





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 		__snake_case (		snake_case_					):





 """simple docstring"""


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

 def __init__(   self ,						__lowerCamelCase = None ,						__lowerCamelCase = None ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     super().__init__(self ,						**_A  )
     __A   :						List[Any]									=					repo_info
     __A   :						Tuple									=					token
     __A   :						Any									=					None

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




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

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase = "rb" ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     if not isinstance(self.repo_info ,						_A  ):
         raise NotImplementedError(F"""Open is only implemented for dataset repositories, but got {self.repo_info}"""  )
     __A   :						List[str]									=					hf_hub_url(self.repo_info.id ,						_A ,						revision=self.repo_info.sha  )
     return fsspec.open(
         _A ,						mode=_A ,						headers=get_authentication_headers_for_url(_A ,						use_auth_token=self.token  ) ,						client_kwargs={'''trust_env''': True} ,						).open()

 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						**__lowerCamelCase  ):



     '''simple docstring'''




     self._get_dirs()
     __A   :						Optional[Any]									=					self._strip_protocol(_A  )
     if path in self.dir_cache:
         return self.dir_cache[path]
     else:
         raise FileNotFoundError(_A  )







 def  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase=False ,						**__lowerCamelCase  ):



     '''simple docstring'''




     self._get_dirs()
     __A   :						Dict									=					PurePosixPath(path.strip('''/'''  )  )
     __A   :						Union[str, Any]									=					{}
     for p, f in self.dir_cache.items():
         __A   :						Optional[int]									=					PurePosixPath(p.strip('''/'''  )  )
         __A   :						Optional[int]									=					p.parent
         if root == path:
             __A   :						Tuple									=					f
     __A   :						Any									=					list(paths.values()  )
     if detail:
         return out
     else:
         return sorted(f['''name'''] for f in out  )











"""simple docstring"""



import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_			=      logging.get_logger(__name__)

a_			=      {
    """asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}






class 		__snake_case (		SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 _lowerCamelCase				=					"""sew-d"""

 def __init__(   self ,						__lowerCamelCase=32 ,						__lowerCamelCase=768 ,						__lowerCamelCase=12 ,						__lowerCamelCase=12 ,						__lowerCamelCase=3072 ,						__lowerCamelCase=2 ,						__lowerCamelCase=512 ,						__lowerCamelCase=256 ,						__lowerCamelCase=True ,						__lowerCamelCase=True ,						__lowerCamelCase=("p2c", "c2p") ,						__lowerCamelCase="layer_norm" ,						__lowerCamelCase="gelu_python" ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=0.0 ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=0.0_2 ,						__lowerCamelCase=1e-7 ,						__lowerCamelCase=1e-5 ,						__lowerCamelCase="group" ,						__lowerCamelCase="gelu" ,						__lowerCamelCase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512) ,						__lowerCamelCase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) ,						__lowerCamelCase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) ,						__lowerCamelCase=False ,						__lowerCamelCase=128 ,						__lowerCamelCase=16 ,						__lowerCamelCase=True ,						__lowerCamelCase=0.0_5 ,						__lowerCamelCase=10 ,						__lowerCamelCase=2 ,						__lowerCamelCase=0.0 ,						__lowerCamelCase=10 ,						__lowerCamelCase=0 ,						__lowerCamelCase="mean" ,						__lowerCamelCase=False ,						__lowerCamelCase=False ,						__lowerCamelCase=256 ,						__lowerCamelCase=0 ,						__lowerCamelCase=1 ,						__lowerCamelCase=2 ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     super().__init__(**__lowerCamelCase ,						pad_token_id=__lowerCamelCase ,						bos_token_id=__lowerCamelCase ,						eos_token_id=__lowerCamelCase  )
     __A   :						str									=					hidden_size
     __A   :						List[Any]									=					feat_extract_norm
     __A   :						Tuple									=					feat_extract_activation
     __A   :						Dict									=					list(__lowerCamelCase  )
     __A   :						int									=					list(__lowerCamelCase  )
     __A   :						List[Any]									=					list(__lowerCamelCase  )
     __A   :						Any									=					conv_bias
     __A   :						List[Any]									=					num_conv_pos_embeddings
     __A   :						Any									=					num_conv_pos_embedding_groups
     __A   :						Optional[Any]									=					len(self.conv_dim  )
     __A   :						int									=					num_hidden_layers
     __A   :						Union[str, Any]									=					intermediate_size
     __A   :						Union[str, Any]									=					squeeze_factor
     __A   :						int									=					max_position_embeddings
     __A   :						Tuple									=					position_buckets
     __A   :						Tuple									=					share_att_key
     __A   :						List[str]									=					relative_attention
     __A   :						Optional[Any]									=					norm_rel_ebd
     __A   :						Dict									=					list(__lowerCamelCase  )
     __A   :						str									=					hidden_act
     __A   :						List[str]									=					num_attention_heads
     __A   :						Union[str, Any]									=					hidden_dropout
     __A   :						Optional[int]									=					attention_dropout
     __A   :						Optional[Any]									=					activation_dropout
     __A   :						List[str]									=					feat_proj_dropout
     __A   :						str									=					final_dropout
     __A   :						Tuple									=					layer_norm_eps
     __A   :						int									=					feature_layer_norm_eps
     __A   :						Optional[int]									=					initializer_range
     __A   :						Dict									=					vocab_size

     if (
         (len(self.conv_stride  ) != self.num_feat_extract_layers)
         or (len(self.conv_kernel  ) != self.num_feat_extract_layers)
         or (len(self.conv_dim  ) != self.num_feat_extract_layers)
     ):
         raise ValueError(
             '''Configuration for convolutional layers is incorrect.'''
             '''It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'''
             F"""but is `len(config.conv_dim) = {len(self.conv_dim  )}`, `len(config.conv_stride)"""
             F"""= {len(self.conv_stride  )}`, `len(config.conv_kernel) = {len(self.conv_kernel  )}`."""  )

     # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
     __A   :						int									=					apply_spec_augment
     __A   :						Any									=					mask_time_prob
     __A   :						Optional[int]									=					mask_time_length
     __A   :						Any									=					mask_time_min_masks
     __A   :						int									=					mask_feature_prob
     __A   :						Tuple									=					mask_feature_length
     __A   :						Dict									=					mask_feature_min_masks

     # ctc loss
     __A   :						Tuple									=					ctc_loss_reduction
     __A   :						Union[str, Any]									=					ctc_zero_infinity

     # sequence classification
     __A   :						Tuple									=					use_weighted_layer_sum
     __A   :						List[str]									=					classifier_proj_size







 @property
 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     return functools.reduce(operator.mul ,						self.conv_stride ,						1  )




