






'''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 a_    :
			_snake_case        =							"""dummy_data"""
			_snake_case        =							"""datasets"""
			_snake_case        =							False







			def __init__(self					,   __a					,   __a					,   __a					,   __a = None					,   __a = False					,   __a = True					,   __a = None					,   )			->      str:
						"""simple docstring"""






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

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







			@property
			def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
						"""simple docstring"""






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







			@property
			def     SCREAMING_SNAKE_CASE__					(self)			->      List[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     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
						"""simple docstring"""






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







			def     SCREAMING_SNAKE_CASE__					(self)			->      str:
						"""simple docstring"""






						__snake_case				:      str     							= (
						    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
						)

						__snake_case				:      int     							= 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     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
						"""simple docstring"""






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







			@property
			def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[int]:
						"""simple docstring"""






						if self._bucket_url is None:
									__snake_case				:      Optional[Any]     							= hf_github_url(self.dataset_name					,   self.dummy_zip_file.replace(os.sep					,   '/'))
						return self._bucket_url







			@property
			def     SCREAMING_SNAKE_CASE__					(self)			->      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     SCREAMING_SNAKE_CASE__					(self					,   __a					,   *__a)			->      Optional[Any]:
						"""simple docstring"""






						if self.load_existing_dummy_data:
									# dummy data is downloaded and tested
									__snake_case				:      int     							= self.dummy_file
						else:
									# dummy data cannot be downloaded and only the path to dummy file is returned
									__snake_case				:      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     SCREAMING_SNAKE_CASE__					(self					,   __a					,   *__a)			->      Optional[int]:
						"""simple docstring"""






						return self.download_and_extract(__a)







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      List[Any]:
						"""simple docstring"""






						return self.download_and_extract(__a)







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   *__a					,   **__a)			->      Union[str, Any]:
						"""simple docstring"""






						return path







			def     SCREAMING_SNAKE_CASE__					(self)			->      int:
						"""simple docstring"""






						return {}







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      Tuple:
						"""simple docstring"""






						__snake_case				:      Optional[Any]     							= {}
						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:
															__snake_case				:      Optional[Any]     							= 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):
												__snake_case				:      Dict     							= [os.path.join(__a					,   urllib.parse.quote_plus(Path(__a).name)) for x in single_urls]
									else:
												__snake_case				:      Optional[Any]     							= single_urls
												__snake_case				:      List[str]     							= os.path.join(__a					,   urllib.parse.quote_plus(Path(__a).name))
									__snake_case				:      Optional[Any]     							= 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
									__snake_case				:      Optional[int]     							= {key: value + key for key, value in dummy_data_dict.items()}

						return dummy_data_dict







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      List[Any]:
						"""simple docstring"""






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







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      Optional[int]:
						"""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
						__snake_case				:      Tuple     							= 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     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
						"""simple docstring"""






						pass







			def     SCREAMING_SNAKE_CASE__					(self)			->      int:
						"""simple docstring"""






						pass







			def     SCREAMING_SNAKE_CASE__					(self					,   __a)			->      List[str]:
						"""simple docstring"""






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

						__snake_case				:      Tuple     							= Path(__a)
						__snake_case				:      int     							= _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     SCREAMING_SNAKE_CASE__					(self					,   __a)			->      Optional[int]:
						"""simple docstring"""






						if not isinstance(__a					,   __a):
									__snake_case				:      Union[str, Any]     							= [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'''






from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload




