


"""simple docstring"""







# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


a__    :							Optional[int]            =					get_logger(__name__)




class 			UpperCamelCase_     :

	"""simple docstring"""





	snake_case__    :  Optional[int]    =      "dummy_data"
	snake_case__    :  Union[str, Any]    =      "datasets"
	snake_case__    :  Tuple    =      False




	def __init__(			self      :    Optional[Any]      ,      UpperCAmelCase__      :    Any      ,      UpperCAmelCase__      :    Union[str, Any]      ,      UpperCAmelCase__      :    str      ,      UpperCAmelCase__      :    Tuple = None      ,      UpperCAmelCase__      :    str = False      ,      UpperCAmelCase__      :    Tuple = True      ,      UpperCAmelCase__      :    List[Any] = None      ,      )	->     Tuple:
							__SCREAMING_SNAKE_CASE						       =    0
							__SCREAMING_SNAKE_CASE						       =    dataset_name
							__SCREAMING_SNAKE_CASE						       =    cache_dir
							__SCREAMING_SNAKE_CASE						       =    use_local_dummy_data
							__SCREAMING_SNAKE_CASE						       =    config
							# download_callbacks take a single url as input
							__SCREAMING_SNAKE_CASE						       =    download_callbacks or []
							# if False, it doesn't load existing files and it returns the paths of the dummy files relative
							# to the dummy_data zip file root
							__SCREAMING_SNAKE_CASE						       =    load_existing_dummy_data

							# TODO(PVP, QL) might need to make this more general
							__SCREAMING_SNAKE_CASE						       =    str(SCREAMING_SNAKE_CASE_       )
							# to be downloaded
							__SCREAMING_SNAKE_CASE						       =    None
							__SCREAMING_SNAKE_CASE						       =    None




	@property
	def   UpperCAmelCase_				(			self      :    List[str]       )	->     Union[str, Any]:
							if self._dummy_file is None:
													__SCREAMING_SNAKE_CASE						       =    self.download_dummy_data()
							return self._dummy_file




	@property
	def   UpperCAmelCase_				(			self      :    Any       )	->     Union[str, Any]:
							if self.config is not None:
													# structure is dummy / config_name / version_name
													return os.path.join("dummy"      ,      self.config.name      ,      self.version_name       )
							# structure is dummy / version_name
							return os.path.join("dummy"      ,      self.version_name       )




	@property
	def   UpperCAmelCase_				(			self      :    Dict       )	->     Any:
							return os.path.join(self.dummy_data_folder      ,      "dummy_data.zip"       )




	def   UpperCAmelCase_				(			self      :    str       )	->     Optional[Any]:
							__SCREAMING_SNAKE_CASE						       =    (
							    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
							)

							__SCREAMING_SNAKE_CASE						       =    cached_path(
							    SCREAMING_SNAKE_CASE_      ,      cache_dir=self.cache_dir      ,      extract_compressed_file=SCREAMING_SNAKE_CASE_      ,      force_extract=SCREAMING_SNAKE_CASE_       )

							return os.path.join(SCREAMING_SNAKE_CASE_      ,      self.dummy_file_name       )




	@property
	def   UpperCAmelCase_				(			self      :    Tuple       )	->     Any:
							return os.path.join(self.datasets_scripts_dir      ,      self.dataset_name      ,      self.dummy_zip_file       )




	@property
	def   UpperCAmelCase_				(			self      :    Tuple       )	->     Tuple:
							if self._bucket_url is None:
													__SCREAMING_SNAKE_CASE						       =    hf_github_url(self.dataset_name      ,      self.dummy_zip_file.replace(os.sep      ,      "/"       )       )
							return self._bucket_url




	@property
	def   UpperCAmelCase_				(			self      :    Tuple       )	->     Dict:
							# return full path if its a dir
							if os.path.isdir(self.dummy_file       ):
													return self.dummy_file
							# else cut off path to file -> example `xsum`.
							return "/".join(self.dummy_file.replace(os.sep      ,      "/"       ).split("/"       )[:-1]       )




	def   UpperCAmelCase_				(			self      :    Dict      ,      UpperCAmelCase__      :    List[str]      ,      *UpperCAmelCase__      :    Union[str, Any]       )	->     int:
							if self.load_existing_dummy_data:
													# dummy data is downloaded and tested
													__SCREAMING_SNAKE_CASE						       =    self.dummy_file
							else:
													# dummy data cannot be downloaded and only the path to dummy file is returned
													__SCREAMING_SNAKE_CASE						       =    self.dummy_file_name

							# special case when data_url is a dict
							if isinstance(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       ):
													return self.create_dummy_data_dict(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )
							elif isinstance(SCREAMING_SNAKE_CASE_      ,      (list, tuple)       ):
													return self.create_dummy_data_list(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )
							else:
													return self.create_dummy_data_single(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )




	def   UpperCAmelCase_				(			self      :    List[Any]      ,      UpperCAmelCase__      :    Union[str, Any]      ,      *UpperCAmelCase__      :    Tuple       )	->     Optional[Any]:
							return self.download_and_extract(SCREAMING_SNAKE_CASE_       )




	def   UpperCAmelCase_				(			self      :    List[Any]      ,      UpperCAmelCase__      :    Any      ,      UpperCAmelCase__      :    Any       )	->     Optional[Any]:
							return self.download_and_extract(SCREAMING_SNAKE_CASE_       )




	def   UpperCAmelCase_				(			self      :    Tuple      ,      UpperCAmelCase__      :    Optional[int]      ,      *UpperCAmelCase__      :    Union[str, Any]      ,      **UpperCAmelCase__      :    Tuple       )	->     Any:
							return path




	def   UpperCAmelCase_				(			self      :    str       )	->     List[Any]:
							return {}




	def   UpperCAmelCase_				(			self      :    str      ,      UpperCAmelCase__      :    str      ,      UpperCAmelCase__      :    Union[str, Any]       )	->     Dict:
							__SCREAMING_SNAKE_CASE						       =    {}
							for key, single_urls in data_url.items():
													for download_callback in self.download_callbacks:
																			if isinstance(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       ):
																									for single_url in single_urls:
																															download_callback(SCREAMING_SNAKE_CASE_       )
																			else:
																									__SCREAMING_SNAKE_CASE						       =    single_urls
																									download_callback(SCREAMING_SNAKE_CASE_       )
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
													if isinstance(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       ):
																			__SCREAMING_SNAKE_CASE						       =    [os.path.join(SCREAMING_SNAKE_CASE_      ,      urllib.parse.quote_plus(Path(SCREAMING_SNAKE_CASE_       ).name       )       ) for x in single_urls]
													else:
																			__SCREAMING_SNAKE_CASE						       =    single_urls
																			__SCREAMING_SNAKE_CASE						       =    os.path.join(SCREAMING_SNAKE_CASE_      ,      urllib.parse.quote_plus(Path(SCREAMING_SNAKE_CASE_       ).name       )       )
													__SCREAMING_SNAKE_CASE						       =    value

							# make sure that values are unique
							if all(isinstance(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       ) for i in dummy_data_dict.values()       ) and len(set(dummy_data_dict.values()       )       ) < len(
							    dummy_data_dict.values()       ):
													# append key to value to make its name unique
													__SCREAMING_SNAKE_CASE						       =    {key: value + key for key, value in dummy_data_dict.items()}

							return dummy_data_dict




	def   UpperCAmelCase_				(			self      :    Optional[Any]      ,      UpperCAmelCase__      :    Union[str, Any]      ,      UpperCAmelCase__      :    Any       )	->     Optional[Any]:
							__SCREAMING_SNAKE_CASE						       =    []
							# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
							__SCREAMING_SNAKE_CASE						       =    all(bool(re.findall("[0-9]{3,}-of-[0-9]{3,}"      ,      SCREAMING_SNAKE_CASE_       )       ) for url in data_url       )
							__SCREAMING_SNAKE_CASE						       =    all(
							    url.startswith("https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed"       ) for url in data_url       )
							if data_url and (is_tf_records or is_pubmed_records):
													__SCREAMING_SNAKE_CASE						       =    [data_url[0]] * len(SCREAMING_SNAKE_CASE_       )
							for single_url in data_url:
													for download_callback in self.download_callbacks:
																			download_callback(SCREAMING_SNAKE_CASE_       )
													# we force the name of each key to be the last file / folder name of the url path
													# if the url has arguments, we need to encode them with urllib.parse.quote_plus
													__SCREAMING_SNAKE_CASE						       =    os.path.join(SCREAMING_SNAKE_CASE_      ,      urllib.parse.quote_plus(single_url.split("/"       )[-1]       )       )
													dummy_data_list.append(SCREAMING_SNAKE_CASE_       )
							return dummy_data_list




	def   UpperCAmelCase_				(			self      :    Optional[Any]      ,      UpperCAmelCase__      :    int      ,      UpperCAmelCase__      :    List[Any]       )	->     Tuple:
							for download_callback in self.download_callbacks:
													download_callback(SCREAMING_SNAKE_CASE_       )
							# we force the name of each key to be the last file / folder name of the url path
							# if the url has arguments, we need to encode them with urllib.parse.quote_plus
							__SCREAMING_SNAKE_CASE						       =    os.path.join(SCREAMING_SNAKE_CASE_      ,      urllib.parse.quote_plus(data_url.split("/"       )[-1]       )       )
							if os.path.exists(SCREAMING_SNAKE_CASE_       ) or not self.load_existing_dummy_data:
													return value
							else:
													# Backward compatibility, maybe deprecate at one point.
													# For many datasets with single url calls to dl_manager.download_and_extract,
													# the dummy_data.zip file is actually the zipped downloaded file
													# while now we expected the dummy_data.zip file to be a directory containing
													# the downloaded file.
													return path_to_dummy_data




	def   UpperCAmelCase_				(			self      :    Optional[int]       )	->     Optional[Any]:
							pass




	def   UpperCAmelCase_				(			self      :    Optional[Any]       )	->     Dict:
							pass




	def   UpperCAmelCase_				(			self      :    Optional[Any]      ,      UpperCAmelCase__      :    List[Any]       )	->     Any:
							def _iter_archive_members(UpperCAmelCase__      :    List[str]       ):
													# this preserves the order of the members inside the ZIP archive
													__SCREAMING_SNAKE_CASE						       =    Path(self.dummy_file       ).parent
													__SCREAMING_SNAKE_CASE						       =    path.relative_to(SCREAMING_SNAKE_CASE_       )
													with ZipFile(self.local_path_to_dummy_data       ) as zip_file:
																			__SCREAMING_SNAKE_CASE						       =    zip_file.namelist()
													for member in members:
																			if member.startswith(relative_path.as_posix()       ):
																									yield dummy_parent_path.joinpath(SCREAMING_SNAKE_CASE_       )

							__SCREAMING_SNAKE_CASE						       =    Path(SCREAMING_SNAKE_CASE_       )
							__SCREAMING_SNAKE_CASE						       =    _iter_archive_members(SCREAMING_SNAKE_CASE_       ) if self.use_local_dummy_data else path.rglob("*"       )
							for file_path in file_paths:
													if file_path.is_file() and not file_path.name.startswith((".", "__")       ):
																			yield file_path.relative_to(SCREAMING_SNAKE_CASE_       ).as_posix(), file_path.open("rb"       )




	def   UpperCAmelCase_				(			self      :    Optional[int]      ,      UpperCAmelCase__      :    Tuple       )	->     Dict:
							if not isinstance(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       ):
													__SCREAMING_SNAKE_CASE						       =    [paths]
							for path in paths:
													if os.path.isfile(SCREAMING_SNAKE_CASE_       ):
																			if os.path.basename(SCREAMING_SNAKE_CASE_       ).startswith((".", "__")       ):
																									return
																			yield path
													else:
																			for dirpath, dirnames, filenames in os.walk(SCREAMING_SNAKE_CASE_       ):
																									if os.path.basename(SCREAMING_SNAKE_CASE_       ).startswith((".", "__")       ):
																															continue
																									dirnames.sort()
																									for filename in sorted(SCREAMING_SNAKE_CASE_       ):
																															if filename.startswith((".", "__")       ):
																																					continue
																															yield os.path.join(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_       )




