



'''simple docstring'''







from ..utils import DummyObject, requires_backends




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Any		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							int      ,       **SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							List[Any]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		int		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Union[str, Any]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Tuple      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Optional[Any]      ,       *SCREAMING_SNAKE_CASE  :							Tuple      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Dict		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							List[Any]      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Union[str, Any]		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							Dict      ,       **SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Union[str, Any]		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							str      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Optional[Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Optional[int]      ,       *SCREAMING_SNAKE_CASE  :							str      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							int      ,       **SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		str		=      ['tokenizers']






			def __init__(   self  :							Optional[int]      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Tuple      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							int      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Any		=      ['tokenizers']






			def __init__(   self  :							Optional[Any]      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Any		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							Dict      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		str		=      ['tokenizers']






			def __init__(   self  :							int      ,       *SCREAMING_SNAKE_CASE  :							int      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		str		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Tuple      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Any		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							Any	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Dict		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							int      ,       *SCREAMING_SNAKE_CASE  :							Dict      ,       **SCREAMING_SNAKE_CASE  :							List[str]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Union[str, Any]		=      ['tokenizers']






			def __init__(   self  :							int      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							Dict      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Union[str, Any]		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Dict      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							List[Any]      ,       *SCREAMING_SNAKE_CASE  :							int      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							str      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[Any]		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Optional[Any]      ,       *SCREAMING_SNAKE_CASE  :							Any      ,       **SCREAMING_SNAKE_CASE  :							Optional[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Optional[int]		=      ['tokenizers']






			def __init__(   self  :							Optional[int]      ,       *SCREAMING_SNAKE_CASE  :							Optional[int]      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Optional[int]      ,       *SCREAMING_SNAKE_CASE  :							Dict      ,       **SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							Union[str, Any]      ,       **SCREAMING_SNAKE_CASE  :							int	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[Any]		=      ['tokenizers']






			def __init__(   self  :							Any      ,       *SCREAMING_SNAKE_CASE  :							str      ,       **SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		List[str]		=      ['tokenizers']






			def __init__(   self  :							List[str]      ,       *SCREAMING_SNAKE_CASE  :							Tuple      ,       **SCREAMING_SNAKE_CASE  :							Optional[int]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Any		=      ['tokenizers']






			def __init__(   self  :							Optional[int]      ,       *SCREAMING_SNAKE_CASE  :							str      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		Tuple		=      ['tokenizers']






			def __init__(   self  :							Dict      ,       *SCREAMING_SNAKE_CASE  :							str      ,       **SCREAMING_SNAKE_CASE  :							Dict	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		str		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       **SCREAMING_SNAKE_CASE  :							List[Any]	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)




class 				__lowerCAmelCase(							metaclass=lowerCAmelCase__      ):
			__snake_case  :		str		=      ['tokenizers']






			def __init__(   self  :							Union[str, Any]      ,       *SCREAMING_SNAKE_CASE  :							List[str]      ,       **SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







					requires_backends(self      ,       ['tokenizers']	)







"""simple docstring"""




from typing import TYPE_CHECKING

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


UpperCamelCase_	 ={
    """configuration_camembert""": ["""CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CamembertConfig""", """CamembertOnnxConfig"""],
}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase_	 =["""CamembertTokenizer"""]

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase_	 =["""CamembertTokenizerFast"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase_	 =[
						    """CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """CamembertForCausalLM""",
						    """CamembertForMaskedLM""",
						    """CamembertForMultipleChoice""",
						    """CamembertForQuestionAnswering""",
						    """CamembertForSequenceClassification""",
						    """CamembertForTokenClassification""",
						    """CamembertModel""",
						    """CamembertPreTrainedModel""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase_	 =[
						    """TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """TFCamembertForCausalLM""",
						    """TFCamembertForMaskedLM""",
						    """TFCamembertForMultipleChoice""",
						    """TFCamembertForQuestionAnswering""",
						    """TFCamembertForSequenceClassification""",
						    """TFCamembertForTokenClassification""",
						    """TFCamembertModel""",
						    """TFCamembertPreTrainedModel""",
						]


if TYPE_CHECKING:
						from .configuration_camembert import CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CamembertConfig, CamembertOnnxConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_camembert import CamembertTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_camembert_fast import CamembertTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_camembert import (
												    CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    CamembertForCausalLM,
												    CamembertForMaskedLM,
												    CamembertForMultipleChoice,
												    CamembertForQuestionAnswering,
												    CamembertForSequenceClassification,
												    CamembertForTokenClassification,
												    CamembertModel,
												    CamembertPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_camembert import (
												    TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFCamembertForCausalLM,
												    TFCamembertForMaskedLM,
												    TFCamembertForMultipleChoice,
												    TFCamembertForQuestionAnswering,
												    TFCamembertForSequenceClassification,
												    TFCamembertForTokenClassification,
												    TFCamembertModel,
												    TFCamembertPreTrainedModel,
												)

else:
						import sys

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