class a_    :







   def __init__(self					,   __a = None)			->      None:
      """simple docstring"""






      if components is None:
         __snake_case				:      List[str]     							= []
      __snake_case				:      Optional[int]     							= list(__a)







   def __len__(self)			->      int:
      """simple docstring"""






      return len(self.__components)







   def __str__(self)			->      str:
      """simple docstring"""






      return "(" + ",".join(map(__a					,   self.__components)) + ")"







   def __add__(self					,   __a)			->      Vector:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= len(self)
      if size == len(__a):
         __snake_case				:      Optional[int]     							= [self.__components[i] + other.component(__a) for i in range(__a)]
         return Vector(__a)
      else:
         raise Exception('must have the same size')







   def __sub__(self					,   __a)			->      Vector:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= len(self)
      if size == len(__a):
         __snake_case				:      Optional[int]     							= [self.__components[i] - other.component(__a) for i in range(__a)]
         return Vector(__a)
      else:  # error case
         raise Exception('must have the same size')







   @overload
   def __mul__(self					,   __a)			->      Vector:
      """simple docstring"""






      ...







   @overload
   def __mul__(self					,   __a)			->      float:
      """simple docstring"""






      ...







   def __mul__(self					,   __a)			->      float | Vector:
      """simple docstring"""






      if isinstance(__a					,   (float, int)):
         __snake_case				:      str     							= [c * other for c in self.__components]
         return Vector(__a)
      elif isinstance(__a					,   __a) and len(self) == len(__a):
         __snake_case				:      List[Any]     							= len(self)
         __snake_case				:      Dict     							= [self.__components[i] * other.component(__a) for i in range(__a)]
         return sum(__a)
      else:  # error case
         raise Exception('invalid operand!')







   def     SCREAMING_SNAKE_CASE__					(self)			->      Vector:
      """simple docstring"""






      return Vector(self.__components)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a)			->      float:
      """simple docstring"""






      if isinstance(__a					,   __a) and -len(self.__components) <= i < len(self.__components):
         return self.__components[i]
      else:
         raise Exception('index out of range')







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      None:
      """simple docstring"""






      assert -len(self.__components) <= pos < len(self.__components)
      __snake_case				:      int     							= value







   def     SCREAMING_SNAKE_CASE__					(self)			->      float:
      """simple docstring"""






      if len(self.__components) == 0:
         raise Exception('Vector is empty')
      __snake_case				:      Tuple     							= [c**2 for c in self.__components]
      return math.sqrt(sum(__a))







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a = False)			->      float:
      """simple docstring"""






      __snake_case				:      Tuple     							= self * other
      __snake_case				:      Optional[int]     							= self.euclidean_length() * other.euclidean_length()
      if deg:
         return math.degrees(math.acos(num / den))
      else:
         return math.acos(num / den)




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> Vector:







   """simple docstring"""
   assert isinstance(A  ,		A  )
   return Vector([0] * dimension  )




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       int  )    -> Vector:







   """simple docstring"""
   assert isinstance(A  ,		A  ) and (isinstance(A  ,		A  ))
   __snake_case				:      Any     							= [0] * dimension
   __snake_case				:      int     							= 1
   return Vector(A  )




def        _SCREAMING_SNAKE_CASE  (				A  :       float  ,		A  :       Vector  ,		A  :       Vector  )    -> Vector:







   """simple docstring"""
   assert (
       isinstance(A  ,		A  )
       and isinstance(A  ,		A  )
       and (isinstance(A  ,		(int, float)  ))
   )
   return x * scalar + y




def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       int  ,		A  :       int  )    -> Vector:







   """simple docstring"""
   random.seed(A  )
   __snake_case				:      List[Any]     							= [random.randint(A  ,		A  ) for _ in range(A  )]
   return Vector(A  )




