


'''simple docstring'''



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   :
					lowerCAmelCase :int						=   '''dummy_data'''
					lowerCAmelCase :Optional[Any]						=   '''datasets'''
					lowerCAmelCase :Optional[int]						=   False




					def __init__( self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase = None							,							_lowerCamelCase = False							,							_lowerCamelCase = True							,							_lowerCamelCase = None							,							):
								UpperCAmelCase__					:   Union[str, Any]       				=       0
								UpperCAmelCase__					:   int       				=       dataset_name
								UpperCAmelCase__					:   Tuple       				=       cache_dir
								UpperCAmelCase__					:   Any       				=       use_local_dummy_data
								UpperCAmelCase__					:   str       				=       config
								# download_callbacks take a single url as input
								UpperCAmelCase__					:   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
								UpperCAmelCase__					:   List[Any]       				=       load_existing_dummy_data

								# TODO(PVP, QL) might need to make this more general
								UpperCAmelCase__					:   str       				=       str(_lowerCamelCase)
								# to be downloaded
								UpperCAmelCase__					:   int       				=       None
								UpperCAmelCase__					:   List[str]       				=       None




					@property
					def 			snake_case__  ( self):
								if self._dummy_file is None:
											UpperCAmelCase__					:   List[Any]       				=       self.download_dummy_data()
								return self._dummy_file




					@property
					def 			snake_case__  ( self):
								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 			snake_case__  ( self):
								return os.path.join(self.dummy_data_folder							,							"""dummy_data.zip""")




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   Tuple       				=       (
								    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
								)

								UpperCAmelCase__					:   Optional[int]       				=       cached_path(
								    _lowerCamelCase							,							cache_dir=self.cache_dir							,							extract_compressed_file=_lowerCamelCase							,							force_extract=_lowerCamelCase)

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




					@property
					def 			snake_case__  ( self):
								return os.path.join(self.datasets_scripts_dir							,							self.dataset_name							,							self.dummy_zip_file)




					@property
					def 			snake_case__  ( self):
								if self._bucket_url is None:
											UpperCAmelCase__					:   Union[str, Any]       				=       hf_github_url(self.dataset_name							,							self.dummy_zip_file.replace(os.sep							,							"""/"""))
								return self._bucket_url




					@property
					def 			snake_case__  ( self):
								# 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 			snake_case__  ( self							,							_lowerCamelCase							,							*_lowerCamelCase):
								if self.load_existing_dummy_data:
											# dummy data is downloaded and tested
											UpperCAmelCase__					:   Optional[int]       				=       self.dummy_file
								else:
											# dummy data cannot be downloaded and only the path to dummy file is returned
											UpperCAmelCase__					:   Optional[Any]       				=       self.dummy_file_name

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




					def 			snake_case__  ( self							,							_lowerCamelCase							,							*_lowerCamelCase):
								return self.download_and_extract(_lowerCamelCase)




					def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase):
								return self.download_and_extract(_lowerCamelCase)




					def 			snake_case__  ( self							,							_lowerCamelCase							,							*_lowerCamelCase							,							**_lowerCamelCase):
								return path




					def 			snake_case__  ( self):
								return {}




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

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

								return dummy_data_dict




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




					def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase):
								for download_callback in self.download_callbacks:
											download_callback(_lowerCamelCase)
								# 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__					:   List[str]       				=       os.path.join(_lowerCamelCase							,							urllib.parse.quote_plus(data_url.split("""/""")[-1]))
								if os.path.exists(_lowerCamelCase) 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 			snake_case__  ( self):
								pass




					def 			snake_case__  ( self):
								pass




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

								UpperCAmelCase__					:   Union[str, Any]       				=       Path(_lowerCamelCase)
								UpperCAmelCase__					:   Dict       				=       _iter_archive_members(_lowerCamelCase) 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(_lowerCamelCase).as_posix(), file_path.open("""rb""")




					def 			snake_case__  ( self							,							_lowerCamelCase):
								if not isinstance(_lowerCamelCase							,							_lowerCamelCase):
											UpperCAmelCase__					:   Optional[Any]       				=       [paths]
								for path in paths:
											if os.path.isfile(_lowerCamelCase):
														if os.path.basename(_lowerCamelCase).startswith((""".""", """__""")):
																	return
														yield path
											else:
														for dirpath, dirnames, filenames in os.walk(_lowerCamelCase):
																	if os.path.basename(_lowerCamelCase).startswith((""".""", """__""")):
																				continue
																	dirnames.sort()
																	for filename in sorted(_lowerCamelCase):
																				if filename.startswith((""".""", """__""")):
																							continue
																				yield os.path.join(_lowerCamelCase							,							_lowerCamelCase)



'''simple docstring'''



def       _UpperCamelCase (						UpperCamelCase__ = 1_0	, UpperCamelCase__ = 2_2   ):
			UpperCAmelCase__					:   List[str]       				=       range(1	, UpperCamelCase__   )
			UpperCAmelCase__					:   int       				=       range(1	, UpperCamelCase__   )
			return sum(
			    1 for power in powers for base in bases if len(str(base**power   )   ) == power   )


if __name__ == "__main__":
		print(f"""{solution(10, 22) = }""")