






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






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A    	=   {'''configuration_timm_backbone''': ['''TimmBackboneConfig''']}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __A    	=   ['''TimmBackbone''']


if TYPE_CHECKING:
      from .configuration_timm_backbone import TimmBackboneConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_timm_backbone import TimmBackbone

else:
      import sys

      __A    	=   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)