





'''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 :
   __UpperCamelCase   : Tuple	      =	'dummy_data'
   __UpperCamelCase   : Dict	      =	'datasets'
   __UpperCamelCase   : int	      =	False





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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       0
      __SCREAMING_SNAKE_CASE      							=       dataset_name
      __SCREAMING_SNAKE_CASE      							=       cache_dir
      __SCREAMING_SNAKE_CASE      							=       use_local_dummy_data
      __SCREAMING_SNAKE_CASE      							=       config
      # download_callbacks take a single url as input
      __SCREAMING_SNAKE_CASE      							=       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
      __SCREAMING_SNAKE_CASE      							=       load_existing_dummy_data

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





   @property
   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

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





   @property
   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''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      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

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





   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       (
          self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
      )

      __SCREAMING_SNAKE_CASE      							=       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      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

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





   @property
   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

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





   @property
   def      UpperCAmelCase__     (					self				:			int    ):

      '''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      UpperCAmelCase__     (					self				:			Union[str, Any]				,lowerCamelCase				:			Dict				,*lowerCamelCase				:			Any    ):

      '''simple docstring'''

      if self.load_existing_dummy_data:
         # dummy data is downloaded and tested
         __SCREAMING_SNAKE_CASE      							=       self.dummy_file
      else:
         # dummy data cannot be downloaded and only the path to dummy file is returned
         __SCREAMING_SNAKE_CASE      							=       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      UpperCAmelCase__     (					self				:			Any				,lowerCamelCase				:			str				,*lowerCamelCase				:			Any    ):

      '''simple docstring'''

      return self.download_and_extract(lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			Union[str, Any]				,lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      return self.download_and_extract(lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Dict				,lowerCamelCase				:			Union[str, Any]				,*lowerCamelCase				:			Optional[int]				,**lowerCamelCase				:			Any    ):

      '''simple docstring'''

      return path





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      return {}





   def      UpperCAmelCase__     (					self				:			str				,lowerCamelCase				:			Optional[int]				,lowerCamelCase				:			List[Any]    ):

      '''simple docstring'''

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

      return dummy_data_dict





   def      UpperCAmelCase__     (					self				:			Optional[Any]				,lowerCamelCase				:			Any				,lowerCamelCase				:			Union[str, Any]    ):

      '''simple docstring'''

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





   def      UpperCAmelCase__     (					self				:			str				,lowerCamelCase				:			Union[str, Any]				,lowerCamelCase				:			List[Any]    ):

      '''simple docstring'''

      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
      __SCREAMING_SNAKE_CASE      							=       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      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			int				,lowerCamelCase				:			Tuple    ):

      '''simple docstring'''

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

      __SCREAMING_SNAKE_CASE      							=       Path(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       _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      UpperCAmelCase__     (					self				:			Optional[int]				,lowerCamelCase				:			Union[str, Any]    ):

      '''simple docstring'''

      if not isinstance(lowerCamelCase				,lowerCamelCase    ):
         __SCREAMING_SNAKE_CASE      							=       [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'''

from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .multicontrolnet import MultiControlNetModel
    from .pipeline_controlnet import StableDiffusionControlNetPipeline
    from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
    from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
    from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline





