

"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_speech_available, is_torch_available


__A						       =      {
    "configuration_audio_spectrogram_transformer": [
        "AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "ASTConfig",
    ]
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__A						       =      [
					    "AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "ASTForAudioClassification",
					    "ASTModel",
					    "ASTPreTrainedModel",
					]

try:
					if not is_speech_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__A						       =      ["ASTFeatureExtractor"]

if TYPE_CHECKING:
					from .configuration_audio_spectrogram_transformer import (
					    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    ASTConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_audio_spectrogram_transformer import (
										    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    ASTForAudioClassification,
										    ASTModel,
										    ASTPreTrainedModel,
										)

					try:
										if not is_speech_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_audio_spectrogram_transformer import ASTFeatureExtractor


else:
					import sys

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





"""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						       =      get_logger(__name__)





class    snake_case     :
				SCREAMING_SNAKE_CASE_       :				List[Any]       				=  """dummy_data"""
				SCREAMING_SNAKE_CASE_       :				List[Any]       				=  """datasets"""
				SCREAMING_SNAKE_CASE_       :				Any       				=  False

				def __init__(     self							:    List[str]					,  UpperCamelCase__							:    str					,  UpperCamelCase__							:    str					,  UpperCamelCase__							:    Union[Version, str]					,  UpperCamelCase__							:    Optional[str] = None					,  UpperCamelCase__							:    bool = False					,  UpperCamelCase__							:    bool = True					,  UpperCamelCase__							:    Optional[List[Callable]] = None					,  )->       Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[Any]   				=      0
						__lowerCAmelCase:	Tuple   				=      dataset_name
						__lowerCAmelCase:	Optional[Any]   				=      cache_dir
						__lowerCAmelCase:	Optional[int]   				=      use_local_dummy_data
						__lowerCAmelCase:	Optional[Any]   				=      config
						# download_callbacks take a single url as input
						__lowerCAmelCase:	List[Callable]   				=      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
						__lowerCAmelCase:	Union[str, Any]   				=      load_existing_dummy_data

						# TODO(PVP, QL) might need to make this more general
						__lowerCAmelCase:	List[str]   				=      str(UpperCamelCase__)
						# to be downloaded
						__lowerCAmelCase:	Dict   				=      None
						__lowerCAmelCase:	Dict   				=      None

				@property
				def 							lowercase_					(     self							:    List[str])->       str:



						'''simple docstring'''


						if self._dummy_file is None:
								__lowerCAmelCase:	Tuple   				=      self.download_dummy_data()
						return self._dummy_file

				@property
				def 							lowercase_					(     self							:    Dict)->       Optional[Any]:



						'''simple docstring'''


						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 							lowercase_					(     self							:    List[str])->       Any:



						'''simple docstring'''


						return os.path.join(self.dummy_data_folder					,  "dummy_data.zip")

				def 							lowercase_					(     self							:    Optional[Any])->       List[str]:



						'''simple docstring'''


						__lowerCAmelCase:	Dict   				=      (
						    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
						)

						__lowerCAmelCase:	str   				=      cached_path(
						    UpperCamelCase__					,  cache_dir=self.cache_dir					,  extract_compressed_file=UpperCamelCase__					,  force_extract=UpperCamelCase__)

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

				@property
				def 							lowercase_					(     self							:    Dict)->       List[Any]:



						'''simple docstring'''


						return os.path.join(self.datasets_scripts_dir					,  self.dataset_name					,  self.dummy_zip_file)

				@property
				def 							lowercase_					(     self							:    Optional[Any])->       Tuple:



						'''simple docstring'''


						if self._bucket_url is None:
								__lowerCAmelCase:	int   				=      hf_github_url(self.dataset_name					,  self.dummy_zip_file.replace(os.sep					,  "/"))
						return self._bucket_url

				@property
				def 							lowercase_					(     self							:    str)->       Optional[int]:



						'''simple docstring'''


						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 							lowercase_					(     self							:    List[Any]					,  UpperCamelCase__							:    int					,  *UpperCamelCase__							:    List[str])->       Optional[int]:



						'''simple docstring'''


						if self.load_existing_dummy_data:
								# dummy data is downloaded and tested
								__lowerCAmelCase:	List[Any]   				=      self.dummy_file
						else:
								# dummy data cannot be downloaded and only the path to dummy file is returned
								__lowerCAmelCase:	str   				=      self.dummy_file_name

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

				def 							lowercase_					(     self							:    Dict					,  UpperCamelCase__							:    Dict					,  *UpperCamelCase__							:    int)->       Dict:



						'''simple docstring'''


						return self.download_and_extract(UpperCamelCase__)

				def 							lowercase_					(     self							:    Optional[Any]					,  UpperCamelCase__							:    Dict					,  UpperCamelCase__							:    Optional[Any])->       str:



						'''simple docstring'''


						return self.download_and_extract(UpperCamelCase__)

				def 							lowercase_					(     self							:    Optional[Any]					,  UpperCamelCase__							:    List[Any]					,  *UpperCamelCase__							:    int					,  **UpperCamelCase__							:    str)->       List[str]:



						'''simple docstring'''


						return path

				def 							lowercase_					(     self							:    Optional[Any])->       Any:



						'''simple docstring'''


						return {}

				def 							lowercase_					(     self							:    Any					,  UpperCamelCase__							:    Tuple					,  UpperCamelCase__							:    int)->       Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[int]   				=      {}
						for key, single_urls in data_url.items():
								for download_callback in self.download_callbacks:
										if isinstance(UpperCamelCase__					,  UpperCamelCase__):
												for single_url in single_urls:
														download_callback(UpperCamelCase__)
										else:
												__lowerCAmelCase:	Union[str, Any]   				=      single_urls
												download_callback(UpperCamelCase__)
            # 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(UpperCamelCase__					,  UpperCamelCase__):
										__lowerCAmelCase:	Dict   				=      [os.path.join(UpperCamelCase__					,  urllib.parse.quote_plus(Path(UpperCamelCase__).name)) for x in single_urls]
								else:
										__lowerCAmelCase:	Any   				=      single_urls
										__lowerCAmelCase:	Optional[int]   				=      os.path.join(UpperCamelCase__					,  urllib.parse.quote_plus(Path(UpperCamelCase__).name))
								__lowerCAmelCase:	Dict   				=      value

						# make sure that values are unique
						if all(isinstance(UpperCamelCase__					,  UpperCamelCase__) 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
								__lowerCAmelCase:	Any   				=      {key: value + key for key, value in dummy_data_dict.items()}

						return dummy_data_dict

				def 							lowercase_					(     self							:    Optional[int]					,  UpperCamelCase__							:    int					,  UpperCamelCase__							:    List[Any])->       int:



						'''simple docstring'''


						__lowerCAmelCase:	Tuple   				=      []
						# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
						__lowerCAmelCase:	Any   				=      all(bool(re.findall("[0-9]{3,}-of-[0-9]{3,}"					,  UpperCamelCase__)) for url in data_url)
						__lowerCAmelCase:	str   				=      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):
								__lowerCAmelCase:	Optional[int]   				=      [data_url[0]] * len(UpperCamelCase__)
						for single_url in data_url:
								for download_callback in self.download_callbacks:
										download_callback(UpperCamelCase__)
								# 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
								__lowerCAmelCase:	Optional[Any]   				=      os.path.join(UpperCamelCase__					,  urllib.parse.quote_plus(single_url.split("/")[-1]))
								dummy_data_list.append(UpperCamelCase__)
						return dummy_data_list

				def 							lowercase_					(     self							:    str					,  UpperCamelCase__							:    Tuple					,  UpperCamelCase__							:    Union[str, Any])->       Optional[int]:



						'''simple docstring'''


						for download_callback in self.download_callbacks:
								download_callback(UpperCamelCase__)
						# 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
						__lowerCAmelCase:	List[Any]   				=      os.path.join(UpperCamelCase__					,  urllib.parse.quote_plus(data_url.split("/")[-1]))
						if os.path.exists(UpperCamelCase__) 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 							lowercase_					(     self							:    List[str])->       Dict:



						'''simple docstring'''


						pass

				def 							lowercase_					(     self							:    Union[str, Any])->       Tuple:



						'''simple docstring'''


						pass

				def 							lowercase_					(     self							:    Dict					,  UpperCamelCase__							:    str)->       int:



						'''simple docstring'''


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

						__lowerCAmelCase:	str   				=      Path(UpperCamelCase__)
						__lowerCAmelCase:	Optional[Any]   				=      _iter_archive_members(UpperCamelCase__) 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(UpperCamelCase__).as_posix(), file_path.open("rb")




				def 							lowercase_					(     self							:    str					,  UpperCamelCase__							:    str)->       str:



						'''simple docstring'''


						if not isinstance(UpperCamelCase__					,  UpperCamelCase__):
								__lowerCAmelCase:	Dict   				=      [paths]
						for path in paths:
								if os.path.isfile(UpperCamelCase__):
										if os.path.basename(UpperCamelCase__).startswith((".", "__")):
												return
										yield path
								else:
										for dirpath, dirnames, filenames in os.walk(UpperCamelCase__):
												if os.path.basename(UpperCamelCase__).startswith((".", "__")):
														continue
												dirnames.sort()
												for filename in sorted(UpperCamelCase__):
														if filename.startswith((".", "__")):
																continue
														yield os.path.join(UpperCamelCase__					,  UpperCamelCase__)


