





from ..utils import DummyObject, requires_backends
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			List[str]       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      Tuple		,   *_A      :      Optional[int]		,   **_A      :      str	)							->    List[Any]:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      List[Any]		,   *_A      :      List[Any]		,   **_A      :      Union[str, Any]	)							->    Union[str, Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[Any]		,   *_A      :      Optional[Any]		,   **_A      :      Union[str, Any]	)							->    Optional[Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			int       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      Dict		,   *_A      :      List[str]		,   **_A      :      List[Any]	)							->    Any:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[Any]		,   *_A      :      Tuple		,   **_A      :      Dict	)							->    str:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[Any]		,   *_A      :      str		,   **_A      :      Any	)							->    str:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			Optional[int]       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      Optional[Any]		,   *_A      :      int		,   **_A      :      Tuple	)							->    Optional[int]:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[int]		,   *_A      :      List[str]		,   **_A      :      List[str]	)							->    Tuple:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      str		,   *_A      :      Optional[int]		,   **_A      :      List[Any]	)							->    Optional[int]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			List[Any]       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      List[str]		,   *_A      :      str		,   **_A      :      List[str]	)							->    int:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Dict		,   *_A      :      Tuple		,   **_A      :      str	)							->    Optional[Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      int		,   *_A      :      Dict		,   **_A      :      List[Any]	)							->    Union[str, Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			Any       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      str		,   *_A      :      str		,   **_A      :      List[str]	)							->    Union[str, Any]:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Union[str, Any]		,   *_A      :      Any		,   **_A      :      Tuple	)							->    int:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Optional[int]		,   *_A      :      int		,   **_A      :      Optional[int]	)							->    Optional[Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)
class SCREAMING_SNAKE_CASE_						(					metaclass=snake_case_					):
						__magic_name__:			Optional[Any]       =       ["torch", "transformers", "onnx"]






						def __init__(      self      :      int		,   *_A      :      Optional[int]		,   **_A      :      Tuple	)							->    Tuple:







							"""simple docstring"""


							requires_backends(self		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      Any		,   *_A      :      int		,   **_A      :      List[str]	)							->    str:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)






						@classmethod
						def UpperCAmelCase_				(      cls      :      List[str]		,   *_A      :      Union[str, Any]		,   **_A      :      Union[str, Any]	)							->    Union[str, Any]:







							"""simple docstring"""


							requires_backends(cls		,   ['torch', 'transformers', 'onnx']	)








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_SCREAMING_SNAKE_CASE      	=		{"""configuration_swin""": ["""SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SwinConfig""", """SwinOnnxConfig"""]}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_SCREAMING_SNAKE_CASE      	=		[
						    """SWIN_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """SwinForImageClassification""",
						    """SwinForMaskedImageModeling""",
						    """SwinModel""",
						    """SwinPreTrainedModel""",
						    """SwinBackbone""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_SCREAMING_SNAKE_CASE      	=		[
						    """TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """TFSwinForImageClassification""",
						    """TFSwinForMaskedImageModeling""",
						    """TFSwinModel""",
						    """TFSwinPreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_swin import (
												    SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SwinBackbone,
												    SwinForImageClassification,
												    SwinForMaskedImageModeling,
												    SwinModel,
												    SwinPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_swin import (
												    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFSwinForImageClassification,
												    TFSwinForMaskedImageModeling,
												    TFSwinModel,
												    TFSwinPreTrainedModel,
												)

else:
						import sys

						_SCREAMING_SNAKE_CASE      	=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

