


'''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_  :				List[str]						= get_logger(__name__)





class      snake_case    :





  """simple docstring"""




  _lowerCamelCase		    =  "dummy_data"
  _lowerCamelCase		    =  "datasets"
  _lowerCamelCase		    =  False






  def __init__(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase = None			,  UpperCamelCase = False			,  UpperCamelCase = True			,  UpperCamelCase = None			,  ):







   """simple docstring"""
   lowerCamelCase_      =  0
   lowerCamelCase_      =  dataset_name
   lowerCamelCase_      =  cache_dir
   lowerCamelCase_      =  use_local_dummy_data
   lowerCamelCase_      =  config
   # download_callbacks take a single url as input
   lowerCamelCase_      =  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_      =  load_existing_dummy_data

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






  @property
  def   snake_case		(    self     ):







   """simple docstring"""
   if self._dummy_file is None:
    lowerCamelCase_      =  self.download_dummy_data()
   return self._dummy_file






  @property
  def   snake_case		(    self     ):







   """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   snake_case		(    self     ):







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






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  (
       self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
   )

   lowerCamelCase_      =  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   snake_case		(    self     ):







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






  @property
  def   snake_case		(    self     ):







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






  @property
  def   snake_case		(    self     ):







   """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   snake_case		(    self			,  UpperCamelCase			,  *UpperCamelCase     ):







   """simple docstring"""
   if self.load_existing_dummy_data:
    # dummy data is downloaded and tested
    lowerCamelCase_      =  self.dummy_file
   else:
    # dummy data cannot be downloaded and only the path to dummy file is returned
    lowerCamelCase_      =  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   snake_case		(    self			,  UpperCamelCase			,  *UpperCamelCase     ):







   """simple docstring"""
   return self.download_and_extract(UpperCamelCase     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   return self.download_and_extract(UpperCamelCase     )






  def   snake_case		(    self			,  UpperCamelCase			,  *UpperCamelCase			,  **UpperCamelCase     ):







   """simple docstring"""
   return path






  def   snake_case		(    self     ):







   """simple docstring"""
   return {}






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  {}
   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_      =  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_      =  [os.path.join(UpperCamelCase			,  urllib.parse.quote_plus(Path(UpperCamelCase     ).name     )     ) for x in single_urls]
    else:
     lowerCamelCase_      =  single_urls
     lowerCamelCase_      =  os.path.join(UpperCamelCase			,  urllib.parse.quote_plus(Path(UpperCamelCase     ).name     )     )
    lowerCamelCase_      =  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_      =  {key: value + key for key, value in dummy_data_dict.items()}

   return dummy_data_dict






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







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






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """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_      =  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   snake_case		(    self     ):







   """simple docstring"""
   pass






  def   snake_case		(    self     ):







   """simple docstring"""
   pass






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   def _iter_archive_members(UpperCamelCase     ):
    # this preserves the order of the members inside the ZIP archive
    lowerCamelCase_      =  Path(self.dummy_file     ).parent
    lowerCamelCase_      =  path.relative_to(UpperCamelCase     )
    with ZipFile(self.local_path_to_dummy_data     ) as zip_file:
     lowerCamelCase_      =  zip_file.namelist()
    for member in members:
     if member.startswith(relative_path.as_posix()     ):
      yield dummy_parent_path.joinpath(UpperCamelCase     )

   lowerCamelCase_      =  Path(UpperCamelCase     )
   lowerCamelCase_      =  _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   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   if not isinstance(UpperCamelCase			,  UpperCamelCase     ):
    lowerCamelCase_      =  [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     )







'''simple docstring'''

from __future__ import annotations

from fractions import Fraction





def __snake_case					(      UpperCAmelCase_						:						int					,				UpperCAmelCase_						:						int		):
 return (
     num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
 )





def __snake_case					(      UpperCAmelCase_						:						int		):
 lowerCamelCase_      =  []
 lowerCamelCase_      =  11
 lowerCamelCase_      =  int("1" + "0" * digit_len		)
 for num in range(UpperCAmelCase_					,				UpperCAmelCase_		):
  while den <= 99:
   if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
    if is_digit_cancelling(UpperCAmelCase_					,				UpperCAmelCase_		):
     solutions.append(F'''{num}/{den}'''		)
   den += 1
  num += 1
  lowerCamelCase_      =  10
 return solutions





def __snake_case					(      UpperCAmelCase_						:						int = 2		):
 lowerCamelCase_      =  1.0
 for fraction in fraction_list(UpperCAmelCase_		):
  lowerCamelCase_      =  Fraction(UpperCAmelCase_		)
  result *= frac.denominator / frac.numerator
 return int(UpperCAmelCase_		)


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



