
"""simple docstring"""



import collections
import importlib.util
import os
import re
from pathlib import Path


UpperCamelCase__          =	'src/transformers'


# Matches is_xxx_available()
UpperCamelCase__          =	re.compile(r'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
UpperCamelCase__          =	re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
UpperCamelCase__          =	re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
UpperCamelCase__          =	re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
UpperCamelCase__          =	re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
UpperCamelCase__          =	re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
UpperCamelCase__          =	re.compile('^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
UpperCamelCase__          =	re.compile('^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
UpperCamelCase__          =	re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
UpperCamelCase__          =	re.compile(r'^\s*try:')
# Catches a line with else:
UpperCamelCase__          =	re.compile(r'^\s*else:')
def 					lowerCamelCase   (     _snake_case ):
    if _re_test_backend.search(_snake_case ) is None:
        return None
    UpperCAmelCase__	:      Union[str, Any]     							=					[b[0] for b in _re_backend.findall(_snake_case )]
    backends.sort()
    return "_and_".join(_snake_case )
def 					lowerCamelCase   (     _snake_case ):
    with open(_snake_case    ,'r'    ,encoding='utf-8'    ,newline='\n' ) as f:
        UpperCAmelCase__	:      List[Any]     							=					f.readlines()

    UpperCAmelCase__	:      Union[str, Any]     							=					0
    while line_index < len(_snake_case ) and not lines[line_index].startswith('_import_structure = {' ):
        line_index += 1

    # If this is a traditional init, just return.
    if line_index >= len(_snake_case ):
        return None

    # First grab the objects without a specific backend in _import_structure
    UpperCAmelCase__	:      str     							=					[]
    while not lines[line_index].startswith('if TYPE_CHECKING' ) and find_backend(lines[line_index] ) is None:
        UpperCAmelCase__	:      Tuple     							=					lines[line_index]
        # If we have everything on a single line, let's deal with it.
        if _re_one_line_import_struct.search(_snake_case ):
            UpperCAmelCase__	:      Optional[int]     							=					_re_one_line_import_struct.search(_snake_case ).groups()[0]
            UpperCAmelCase__	:      str     							=					re.findall('\[([^\]]+)\]'    ,_snake_case )
            for imp in imports:
                objects.extend([obj[1:-1] for obj in imp.split(', ' )] )
            line_index += 1
            continue
        UpperCAmelCase__	:      List[str]     							=					_re_import_struct_key_value.search(_snake_case )
        if single_line_import_search is not None:
            UpperCAmelCase__	:      Tuple     							=					[obj[1:-1] for obj in single_line_import_search.groups()[0].split(', ' ) if len(_snake_case ) > 0]
            objects.extend(_snake_case )
        elif line.startswith(' ' * 8 + '"' ):
            objects.append(line[9:-3] )
        line_index += 1

    UpperCAmelCase__	:      Union[str, Any]     							=					{'none': objects}
    # Let's continue with backend-specific objects in _import_structure
    while not lines[line_index].startswith('if TYPE_CHECKING' ):
        # If the line is an if not is_backend_available, we grab all objects associated.
        UpperCAmelCase__	:      str     							=					find_backend(lines[line_index] )
        # Check if the backend declaration is inside a try block:
        if _re_try.search(lines[line_index - 1] ) is None:
            UpperCAmelCase__	:      Optional[Any]     							=					None

        if backend is not None:
            line_index += 1

            # Scroll until we hit the else block of try-except-else
            while _re_else.search(lines[line_index] ) is None:
                line_index += 1

            line_index += 1

            UpperCAmelCase__	:      Tuple     							=					[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index] ) <= 1 or lines[line_index].startswith(' ' * 4 ):
                UpperCAmelCase__	:      List[Any]     							=					lines[line_index]
                if _re_import_struct_add_one.search(_snake_case ) is not None:
                    objects.append(_re_import_struct_add_one.search(_snake_case ).groups()[0] )
                elif _re_import_struct_add_many.search(_snake_case ) is not None:
                    UpperCAmelCase__	:      Optional[int]     							=					_re_import_struct_add_many.search(_snake_case ).groups()[0].split(', ' )
                    UpperCAmelCase__	:      Tuple     							=					[obj[1:-1] for obj in imports if len(_snake_case ) > 0]
                    objects.extend(_snake_case )
                elif _re_between_brackets.search(_snake_case ) is not None:
                    UpperCAmelCase__	:      Optional[Any]     							=					_re_between_brackets.search(_snake_case ).groups()[0].split(', ' )
                    UpperCAmelCase__	:      List[str]     							=					[obj[1:-1] for obj in imports if len(_snake_case ) > 0]
                    objects.extend(_snake_case )
                elif _re_quote_object.search(_snake_case ) is not None:
                    objects.append(_re_quote_object.search(_snake_case ).groups()[0] )
                elif line.startswith(' ' * 8 + '"' ):
                    objects.append(line[9:-3] )
                elif line.startswith(' ' * 12 + '"' ):
                    objects.append(line[13:-3] )
                line_index += 1

            UpperCAmelCase__	:      int     							=					objects
        else:
            line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
    UpperCAmelCase__	:      Tuple     							=					[]
    while (
        line_index < len(_snake_case )
        and find_backend(lines[line_index] ) is None
        and not lines[line_index].startswith('else' )
    ):
        UpperCAmelCase__	:      str     							=					lines[line_index]
        UpperCAmelCase__	:      Optional[Any]     							=					_re_import.search(_snake_case )
        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

    UpperCAmelCase__	:      List[Any]     							=					{'none': objects}
    # Let's continue with backend-specific objects
    while line_index < len(_snake_case ):
        # If the line is an if is_backend_available, we grab all objects associated.
        UpperCAmelCase__	:      List[str]     							=					find_backend(lines[line_index] )
        # Check if the backend declaration is inside a try block:
        if _re_try.search(lines[line_index - 1] ) is None:
            UpperCAmelCase__	:      List[Any]     							=					None

        if backend is not None:
            line_index += 1

            # Scroll until we hit the else block of try-except-else
            while _re_else.search(lines[line_index] ) is None:
                line_index += 1

            line_index += 1

            UpperCAmelCase__	:      Any     							=					[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index] ) <= 1 or lines[line_index].startswith(' ' * 8 ):
                UpperCAmelCase__	:      List[Any]     							=					lines[line_index]
                UpperCAmelCase__	:      Tuple     							=					_re_import.search(_snake_case )
                if single_line_import_search is not None:
                    objects.extend(single_line_import_search.groups()[0].split(', ' ) )
                elif line.startswith(' ' * 12 ):
                    objects.append(line[12:-2] )
                line_index += 1

            UpperCAmelCase__	:      int     							=					objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects
def 					lowerCamelCase   (     _snake_case    ,_snake_case ):

    def find_duplicates(_snake_case ):
        return [k for k, v in collections.Counter(_snake_case ).items() if v > 1]

    if list(import_dict_objects.keys() ) != list(type_hint_objects.keys() ):
        return ["Both sides of the init do not have the same backends!"]

    UpperCAmelCase__	:      int     							=					[]
    for key in import_dict_objects.keys():
        UpperCAmelCase__	:      Tuple     							=					find_duplicates(import_dict_objects[key] )
        if duplicate_imports:
            errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}''' )
        UpperCAmelCase__	:      Optional[int]     							=					find_duplicates(type_hint_objects[key] )
        if duplicate_type_hints:
            errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}''' )

        if sorted(set(import_dict_objects[key] ) ) != sorted(set(type_hint_objects[key] ) ):
            UpperCAmelCase__	:      Any     							=					'base imports' if key == 'none' else F'''{key} backend'''
            errors.append(F'''Differences for {name}:''' )
            for a in type_hint_objects[key]:
                if a not in import_dict_objects[key]:
                    errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.''' )
            for a in import_dict_objects[key]:
                if a not in type_hint_objects[key]:
                    errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.''' )
    return errors