"""simple docstring"""







from typing import List

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


a__    :							Tuple            =					logging.get_logger(__name__)

a__    :							List[Any]            =					{
    '''snap-research/efficientformer-l1-300''': (
        '''https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json'''
    ),
}




class 			UpperCamelCase_     (			UpperCamelCase):

	"""simple docstring"""





	snake_case__    :  Any    =      "efficientformer"




	def __init__(			self      :    Any      ,      UpperCAmelCase__      :    List[int] = [3, 2, 6, 4]      ,      UpperCAmelCase__      :    List[int] = [4_8, 9_6, 2_2_4, 4_4_8]      ,      UpperCAmelCase__      :    List[bool] = [True, True, True, True]      ,      UpperCAmelCase__      :    int = 4_4_8      ,      UpperCAmelCase__      :    int = 3_2      ,      UpperCAmelCase__      :    int = 4      ,      UpperCAmelCase__      :    int = 7      ,      UpperCAmelCase__      :    int = 5      ,      UpperCAmelCase__      :    int = 8      ,      UpperCAmelCase__      :    int = 4      ,      UpperCAmelCase__      :    float = 0.0      ,      UpperCAmelCase__      :    int = 1_6      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 3      ,      UpperCAmelCase__      :    int = 2      ,      UpperCAmelCase__      :    int = 1      ,      UpperCAmelCase__      :    float = 0.0      ,      UpperCAmelCase__      :    int = 1      ,      UpperCAmelCase__      :    bool = True      ,      UpperCAmelCase__      :    bool = True      ,      UpperCAmelCase__      :    float = 1E-5      ,      UpperCAmelCase__      :    str = "gelu"      ,      UpperCAmelCase__      :    float = 0.02      ,      UpperCAmelCase__      :    float = 1E-12      ,      UpperCAmelCase__      :    int = 2_2_4      ,      UpperCAmelCase__      :    float = 1E-05      ,      **UpperCAmelCase__      :    Tuple      ,      )	->     None:
						super().__init__(**UpperCAmelCase__       )

						__SCREAMING_SNAKE_CASE						       =    hidden_act
						__SCREAMING_SNAKE_CASE						       =    hidden_dropout_prob
						__SCREAMING_SNAKE_CASE						       =    hidden_sizes
						__SCREAMING_SNAKE_CASE						       =    num_hidden_layers
						__SCREAMING_SNAKE_CASE						       =    num_attention_heads
						__SCREAMING_SNAKE_CASE						       =    initializer_range
						__SCREAMING_SNAKE_CASE						       =    layer_norm_eps
						__SCREAMING_SNAKE_CASE						       =    patch_size
						__SCREAMING_SNAKE_CASE						       =    num_channels
						__SCREAMING_SNAKE_CASE						       =    depths
						__SCREAMING_SNAKE_CASE						       =    mlp_expansion_ratio
						__SCREAMING_SNAKE_CASE						       =    downsamples
						__SCREAMING_SNAKE_CASE						       =    dim
						__SCREAMING_SNAKE_CASE						       =    key_dim
						__SCREAMING_SNAKE_CASE						       =    attention_ratio
						__SCREAMING_SNAKE_CASE						       =    resolution
						__SCREAMING_SNAKE_CASE						       =    pool_size
						__SCREAMING_SNAKE_CASE						       =    downsample_patch_size
						__SCREAMING_SNAKE_CASE						       =    downsample_stride
						__SCREAMING_SNAKE_CASE						       =    downsample_pad
						__SCREAMING_SNAKE_CASE						       =    drop_path_rate
						__SCREAMING_SNAKE_CASE						       =    num_metaad_blocks
						__SCREAMING_SNAKE_CASE						       =    distillation
						__SCREAMING_SNAKE_CASE						       =    use_layer_scale
						__SCREAMING_SNAKE_CASE						       =    layer_scale_init_value
						__SCREAMING_SNAKE_CASE						       =    image_size
						__SCREAMING_SNAKE_CASE						       =    batch_norm_eps