class a_    :







   def __init__(self					,   __a					,   __a					,   __a)			->      None:
      """simple docstring"""






      __snake_case				:      Union[str, Any]     							= matrix
      __snake_case				:      int     							= w
      __snake_case				:      str     							= h







   def __str__(self)			->      str:
      """simple docstring"""






      __snake_case				:      Dict     							= ''
      for i in range(self.__height):
         ans += "|"
         for j in range(self.__width):
            if j < self.__width - 1:
               ans += str(self.__matrix[i][j]) + ","
            else:
               ans += str(self.__matrix[i][j]) + "|\n"
      return ans







   def __add__(self					,   __a)			->      Matrix:
      """simple docstring"""






      if self.__width == other.width() and self.__height == other.height():
         __snake_case				:      Tuple     							= []
         for i in range(self.__height):
            __snake_case				:      List[Any]     							= [
                self.__matrix[i][j] + other.component(__a					,   __a)
                for j in range(self.__width)
            ]
            matrix.append(__a)
         return Matrix(__a					,   self.__width					,   self.__height)
      else:
         raise Exception('matrix must have the same dimension!')







   def __sub__(self					,   __a)			->      Matrix:
      """simple docstring"""






      if self.__width == other.width() and self.__height == other.height():
         __snake_case				:      str     							= []
         for i in range(self.__height):
            __snake_case				:      List[str]     							= [
                self.__matrix[i][j] - other.component(__a					,   __a)
                for j in range(self.__width)
            ]
            matrix.append(__a)
         return Matrix(__a					,   self.__width					,   self.__height)
      else:
         raise Exception('matrices must have the same dimension!')







   @overload
   def __mul__(self					,   __a)			->      Matrix:
      """simple docstring"""






      ...







   @overload
   def __mul__(self					,   __a)			->      Vector:
      """simple docstring"""






      ...







   def __mul__(self					,   __a)			->      Vector | Matrix:
      """simple docstring"""






      if isinstance(__a					,   __a):  # matrix-vector
         if len(__a) == self.__width:
            __snake_case				:      Tuple     							= zero_vector(self.__height)
            for i in range(self.__height):
               __snake_case				:      Union[str, Any]     							= [
                   self.__matrix[i][j] * other.component(__a)
                   for j in range(self.__width)
               ]
               ans.change_component(__a					,   sum(__a))
            return ans
         else:
            raise Exception(
                'vector must have the same size as the '
                'number of columns of the matrix!')
      elif isinstance(__a					,   (int, float)):  # matrix-scalar
         __snake_case				:      str     							= [
             [self.__matrix[i][j] * other for j in range(self.__width)]
             for i in range(self.__height)
         ]
         return Matrix(__a					,   self.__width					,   self.__height)
      return None







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      return self.__height







   def     SCREAMING_SNAKE_CASE__					(self)			->      int:
      """simple docstring"""






      return self.__width







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      float:
      """simple docstring"""






      if 0 <= x < self.__height and 0 <= y < self.__width:
         return self.__matrix[x][y]
      else:
         raise Exception('change_component: indices out of bounds')







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      None:
      """simple docstring"""






      if 0 <= x < self.__height and 0 <= y < self.__width:
         __snake_case				:      List[Any]     							= value
      else:
         raise Exception('change_component: indices out of bounds')







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      float:
      """simple docstring"""






      if self.__height != self.__width:
         raise Exception('Matrix is not square')
      __snake_case				:      List[Any]     							= self.__matrix[:x] + self.__matrix[x + 1 :]
      for i in range(len(__a)):
         __snake_case				:      Tuple     							= minor[i][:y] + minor[i][y + 1 :]
      return Matrix(__a					,   self.__width - 1					,   self.__height - 1).determinant()







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a)			->      float:
      """simple docstring"""






      if self.__height != self.__width:
         raise Exception('Matrix is not square')
      if 0 <= x < self.__height and 0 <= y < self.__width:
         return (-1) ** (x + y) * self.minor(__a					,   __a)
      else:
         raise Exception('Indices out of bounds')







   def     SCREAMING_SNAKE_CASE__					(self)			->      float:
      """simple docstring"""






      if self.__height != self.__width:
         raise Exception('Matrix is not square')
      if self.__height < 1:
         raise Exception('Matrix has no element')
      elif self.__height == 1:
         return self.__matrix[0][0]
      elif self.__height == 2:
         return (
             self.__matrix[0][0] * self.__matrix[1][1]
             - self.__matrix[0][1] * self.__matrix[1][0]
         )
      else:
         __snake_case				:      Any     							= [
             self.__matrix[0][y] * self.cofactor(0					,   __a) for y in range(self.__width)
         ]
         return sum(__a)




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> Matrix:







   """simple docstring"""
   __snake_case				:      list[list[float]]     							= [[0] * n for _ in range(A  )]
   return Matrix(A  ,		A  ,		A  )





def        _SCREAMING_SNAKE_CASE  (				A  :       int  ,		A  :       int  ,		A  :       int  ,		A  :       int  )    -> Matrix:







   """simple docstring"""
   random.seed(A  )
   __snake_case				:      list[list[float]]     							= [
       [random.randint(A  ,		A  ) for _ in range(A  )] for _ in range(A  )
   ]
   return Matrix(A  ,		A  ,		A  )