
from typing import TYPE_CHECKING

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


__lowerCamelCase								=					{
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCamelCase								=					[
				    'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DonutSwinModel',
				    'DonutSwinPreTrainedModel',
				]

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCamelCase								=					['DonutFeatureExtractor']
				__lowerCamelCase								=					['DonutImageProcessor']


if TYPE_CHECKING:
				from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
				from .processing_donut import DonutProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_donut_swin import (
								    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DonutSwinModel,
								    DonutSwinPreTrainedModel,
								)

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_donut import DonutFeatureExtractor
								from .image_processing_donut import DonutImageProcessor

else:
				import sys

				__lowerCamelCase								=					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






from ..utils import DummyObject, requires_backends
class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  str	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  Tuple							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  int							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  str	,					*_UpperCAmelCase    :  Optional[int]	,					**_UpperCAmelCase    :  Union[str, Any]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Union[str, Any]	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  List[Any]							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Tuple							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Tuple							)		->						List[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Union[str, Any]							)		->						int:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Dict	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  Optional[int]							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  Dict	,					**_UpperCAmelCase    :  str							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





							def __init__(					self    :  Dict	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Tuple							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Union[str, Any]	,					*_UpperCAmelCase    :  Optional[Any]	,					**_UpperCAmelCase    :  Dict							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





							def __init__(					self    :  Optional[int]	,					*_UpperCAmelCase    :  str	,					**_UpperCAmelCase    :  Optional[int]							)		->						Optional[int]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Dict							)		->						Union[str, Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Optional[Any]	,					*_UpperCAmelCase    :  int	,					**_UpperCAmelCase    :  Optional[int]							)		->						Dict:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Any							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  List[Any]	,					**_UpperCAmelCase    :  Any							)		->						Any:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





							def __init__(					self    :  List[Any]	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Dict							)		->						Optional[Any]:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)





