

from typing import TYPE_CHECKING

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


_UpperCamelCase					     =						{
    "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"],
}

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

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

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _UpperCamelCase					     =						[
     "LlamaForCausalLM",
     "LlamaModel",
     "LlamaPreTrainedModel",
     "LlamaForSequenceClassification",
 ]


if TYPE_CHECKING:
 from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_llama import LlamaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_llama_fast import LlamaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
 import sys

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








'''simple docstring'''






from ..utils import DummyObject, requires_backends






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Tuple     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					int     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					List[str]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					str			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					str			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[int]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Tuple     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					List[Any]     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Dict     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Any			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Any			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Tuple     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Dict			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					int     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					int			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[str]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					List[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[int]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Tuple			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Dict     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					str     ,							*__lowerCamelCase     :					int     ,							**__lowerCamelCase     :					Dict			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[str]     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					Tuple			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Dict     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)
