





"""simple docstring"""




import argparse
import os
import re

import packaging.version


_snake_case           =			"""examples/"""
_snake_case           =			{
    """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"""),
}
_snake_case           =			{
    """init""": """src/diffusers/__init__.py""",
    """setup""": """setup.py""",
}
_snake_case           =			"""README.md"""


def _A       (   __magic_name__  , __magic_name__  , __magic_name__	):
   with open(__magic_name__  , "r"  , encoding="utf-8"  , newline="\n"	) as f:
      lowercase__			       =  f.read()
   lowercase__       ,							lowercase__			       =  REPLACE_PATTERNS[pattern]
   lowercase__			       =  replace.replace("VERSION"  , __magic_name__	)
   lowercase__			       =  re_pattern.sub(__magic_name__  , __magic_name__	)
   with open(__magic_name__  , "w"  , encoding="utf-8"  , newline="\n"	) as f:
      f.write(__magic_name__	)


def _A       (   __magic_name__	):
   for folder, directories, fnames in os.walk(__magic_name__	):
      # 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(__magic_name__  , __magic_name__	)  , __magic_name__  , pattern="examples"	)


def _A       (   __magic_name__  , __magic_name__=False	):
   for pattern, fname in REPLACE_FILES.items():
      update_version_in_file(__magic_name__  , __magic_name__  , __magic_name__	)
   if not patch:
      update_version_in_examples(__magic_name__	)


def _A       (   ):
   lowercase__			       =  "🤗 Transformers currently provides the following architectures"
   lowercase__			       =  "1. Want to contribute a new model?"
   with open(__magic_name__  , "r"  , encoding="utf-8"  , newline="\n"	) as f:
      lowercase__			       =  f.readlines()

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

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

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


def _A       (   ):
   with open(REPLACE_FILES["init"]  , "r"	) as f:
      lowercase__			       =  f.read()
   lowercase__			       =  REPLACE_PATTERNS["init"][0].search(__magic_name__	).groups()[0]
   return packaging.version.parse(__magic_name__	)


def _A       (   __magic_name__=False	):
   lowercase__			       =  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:
      lowercase__			       =  default_version.base_version
   elif patch:
      lowercase__			       =  f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
   else:
      lowercase__			       =  f'''{default_version.major}.{default_version.minor + 1}.0'''

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

   print(f'''Updating version to {version}.'''	)
   global_version_update(__magic_name__  , patch=__magic_name__	)


def _A       (   ):
   lowercase__			       =  get_version()
   lowercase__			       =  f'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
   lowercase__			       =  current_version.base_version

   # Check with the user we got that right.
   lowercase__			       =  input(f'''Which version are we developing now? [{dev_version}]'''	)
   if len(__magic_name__	) == 0:
      lowercase__			       =  dev_version

   print(f'''Updating version to {version}.'''	)
   global_version_update(__magic_name__	)


#    print("Cleaning main README, don't forget to run `make fix-copies`.")
#    clean_main_ref_in_model_list()


if __name__ == "__main__":
  _snake_case           =			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.""")
  _snake_case           =			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 os
import socket
from contextlib import contextmanager

import torch

from ..commands.config.default import write_basic_config  # noqa: F401
from ..state import PartialState
from .dataclasses import DistributedType
from .imports import is_deepspeed_available, is_tpu_available
from .transformer_engine import convert_model
from .versions import is_torch_version


if is_deepspeed_available():
  from deepspeed import DeepSpeedEngine

if is_tpu_available(check_device=False):
  import torch_xla.core.xla_model as xm


def _A       (   __magic_name__	):
   if is_torch_version("<"  , "2.0.0"	) or not hasattr(__magic_name__  , "_dynamo"	):
      return False
   return isinstance(__magic_name__  , torch._dynamo.eval_frame.OptimizedModule	)


def _A       (   __magic_name__  , __magic_name__ = True	):
   lowercase__			       =  (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)

   lowercase__			       =  is_compiled_module(__magic_name__	)
   if is_compiled:
      lowercase__			       =  model
      lowercase__			       =  model._orig_mod

   if is_deepspeed_available():
      options += (DeepSpeedEngine,)

   while isinstance(__magic_name__  , __magic_name__	):
      lowercase__			       =  model.module

   if not keep_fpaa_wrapper:
      lowercase__			       =  getattr(__magic_name__  , "forward"	)
      lowercase__			       =  model.__dict__.pop("_original_forward"  , __magic_name__	)
      if original_forward is not None:
         while hasattr(__magic_name__  , "__wrapped__"	):
            lowercase__			       =  forward.__wrapped__
            if forward == original_forward:
               break
         lowercase__			       =  forward
      if getattr(__magic_name__  , "_converted_to_transformer_engine"  , __magic_name__	):
         convert_model(__magic_name__  , to_transformer_engine=__magic_name__	)

   if is_compiled:
      lowercase__			       =  model
      lowercase__			       =  compiled_model

   return model


def _A       (   ):
   PartialState().wait_for_everyone()


def _A       (   __magic_name__  , __magic_name__	):
   if PartialState().distributed_type == DistributedType.TPU:
      xm.save(__magic_name__  , __magic_name__	)
   elif PartialState().local_process_index == 0:
      torch.save(__magic_name__  , __magic_name__	)


@contextmanager
def _A       (   **__magic_name__	):
   for key, value in kwargs.items():
      lowercase__			       =  str(__magic_name__	)

   yield

   for key in kwargs:
      if key.upper() in os.environ:
         del os.environ[key.upper()]


def _A       (   __magic_name__	):
   if not hasattr(__magic_name__  , "__qualname__"	) and not hasattr(__magic_name__  , "__name__"	):
      lowercase__			       =  getattr(__magic_name__  , "__class__"  , __magic_name__	)
   if hasattr(__magic_name__  , "__qualname__"	):
      return obj.__qualname__
   if hasattr(__magic_name__  , "__name__"	):
      return obj.__name__
   return str(__magic_name__	)


def _A       (   __magic_name__  , __magic_name__	):
   for key, value in source.items():
      if isinstance(__magic_name__  , __magic_name__	):
         lowercase__			       =  destination.setdefault(__magic_name__  , {}	)
         merge_dicts(__magic_name__  , __magic_name__	)
      else:
         lowercase__			       =  value

   return destination







def _A       (   __magic_name__ = None	):
   if port is None:
      lowercase__			       =  2_9500
   with socket.socket(socket.AF_INET  , socket.SOCK_STREAM	) as s:
      return s.connect_ex(("localhost", port)	) == 0






