






'''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


lowerCamelCase_				: int    	=							get_logger(__name__)
class    _SCREAMING_SNAKE_CASE							:


			'''simple docstring'''





			__a							:							Tuple					     =					"dummy_data"
			__a							:							Union[str, Any]					     =					"datasets"
			__a							:							Any					     =					False






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

									'''simple docstring'''







									UpperCamelCase__         = 0
									UpperCamelCase__         = dataset_name
									UpperCamelCase__         = cache_dir
									UpperCamelCase__         = use_local_dummy_data
									UpperCamelCase__         = config
									# download_callbacks take a single url as input
									UpperCamelCase__         = 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
									UpperCamelCase__         = load_existing_dummy_data

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






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

									'''simple docstring'''







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






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

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

									'''simple docstring'''







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






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

									'''simple docstring'''







									UpperCamelCase__         = (
									    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
									)

									UpperCamelCase__         = cached_path(
									    lowercase ,      cache_dir=self.cache_dir ,      extract_compressed_file=lowercase ,      force_extract=lowercase			)

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






			@property
			def 				A      (   self							:						Optional[int]			)							->    List[Any]:

									'''simple docstring'''







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






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

									'''simple docstring'''







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






			@property
			def 				A      (   self							:						int			)							->    Tuple:

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

									'''simple docstring'''







									if self.load_existing_dummy_data:
															# dummy data is downloaded and tested
															UpperCamelCase__         = self.dummy_file
									else:
															# dummy data cannot be downloaded and only the path to dummy file is returned
															UpperCamelCase__         = self.dummy_file_name

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






			def 				A      (   self							:						Union[str, Any] ,      lowercase							:						Optional[Any] ,      *lowercase							:						Any			)							->    Optional[Any]:

									'''simple docstring'''







									return self.download_and_extract(lowercase			)






			def 				A      (   self							:						Optional[Any] ,      lowercase							:						int ,      lowercase							:						Dict			)							->    Tuple:

									'''simple docstring'''







									return self.download_and_extract(lowercase			)






			def 				A      (   self							:						Optional[int] ,      lowercase							:						str ,      *lowercase							:						Union[str, Any] ,      **lowercase							:						Optional[Any]			)							->    Tuple:

									'''simple docstring'''







									return path






			def 				A      (   self							:						Tuple			)							->    List[str]:

									'''simple docstring'''







									return {}






			def 				A      (   self							:						Union[str, Any] ,      lowercase							:						Optional[int] ,      lowercase							:						Optional[Any]			)							->    Optional[Any]:

									'''simple docstring'''







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

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

									return dummy_data_dict






			def 				A      (   self							:						List[Any] ,      lowercase							:						List[str] ,      lowercase							:						List[str]			)							->    str:

									'''simple docstring'''







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






			def 				A      (   self							:						Optional[int] ,      lowercase							:						Optional[Any] ,      lowercase							:						Optional[int]			)							->    List[Any]:

									'''simple docstring'''







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

									'''simple docstring'''







									pass






			def 				A      (   self							:						Tuple			)							->    Optional[int]:

									'''simple docstring'''







									pass






			def 				A      (   self							:						int ,      lowercase							:						Tuple			)							->    Optional[int]:

									'''simple docstring'''







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

									UpperCamelCase__         = Path(lowercase			)
									UpperCamelCase__         = _iter_archive_members(lowercase			) 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(lowercase			).as_posix(), file_path.open("""rb"""			)







			def 				A      (   self							:						Tuple ,      lowercase							:						Tuple			)							->    List[str]:

									'''simple docstring'''







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








'''simple docstring'''


import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate
@dataclass(frozen=SCREAMING_SNAKE_CASE	)
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





			__a							:							str					     =					field(default="audio-classification"       ,metadata={"include_in_asdict_even_if_is_default": True}	)
			__a							:							ClassVar[Features]					     =					Features({"audio": Audio()}	)
			__a							:							ClassVar[Features]					     =					Features({"labels": ClassLabel}	)
			__a							:							str					     =					"audio"
			__a							:							str					     =					"labels"






			def 				A      (   self							:						List[Any] ,      lowercase							:						List[Any]			)							->    Any:

									'''simple docstring'''







									if self.label_column not in features:
															raise ValueError(f"Column {self.label_column} is not present in features."			)
									if not isinstance(features[self.label_column] ,      lowercase			):
															raise ValueError(f"Column {self.label_column} is not a ClassLabel."			)
									UpperCamelCase__         = copy.deepcopy(self			)
									UpperCamelCase__         = self.label_schema.copy()
									UpperCamelCase__         = features[self.label_column]
									UpperCamelCase__         = label_schema
									return task_template







			@property
			def 				A      (   self							:						int			)							->    Dict[str, str]:

									'''simple docstring'''







									return {
									    self.audio_column: "audio",
									    self.label_column: "labels",
									}
