




from typing import TYPE_CHECKING

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


lowerCamelCase__			:       Dict         =							{
    'configuration_electra': ['ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ElectraConfig', 'ElectraOnnxConfig'],
    'tokenization_electra': ['ElectraTokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__			:       Union[str, Any]         =							['ElectraTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__			:       Union[str, Any]         =							[
       'ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
       'ElectraForCausalLM',
       'ElectraForMaskedLM',
       'ElectraForMultipleChoice',
       'ElectraForPreTraining',
       'ElectraForQuestionAnswering',
       'ElectraForSequenceClassification',
       'ElectraForTokenClassification',
       'ElectraModel',
       'ElectraPreTrainedModel',
       'load_tf_weights_in_electra',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__			:       List[str]         =							[
       'TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFElectraForMaskedLM',
       'TFElectraForMultipleChoice',
       'TFElectraForPreTraining',
       'TFElectraForQuestionAnswering',
       'TFElectraForSequenceClassification',
       'TFElectraForTokenClassification',
       'TFElectraModel',
       'TFElectraPreTrainedModel',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__			:       str         =							[
       'FlaxElectraForCausalLM',
       'FlaxElectraForMaskedLM',
       'FlaxElectraForMultipleChoice',
       'FlaxElectraForPreTraining',
       'FlaxElectraForQuestionAnswering',
       'FlaxElectraForSequenceClassification',
       'FlaxElectraForTokenClassification',
       'FlaxElectraModel',
       'FlaxElectraPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
   from .tokenization_electra import ElectraTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_electra_fast import ElectraTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_electra import (
          ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
          ElectraForCausalLM,
          ElectraForMaskedLM,
          ElectraForMultipleChoice,
          ElectraForPreTraining,
          ElectraForQuestionAnswering,
          ElectraForSequenceClassification,
          ElectraForTokenClassification,
          ElectraModel,
          ElectraPreTrainedModel,
          load_tf_weights_in_electra,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_electra import (
          TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFElectraForMaskedLM,
          TFElectraForMultipleChoice,
          TFElectraForPreTraining,
          TFElectraForQuestionAnswering,
          TFElectraForSequenceClassification,
          TFElectraForTokenClassification,
          TFElectraModel,
          TFElectraPreTrainedModel,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_electra import (
          FlaxElectraForCausalLM,
          FlaxElectraForMaskedLM,
          FlaxElectraForMultipleChoice,
          FlaxElectraForPreTraining,
          FlaxElectraForQuestionAnswering,
          FlaxElectraForSequenceClassification,
          FlaxElectraForTokenClassification,
          FlaxElectraModel,
          FlaxElectraPreTrainedModel,
      )

else:
   import sys

   lowerCamelCase__			:       str         =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





from pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url





class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE ):


 '''simple docstring'''







 lowercase_       =   ""
 lowercase_       =   "hf-legacy"  # "hf://"" is reserved for hffs



 def __init__(							self  :		Optional[int]    ,    _lowerCAmelCase  :		Optional[DatasetInfo] = None    ,    _lowerCAmelCase  :		Optional[str] = None    ,    **_lowerCAmelCase  :		int    ,    ):
       super().__init__(self    ,    **_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      repo_info
       SCREAMING_SNAKE_CASE_     						=      token
       SCREAMING_SNAKE_CASE_     						=      None



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       if self.dir_cache is None:
             SCREAMING_SNAKE_CASE_     						=      {}
             for hf_file in self.repo_info.siblings:
                   # TODO(QL): add sizes
                   SCREAMING_SNAKE_CASE_     						=      {
                       'name': hf_file.rfilename,
                       'size': None,
                       'type': 'file',
                   }
                   self.dir_cache.update(
                       {
                           str(_lowerCAmelCase						): {'name': str(_lowerCAmelCase						), 'size': None, 'type': 'directory'}
                           for d in list(PurePosixPath(hf_file.rfilename						).parents						)[:-1]
                       }						)



 def 				lowerCAmelCase_  (							self  :		Optional[int]    ,    _lowerCAmelCase  :		str    ,    _lowerCAmelCase  :		str = "rb"    ,    **_lowerCAmelCase  :		Optional[Any]    ,    ):
       if not isinstance(self.repo_info    ,    _lowerCAmelCase						):
             raise NotImplementedError(F"Open is only implemented for dataset repositories, but got {self.repo_info}"						)
       SCREAMING_SNAKE_CASE_     						=      hf_hub_url(self.repo_info.id    ,    _lowerCAmelCase    ,    revision=self.repo_info.sha						)
       return fsspec.open(
           _lowerCAmelCase    ,    mode=_lowerCAmelCase    ,    headers=get_authentication_headers_for_url(_lowerCAmelCase    ,    use_auth_token=self.token						)    ,    client_kwargs={'trust_env': True}    ,    ).open()



 def 				lowerCAmelCase_  (							self  :		List[Any]    ,    _lowerCAmelCase  :		Any    ,    **_lowerCAmelCase  :		Dict						):
       self._get_dirs()
       SCREAMING_SNAKE_CASE_     						=      self._strip_protocol(_lowerCAmelCase						)
       if path in self.dir_cache:
             return self.dir_cache[path]
       else:
             raise FileNotFoundError(_lowerCAmelCase						)




 def 				lowerCAmelCase_  (							self  :		Optional[Any]    ,    _lowerCAmelCase  :		Any    ,    _lowerCAmelCase  :		Any=False    ,    **_lowerCAmelCase  :		str						):
       self._get_dirs()
       SCREAMING_SNAKE_CASE_     						=      PurePosixPath(path.strip('/'						)						)
       SCREAMING_SNAKE_CASE_     						=      {}
       for p, f in self.dir_cache.items():
             SCREAMING_SNAKE_CASE_     						=      PurePosixPath(p.strip('/'						)						)
             SCREAMING_SNAKE_CASE_     						=      p.parent
             if root == path:
                   SCREAMING_SNAKE_CASE_     						=      f
       SCREAMING_SNAKE_CASE_     						=      list(paths.values()						)
       if detail:
             return out
       else:
             return sorted(f['name'] for f in out						)