"""simple docstring"""


import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
lowerCAmelCase_:					Optional[Any]     =					"src/diffusers"

# Matches is_xxx_available()
lowerCAmelCase_:					int     =					re.compile(R"is\_([a-z_]*)_available\(\)")
# Matches from xxx import bla
lowerCAmelCase_:					int     =					re.compile(R"\s+from\s+\S*\s+import\s+([^\(\s].*)\n")


lowerCAmelCase_:					Tuple     =					"\n{0} = None\n"

lowerCAmelCase_:					Any     =					"\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, {1})\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, {1})\n"


lowerCAmelCase_:					Any     =					"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"







def 					__a   (		A      ):






     '''simple docstring'''



     lowercase__				 =							_re_backend.findall(A      )
     if len(A      ) == 0:
          return None

     return "_and_".join(A      )







def 					__a   (		):






     '''simple docstring'''



     with open(os.path.join(A    ,				"__init__.py"      )    ,				"r"    ,				encoding="utf-8"    ,				newline="\n"      ) as f:
          lowercase__				 =							f.readlines()

     # Get to the point we do the actual imports for type checking
     lowercase__				 =							0
     lowercase__				 =							{}
     # Go through the end of the file
     while line_index < len(A      ):
          # If the line contains is_backend_available, we grab all objects associated with the `else` block
          lowercase__				 =							find_backend(lines[line_index]      )
          if backend is not None:
               while not lines[line_index].startswith("else:"      ):
                    line_index += 1
               line_index += 1
               lowercase__				 =							[]
               # Until we unindent, add backend objects to the list
               while line_index < len(A      ) and len(lines[line_index]      ) > 1:
                    lowercase__				 =							lines[line_index]
                    lowercase__				 =							_re_single_line_import.search(A      )
                    if single_line_import_search is not None:
                         objects.extend(single_line_import_search.groups()[0].split(", "      )      )
                    elif line.startswith(" " * 8      ):
                         objects.append(line[8:-2]      )
                    line_index += 1

               if len(A      ) > 0:
                    lowercase__				 =							objects
          else:
               line_index += 1

     return backend_specific_objects







def 					__a   (		A    ,				A      ):






     '''simple docstring'''



     if name.isupper():
          return DUMMY_CONSTANT.format(A      )
     elif name.islower():
          return DUMMY_FUNCTION.format(A    ,				A      )
     else:
          return DUMMY_CLASS.format(A    ,				A      )







def 					__a   (		A=None      ):






     '''simple docstring'''



     if backend_specific_objects is None:
          lowercase__				 =							read_init()
     # For special correspondence backend to module name as used in the function requires_modulename
     lowercase__				 =							{}

     for backend, objects in backend_specific_objects.items():
          lowercase__				 =							"[" + ", ".join(f'''"{b}"''' for b in backend.split("_and_"      )      ) + "]"
          lowercase__				 =							"# This file is autogenerated by the command `make fix-copies`, do not edit.\n"
          dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
          dummy_file += "\n".join([create_dummy_object(A    ,				A      ) for o in objects]      )
          lowercase__				 =							dummy_file

     return dummy_files







def 					__a   (		A=False      ):






     '''simple docstring'''



     lowercase__				 =							create_dummy_files()
     # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
     lowercase__				 =							{"torch": "pt"}

     # Locate actual dummy modules and read their content.
     lowercase__				 =							os.path.join(A    ,				"utils"      )
     lowercase__				 =							{
         backend: os.path.join(A    ,				f'''dummy_{short_names.get(A    ,				A      )}_objects.py'''      )
         for backend in dummy_files.keys()
     }

     lowercase__				 =							{}
     for backend, file_path in dummy_file_paths.items():
          if os.path.isfile(A      ):
               with open(A    ,				"r"    ,				encoding="utf-8"    ,				newline="\n"      ) as f:
                    lowercase__				 =							f.read()
          else:
               lowercase__				 =							""

     for backend in dummy_files.keys():
          if dummy_files[backend] != actual_dummies[backend]:
               if overwrite:
                    print(
                        f'''Updating diffusers.utils.dummy_{short_names.get(A    ,				A      )}_objects.py as the main '''
                        "__init__ has new objects."      )
                    with open(dummy_file_paths[backend]    ,				"w"    ,				encoding="utf-8"    ,				newline="\n"      ) as f:
                         f.write(dummy_files[backend]      )
               else:
                    raise ValueError(
                        "The main __init__ has objects that are not present in "
                        f'''diffusers.utils.dummy_{short_names.get(A    ,				A      )}_objects.py. Run `make fix-copies` '''
                        "to fix this."      )


if __name__ == "__main__":
 lowerCAmelCase_:					Optional[Any]     =					argparse.ArgumentParser()
 parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
 lowerCAmelCase_:					List[str]     =					parser.parse_args()

 check_dummies(args.fix_and_overwrite)





"""simple docstring"""


lowerCAmelCase_:					Any     =					"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 					__a   (		A      ):






     '''simple docstring'''



     if not isinstance(A    ,				A      ):
          lowercase__				 =							f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
          raise TypeError(A      )

     lowercase__				 =							"".join(bin(A      )[2:].zfill(8      ) for byte in data      )

     lowercase__				 =							len(A      ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          lowercase__				 =							b"=" * ((6 - len(A      ) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(A      ) % 6)
     else:
          lowercase__				 =							b""

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]    ,				2      )]
             for index in range(0    ,				len(A      )    ,				6      )      ).encode()
         + padding
     )







def 					__a   (		A      ):






     '''simple docstring'''



     if not isinstance(A    ,				A      ) and not isinstance(A    ,				A      ):
          lowercase__				 =							(
              "argument should be a bytes-like object or ASCII string, "
              f'''not \'{encoded_data.__class__.__name__}\''''
          )
          raise TypeError(A      )

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(A    ,				A      ):
          try:
               lowercase__				 =							encoded_data.decode("utf-8"      )
          except UnicodeDecodeError:
               raise ValueError("base64 encoded data should only contain ASCII characters"      )

     lowercase__				 =							encoded_data.count("="      )

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding]      ), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data      ), "Invalid base64 character(s) found."

     # Check the padding
     assert len(A      ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          lowercase__				 =							encoded_data[:-padding]

          lowercase__				 =							"".join(
              bin(B64_CHARSET.index(A      )      )[2:].zfill(6      ) for char in encoded_data      )[: -padding * 2]
     else:
          lowercase__				 =							"".join(
              bin(B64_CHARSET.index(A      )      )[2:].zfill(6      ) for char in encoded_data      )

     lowercase__				 =							[
         int(binary_stream[index : index + 8]    ,				2      )
         for index in range(0    ,				len(A      )    ,				8      )
     ]

     return bytes(A      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()