def 					lowerCamelCase   (     ):
    UpperCAmelCase__	:      Optional[Any]     							=					[]
    for root, _, files in os.walk(_snake_case ):
        if "__init__.py" in files:
            UpperCAmelCase__	:      List[Any]     							=					os.path.join(_snake_case    ,'__init__.py' )
            UpperCAmelCase__	:      Tuple     							=					parse_init(_snake_case )
            if objects is not None:
                UpperCAmelCase__	:      Any     							=					analyze_results(*_snake_case )
                if len(_snake_case ) > 0:
                    UpperCAmelCase__	:      Optional[int]     							=					F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
                    failures.append('\n'.join(_snake_case ) )
    if len(_snake_case ) > 0:
        raise ValueError('\n\n'.join(_snake_case ) )
def 					lowerCamelCase   (     ):
    UpperCAmelCase__	:      Union[str, Any]     							=					[]
    for path, directories, files in os.walk(_snake_case ):
        for folder in directories:
            # Ignore private modules
            if folder.startswith('_' ):
                directories.remove(_snake_case )
                continue
            # Ignore leftovers from branches (empty folders apart from pycache)
            if len(list((Path(_snake_case ) / folder).glob('*.py' ) ) ) == 0:
                continue
            UpperCAmelCase__	:      str     							=					str((Path(_snake_case ) / folder).relative_to(_snake_case ) )
            UpperCAmelCase__	:      Dict     							=					short_path.replace(os.path.sep    ,'.' )
            submodules.append(_snake_case )
        for fname in files:
            if fname == "__init__.py":
                continue
            UpperCAmelCase__	:      List[Any]     							=					str((Path(_snake_case ) / fname).relative_to(_snake_case ) )
            UpperCAmelCase__	:      Union[str, Any]     							=					short_path.replace('.py'    ,'' ).replace(os.path.sep    ,'.' )
            if len(submodule.split('.' ) ) == 1:
                submodules.append(_snake_case )
    return submodules


