
from importlib import import_module

from .logging import get_logger


lowercase__		:Optional[Any]			  =   get_logger(__name__)







class     lowercase		:




					def __init__(    self       ,A__       ,A__=None):
										lowercase						     =						attrs or []
										if module is not None:
															for key in module.__dict__:
																				if key in attrs or not key.startswith('''__'''):
																									setattr(self       ,A__       ,getattr(A__       ,A__))
										lowercase						     =						module._original_module if isinstance(A__       ,_PatchedModuleObj) else module







class     lowercase		:
					lowercase_	:	Union[str, Any]	 =[]




					def __init__(    self       ,A__       ,A__       ,A__       ,A__=None):
										lowercase						     =						obj
										lowercase						     =						target
										lowercase						     =						new
										lowercase						     =						target.split('''.''')[0]
										lowercase						     =						{}
										lowercase						     =						attrs or []




					def __enter__(    self):
										*lowercase     ,						lowercase						     =						self.target.split('''.''')

										# Patch modules:
										# it's used to patch attributes of submodules like "os.path.join";
										# in this case we need to patch "os" and "os.path"

										for i in range(len(A__)):
															try:
																				lowercase						     =						import_module('''.'''.join(submodules[: i + 1]))
															except ModuleNotFoundError:
																				continue
															# We iterate over all the globals in self.obj in case we find "os" or "os.path"
															for attr in self.obj.__dir__():
																				lowercase						     =						getattr(self.obj       ,A__)
																				# We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
																				# This allows to patch renamed modules like "from os import path as ospath".
																				if obj_attr is submodule or (
																				    (isinstance(A__       ,_PatchedModuleObj) and obj_attr._original_module is submodule)
																				):
																									lowercase						     =						obj_attr
																									# patch at top level
																									setattr(self.obj       ,A__       ,_PatchedModuleObj(A__       ,attrs=self.attrs))
																									lowercase						     =						getattr(self.obj       ,A__)
																									# construct lower levels patches
																									for key in submodules[i + 1 :]:
																														setattr(A__       ,A__       ,_PatchedModuleObj(getattr(A__       ,A__       ,A__)       ,attrs=self.attrs))
																														lowercase						     =						getattr(A__       ,A__)
																									# finally set the target attribute
																									setattr(A__       ,A__       ,self.new)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

										if submodules:  # if it's an attribute of a submodule like "os.path.join"
															try:
																				lowercase						     =						getattr(import_module('''.'''.join(A__))       ,A__)
															except (AttributeError, ModuleNotFoundError):
																				return
															# We iterate over all the globals in self.obj in case we find "os.path.join"
															for attr in self.obj.__dir__():
																				# We don't check for the name of the global, but rather if its value *is* "os.path.join".
																				# This allows to patch renamed attributes like "from os.path import join as pjoin".
																				if getattr(self.obj       ,A__) is attr_value:
																									lowercase						     =						getattr(self.obj       ,A__)
																									setattr(self.obj       ,A__       ,self.new)
										elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
															lowercase						     =						globals()['''__builtins__'''][target_attr]
															setattr(self.obj       ,A__       ,self.new)
										else:
															raise RuntimeError(f'Tried to patch attribute {target_attr} instead of a submodule.')




					def __exit__(    self       ,*A__):
										for attr in list(self.original):
															setattr(self.obj       ,A__       ,self.original.pop(A__))




					def 			A__				(    self):
										self.__enter__()
										self._active_patches.append(self)





					def 			A__				(    self):
										try:
															self._active_patches.remove(self)
										except ValueError:
															# If the patch hasn't been started this will fail
															return None

										return self.__exit__()






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase__		:Any			  =   {
    "configuration_distilbert": [
        "DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "DistilBertConfig",
        "DistilBertOnnxConfig",
    ],
    "tokenization_distilbert": ["DistilBertTokenizer"],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Tuple			  =   ["DistilBertTokenizerFast"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Union[str, Any]			  =   [
							    "DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "DistilBertForMaskedLM",
							    "DistilBertForMultipleChoice",
							    "DistilBertForQuestionAnswering",
							    "DistilBertForSequenceClassification",
							    "DistilBertForTokenClassification",
							    "DistilBertModel",
							    "DistilBertPreTrainedModel",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Optional[int]			  =   [
							    "TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "TFDistilBertForMaskedLM",
							    "TFDistilBertForMultipleChoice",
							    "TFDistilBertForQuestionAnswering",
							    "TFDistilBertForSequenceClassification",
							    "TFDistilBertForTokenClassification",
							    "TFDistilBertMainLayer",
							    "TFDistilBertModel",
							    "TFDistilBertPreTrainedModel",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:Union[str, Any]			  =   [
							    "FlaxDistilBertForMaskedLM",
							    "FlaxDistilBertForMultipleChoice",
							    "FlaxDistilBertForQuestionAnswering",
							    "FlaxDistilBertForSequenceClassification",
							    "FlaxDistilBertForTokenClassification",
							    "FlaxDistilBertModel",
							    "FlaxDistilBertPreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_distilbert import (
							    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    DistilBertConfig,
							    DistilBertOnnxConfig,
							)
							from .tokenization_distilbert import DistilBertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_distilbert_fast import DistilBertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_distilbert import (
														    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DistilBertForMaskedLM,
														    DistilBertForMultipleChoice,
														    DistilBertForQuestionAnswering,
														    DistilBertForSequenceClassification,
														    DistilBertForTokenClassification,
														    DistilBertModel,
														    DistilBertPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_distilbert import (
														    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFDistilBertForMaskedLM,
														    TFDistilBertForMultipleChoice,
														    TFDistilBertForQuestionAnswering,
														    TFDistilBertForSequenceClassification,
														    TFDistilBertForTokenClassification,
														    TFDistilBertMainLayer,
														    TFDistilBertModel,
														    TFDistilBertPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_distilbert import (
														    FlaxDistilBertForMaskedLM,
														    FlaxDistilBertForMultipleChoice,
														    FlaxDistilBertForQuestionAnswering,
														    FlaxDistilBertForSequenceClassification,
														    FlaxDistilBertForTokenClassification,
														    FlaxDistilBertModel,
														    FlaxDistilBertPreTrainedModel,
														)

else:
							import sys

							lowercase__		:List[str]			  =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




