

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


__UpperCAmelCase =				get_logger(__name__)







class      __lowercase			:

  '''simple docstring'''





  snake_case_				       =       """dummy_data"""
  snake_case_				       =       """datasets"""
  snake_case_				       =       False

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






   '''simple docstring'''
   UpperCAmelCase__					:  str					   =					0
   UpperCAmelCase__					:  int					   =					dataset_name
   UpperCAmelCase__					:  Dict					   =					cache_dir
   UpperCAmelCase__					:  int					   =					use_local_dummy_data
   UpperCAmelCase__					:  List[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__					:  str					   =					load_existing_dummy_data

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

  @property
  def    __lowercase       (  self		:			List[Any]    ):






   '''simple docstring'''
   if self._dummy_file is None:
    UpperCAmelCase__					:  Union[str, Any]					   =					self.download_dummy_data()
   return self._dummy_file

  @property
  def    __lowercase       (  self		:			Optional[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    __lowercase       (  self		:			List[Any]    ):






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

  def    __lowercase       (  self		:			List[Any]    ):






   '''simple docstring'''
   UpperCAmelCase__					:  Union[str, Any]					   =					(
       self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
   )

   UpperCAmelCase__					:  Optional[Any]					   =					cached_path(
       A					,cache_dir=self.cache_dir					,extract_compressed_file=A					,force_extract=A    )

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

  @property
  def    __lowercase       (  self		:			Optional[int]    ):






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

  @property
  def    __lowercase       (  self		:			int    ):






   '''simple docstring'''
   if self._bucket_url is None:
    UpperCAmelCase__					:  Dict					   =					hf_github_url(self.dataset_name					,self.dummy_zip_file.replace(os.sep					,"""/"""    )    )
   return self._bucket_url

  @property
  def    __lowercase       (  self		:			List[Any]    ):






   '''simple docstring'''
   # 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    __lowercase       (  self		:			List[str]					,A		:			Tuple					,*A		:			Tuple    ):






   '''simple docstring'''
   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(A					,A    ):
    return self.create_dummy_data_dict(A					,A    )
   elif isinstance(A					,(list, tuple)    ):
    return self.create_dummy_data_list(A					,A    )
   else:
    return self.create_dummy_data_single(A					,A    )

  def    __lowercase       (  self		:			List[Any]					,A		:			Tuple					,*A		:			Any    ):






   '''simple docstring'''
   return self.download_and_extract(A    )

  def    __lowercase       (  self		:			List[Any]					,A		:			List[Any]					,A		:			List[str]    ):






   '''simple docstring'''
   return self.download_and_extract(A    )

  def    __lowercase       (  self		:			Dict					,A		:			Tuple					,*A		:			Dict					,**A		:			int    ):






   '''simple docstring'''
   return path

  def    __lowercase       (  self		:			Optional[int]    ):






   '''simple docstring'''
   return {}

  def    __lowercase       (  self		:			Union[str, Any]					,A		:			Optional[int]					,A		:			List[Any]    ):






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

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

   return dummy_data_dict

  def    __lowercase       (  self		:			Any					,A		:			Optional[Any]					,A		:			Optional[int]    ):






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

  def    __lowercase       (  self		:			Tuple					,A		:			str					,A		:			Union[str, Any]    ):






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






   '''simple docstring'''
   pass

  def    __lowercase       (  self		:			str    ):






   '''simple docstring'''
   pass

  def    __lowercase       (  self		:			str					,A		:			int    ):






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

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




  def    __lowercase       (  self		:			List[str]					,A		:			str    ):






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








"""simple docstring"""




def   lowerCAmelCase						(					__UpperCamelCase = 1000      ):
 '''simple docstring'''





 return sum(2 * a * ((a - 1) // 2) for a in range(3							,    n + 1      )      )


if __name__ == "__main__":
      print(solution())





