
"""simple docstring"""




from __future__ import annotations

from collections import deque





class  snake_case     :

							def __init__(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = []
									self.adlist.append(
									    {'''value''': '''''', '''next_states''': [], '''fail_state''': 0, '''output''': []}    )

									for keyword in keywords:
											self.add_keyword(SCREAMING_SNAKE_CASE_    )
									self.set_fail_transitions()

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									for state in self.adlist[current_state]["next_states"]:
											if char == self.adlist[state]["value"]:
													return state
									return None

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = 0
									for character in keyword:
											SCREAMING_SNAKE_CASE_						 = self.find_next_state(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
											if next_state is None:
													self.adlist.append(
													    {
													        '''value''': character,
													        '''next_states''': [],
													        '''fail_state''': 0,
													        '''output''': [],
													    }    )
													self.adlist[current_state]["next_states"].append(len(self.adlist    ) - 1    )
													SCREAMING_SNAKE_CASE_						 = len(self.adlist    ) - 1
											else:
													SCREAMING_SNAKE_CASE_						 = next_state
									self.adlist[current_state]["output"].append(SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = deque()
									for node in self.adlist[0]["next_states"]:
											q.append(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = 0
									while q:
											SCREAMING_SNAKE_CASE_						 = q.popleft()
											for child in self.adlist[r]["next_states"]:
													q.append(SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = self.adlist[r]['''fail_state''']
													while (
													    self.find_next_state(SCREAMING_SNAKE_CASE_       ,       self.adlist[child]['''value''']    ) is None
													    and state != 0
													):
															SCREAMING_SNAKE_CASE_						 = self.adlist[state]['''fail_state''']
													SCREAMING_SNAKE_CASE_						 = self.find_next_state(
													    SCREAMING_SNAKE_CASE_       ,       self.adlist[child]['''value''']    )
													if self.adlist[child]["fail_state"] is None:
															SCREAMING_SNAKE_CASE_						 = 0
													SCREAMING_SNAKE_CASE_						 = (
													    self.adlist[child]['''output''']
													    + self.adlist[self.adlist[child]['''fail_state''']]['''output''']
													)







							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = {}  # returns a dict with keywords and list of its occurrences
									SCREAMING_SNAKE_CASE_						 = 0
									for i in range(len(SCREAMING_SNAKE_CASE_    )    ):
											while (
											    self.find_next_state(SCREAMING_SNAKE_CASE_       ,       string[i]    ) is None
											    and current_state != 0
											):
													SCREAMING_SNAKE_CASE_						 = self.adlist[current_state]['''fail_state''']
											SCREAMING_SNAKE_CASE_						 = self.find_next_state(SCREAMING_SNAKE_CASE_       ,       string[i]    )
											if next_state is None:
													SCREAMING_SNAKE_CASE_						 = 0
											else:
													SCREAMING_SNAKE_CASE_						 = next_state
													for key in self.adlist[current_state]["output"]:
															if key not in result:
																	SCREAMING_SNAKE_CASE_						 = []
															result[key].append(i - len(SCREAMING_SNAKE_CASE_    ) + 1    )
									return result


if __name__ == "__main__":
						import doctest

						doctest.testmod()

"""simple docstring"""




import os
import socket
from contextlib import contextmanager

import torch

from ..commands.config.default import write_basic_config  # noqa: F401
from ..state import PartialState
from .dataclasses import DistributedType
from .imports import is_deepspeed_available, is_tpu_available
from .transformer_engine import convert_model
from .versions import is_torch_version


if is_deepspeed_available():
						from deepspeed import DeepSpeedEngine

if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm



def        _lowerCamelCase ( __a    ):
		if is_torch_version('''<''',							'''2.0.0'''    ) or not hasattr(__a,							'''_dynamo'''    ):
				return False
		return isinstance(__a,							torch._dynamo.eval_frame.OptimizedModule    )



def        _lowerCamelCase ( __a,							__a = True    ):
		SCREAMING_SNAKE_CASE_						 = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)

		SCREAMING_SNAKE_CASE_						 = is_compiled_module(__a    )
		if is_compiled:
				SCREAMING_SNAKE_CASE_						 = model
				SCREAMING_SNAKE_CASE_						 = model._orig_mod

		if is_deepspeed_available():
				options += (DeepSpeedEngine,)

		while isinstance(__a,							__a    ):
				SCREAMING_SNAKE_CASE_						 = model.module

		if not keep_fpaa_wrapper:
				SCREAMING_SNAKE_CASE_						 = getattr(__a,							'''forward'''    )
				SCREAMING_SNAKE_CASE_						 = model.__dict__.pop('''_original_forward''',							__a    )
				if original_forward is not None:
						while hasattr(__a,							'''__wrapped__'''    ):
								SCREAMING_SNAKE_CASE_						 = forward.__wrapped__
								if forward == original_forward:
										break
						SCREAMING_SNAKE_CASE_						 = forward
				if getattr(__a,							'''_converted_to_transformer_engine''',							__a    ):
						convert_model(__a,							to_transformer_engine=__a    )

		if is_compiled:
				SCREAMING_SNAKE_CASE_						 = model
				SCREAMING_SNAKE_CASE_						 = compiled_model

		return model



def        _lowerCamelCase ( ):
		PartialState().wait_for_everyone()



def        _lowerCamelCase ( __a,							__a    ):
		if PartialState().distributed_type == DistributedType.TPU:
				xm.save(__a,							__a    )
		elif PartialState().local_process_index == 0:
				torch.save(__a,							__a    )



@contextmanager
def        _lowerCamelCase ( **__a    ):
		for key, value in kwargs.items():
				SCREAMING_SNAKE_CASE_						 = str(__a    )

		yield

		for key in kwargs:
				if key.upper() in os.environ:
						del os.environ[key.upper()]



def        _lowerCamelCase ( __a    ):
		if not hasattr(__a,							'''__qualname__'''    ) and not hasattr(__a,							'''__name__'''    ):
				SCREAMING_SNAKE_CASE_						 = getattr(__a,							'''__class__''',							__a    )
		if hasattr(__a,							'''__qualname__'''    ):
				return obj.__qualname__
		if hasattr(__a,							'''__name__'''    ):
				return obj.__name__
		return str(__a    )



def        _lowerCamelCase ( __a,							__a    ):
		for key, value in source.items():
				if isinstance(__a,							__a    ):
						SCREAMING_SNAKE_CASE_						 = destination.setdefault(__a,							{}    )
						merge_dicts(__a,							__a    )
				else:
						SCREAMING_SNAKE_CASE_						 = value

		return destination



def        _lowerCamelCase ( __a = None    ):
		if port is None:
				SCREAMING_SNAKE_CASE_						 = 29_500
		with socket.socket(socket.AF_INET,							socket.SOCK_STREAM    ) as s:
				return s.connect_ex(('''localhost''', port)    ) == 0