UpperCamelCase__          =	[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]
def 					lowerCamelCase   (     ):
    # This is to make sure the transformers module imported is the one in the repo.
    UpperCAmelCase__	:      Tuple     							=					importlib.util.spec_from_file_location(
        'transformers'    ,os.path.join(_snake_case    ,'__init__.py' )    ,submodule_search_locations=[PATH_TO_TRANSFORMERS]    ,)
    UpperCAmelCase__	:      int     							=					spec.loader.load_module()

    UpperCAmelCase__	:      Tuple     							=					[
        module
        for module in get_transformers_submodules()
        if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
    ]
    if len(_snake_case ) > 0:
        UpperCAmelCase__	:      List[Any]     							=					'\n'.join(F'''- {module}''' for module in module_not_registered )
        raise ValueError(
            'The following submodules are not properly registered in the main init of Transformers:\n'
            F'''{list_of_modules}\n'''
            'Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.' )


if __name__ == "__main__":
    check_all_inits()
    check_submodules()



"""simple docstring"""



import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin





@skip_mps
class 				a			(					lowercase						,		lowercase						,		unittest.TestCase      ):
      UpperCamelCase							:   int           =     IFImgaImgSuperResolutionPipeline
      UpperCamelCase							:   Union[str, Any]           =     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
      UpperCamelCase							:   Tuple           =     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}      )
      UpperCamelCase							:   Union[str, Any]           =     PipelineTesterMixin.required_optional_params - {"""latents"""}



      def  __snake_case							(   self      ):
          return self._get_superresolution_dummy_components()



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_=0      ):
          if str(UpperCamelCase_      ).startswith('mps'      ):
              UpperCAmelCase__	:      Optional[int]     							=					torch.manual_seed(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      int     							=					torch.Generator(device=UpperCamelCase_      ).manual_seed(UpperCamelCase_      )

          UpperCAmelCase__	:      Union[str, Any]     							=					floats_tensor((1, 3, 32, 32)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					floats_tensor((1, 3, 16, 16)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )

          UpperCAmelCase__	:      int     							=					{
              'prompt': 'A painting of a squirrel eating a burger',
              'image': image,
              'original_image': original_image,
              'generator': generator,
              'num_inference_steps': 2,
              'output_type': 'numpy',
          }

          return inputs



      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()     ,	reason='XFormers attention is only available with CUDA and `xformers` installed'     ,	)
      def  __snake_case							(   self      ):
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )



      def  __snake_case							(   self      ):
          self._test_save_load_optional_components()



      @unittest.skipIf(torch_device != 'cuda'     ,	reason='float16 requires CUDA'      )
      def  __snake_case							(   self      ):
          # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
          super().test_save_load_floataa(expected_max_diff=1E-1      )



      def  __snake_case							(   self      ):
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )



      def  __snake_case							(   self      ):
          self._test_save_load_local()



      def  __snake_case							(   self      ):
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2     ,	)

