


import argparse
import os
import re

import packaging.version


lowerCamelCase__							:						Union[str, Any]							     =   """examples/"""
lowerCamelCase__							:						Union[str, Any]							     =   {
    """examples""": (re.compile(r"""^check_min_version\(\"[^\"]+\"\)\s*$""", re.MULTILINE), """check_min_version(\"VERSION\")\n"""),
    """init""": (re.compile(r"""^__version__\s+=\s+\"([^\"]+)\"\s*$""", re.MULTILINE), """__version__ = \"VERSION\"\n"""),
    """setup""": (re.compile(r"""^(\s*)version\s*=\s*\"[^\"]+\",""", re.MULTILINE), r"""\1version=\"VERSION\","""),
    """doc""": (re.compile(r"""^(\s*)release\s*=\s*\"[^\"]+\"$""", re.MULTILINE), """release = \"VERSION\"\n"""),
}
lowerCamelCase__							:						Dict							     =   {
    """init""": """src/transformers/__init__.py""",
    """setup""": """setup.py""",
}
lowerCamelCase__							:						List[Any]							     =   """README.md"""







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase				)    ->				List[Any]:
  with open(__lowerCAmelCase							,   '''r'''							,   encoding='''utf-8'''							,   newline='''\n'''				) as f:
    snake_case__						= f.read()
  snake_case__				,				snake_case__						= REPLACE_PATTERNS[pattern]
  snake_case__						= replace.replace('''VERSION'''							,   __lowerCAmelCase				)
  snake_case__						= re_pattern.sub(__lowerCAmelCase							,   __lowerCAmelCase				)
  with open(__lowerCAmelCase							,   '''w'''							,   encoding='''utf-8'''							,   newline='''\n'''				) as f:
    f.write(__lowerCAmelCase				)







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase				)    ->				Any:
  for folder, directories, fnames in os.walk(__lowerCAmelCase				):
    # Removing some of the folders with non-actively maintained examples from the walk
    if "research_projects" in directories:
      directories.remove('''research_projects'''				)
    if "legacy" in directories:
      directories.remove('''legacy'''				)
    for fname in fnames:
      if fname.endswith('''.py'''				):
        update_version_in_file(os.path.join(__lowerCAmelCase							,   __lowerCAmelCase				)							,   __lowerCAmelCase							,   pattern='''examples'''				)







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase=False				)    ->				int:
  for pattern, fname in REPLACE_FILES.items():
    update_version_in_file(__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase				)
  if not patch:
    update_version_in_examples(__lowerCAmelCase				)







def SCREAMING_SNAKE_CASE	(			)    ->				Dict:
  snake_case__						= '''🤗 Transformers currently provides the following architectures'''
  snake_case__						= '''1. Want to contribute a new model?'''
  with open(__lowerCAmelCase							,   '''r'''							,   encoding='''utf-8'''							,   newline='''\n'''				) as f:
    snake_case__						= f.readlines()

  # Find the start of the list.
  snake_case__						= 0
  while not lines[start_index].startswith(_start_prompt				):
    start_index += 1
  start_index += 1

  snake_case__						= start_index
  # Update the lines in the model list.
  while not lines[index].startswith(_end_prompt				):
    if lines[index].startswith('''1.'''				):
      snake_case__						= lines[index].replace(
          '''https://huggingface.co/docs/transformers/main/model_doc'''							,   '''https://huggingface.co/docs/transformers/model_doc'''							,   )
    index += 1

  with open(__lowerCAmelCase							,   '''w'''							,   encoding='''utf-8'''							,   newline='''\n'''				) as f:
    f.writelines(__lowerCAmelCase				)







def SCREAMING_SNAKE_CASE	(			)    ->				Any:
  with open(REPLACE_FILES['''init''']							,   '''r'''				) as f:
    snake_case__						= f.read()
  snake_case__						= REPLACE_PATTERNS['''init'''][0].search(__lowerCAmelCase				).groups()[0]
  return packaging.version.parse(__lowerCAmelCase				)







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase=False				)    ->				List[Any]:
  snake_case__						= get_version()
  if patch and default_version.is_devrelease:
    raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''				)
  if default_version.is_devrelease:
    snake_case__						= default_version.base_version
  elif patch:
    snake_case__						= F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
  else:
    snake_case__						= F"""{default_version.major}.{default_version.minor + 1}.0"""

  # Now let's ask nicely if that's the right one.
  snake_case__						= input(F"""Which version are you releasing? [{default_version}]"""				)
  if len(__lowerCAmelCase				) == 0:
    snake_case__						= default_version

  print(F"""Updating version to {version}."""				)
  global_version_update(__lowerCAmelCase							,   patch=__lowerCAmelCase				)
  if not patch:
    print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''				)
    clean_main_ref_in_model_list()







def SCREAMING_SNAKE_CASE	(			)    ->				Any:
  snake_case__						= get_version()
  snake_case__						= F"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
  snake_case__						= current_version.base_version

  # Check with the user we got that right.
  snake_case__						= input(F"""Which version are we developing now? [{dev_version}]"""				)
  if len(__lowerCAmelCase				) == 0:
    snake_case__						= dev_version

  print(F"""Updating version to {version}."""				)
  global_version_update(__lowerCAmelCase				)
  print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''				)
  clean_main_ref_in_model_list()


if __name__ == "__main__":
   lowerCamelCase__							:						Optional[int]							     =   argparse.ArgumentParser()
   parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""")
   parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""")
   lowerCamelCase__							:						Tuple							     =   parser.parse_args()
   if not args.post_release:
      pre_release_work(patch=args.patch)
   elif args.patch:
      print("""Nothing to do after a patch :-)""")
   else:
      post_release_work()





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 		__magic_name__						(snake_case_   ,snake_case_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							str	   =       IFImgaImgSuperResolutionPipeline
     __lowercase				:							Optional[Any]	   =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     __lowercase				:							int	   =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}				)
     __lowercase				:							List[str]	   =       PipelineTesterMixin.required_optional_params - {'latents'}

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       return self._get_superresolution_dummy_components()

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		_a:int     ,		_a:Optional[Any]=0   ):
       if str(_a   ).startswith('''mps'''   ):
         snake_case__						= torch.manual_seed(_a   )
       else:
         snake_case__						= torch.Generator(device=_a   ).manual_seed(_a   )

       snake_case__						= floats_tensor((1, 3, 32, 32)     ,		rng=random.Random(_a   )   ).to(_a   )
       snake_case__						= floats_tensor((1, 3, 16, 16)     ,		rng=random.Random(_a   )   ).to(_a   )

       snake_case__						= {
           '''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 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       self._test_save_load_optional_components()

     @unittest.skipIf(torch_device != '''cuda'''     ,		reason='''float16 requires CUDA'''   )
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       # 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 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       self._test_attention_slicing_forward_pass(expected_max_diff=1e-2   )

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       self._test_save_load_local()







     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       self._test_inference_batch_single_identical(
           expected_max_diff=1e-2     ,		)

