


'''simple docstring'''







import argparse
import os
import re

import packaging.version


A__:    Optional[Any]					    =       '''examples/'''
A__:    Optional[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'''),
}
A__:    Optional[int]					    =       {
    '''init''': '''src/diffusers/__init__.py''',
    '''setup''': '''setup.py''',
}
A__:    int					    =       '''README.md'''


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	List[Any]    ,_UpperCAmelCase	:	Dict    ,_UpperCAmelCase	:	Any  )  ->			Tuple:
       with open(_UpperCAmelCase    ,"""r"""    ,encoding="""utf-8"""    ,newline="""\n"""  ) as f:
              _a    : Any     					=f.read()
       _a					,    _a    : Any     					=REPLACE_PATTERNS[pattern]
       _a    : List[Any]     					=replace.replace("""VERSION"""    ,_UpperCAmelCase  )
       _a    : str     					=re_pattern.sub(_UpperCAmelCase    ,_UpperCAmelCase  )
       with open(_UpperCAmelCase    ,"""w"""    ,encoding="""utf-8"""    ,newline="""\n"""  ) as f:
              f.write(_UpperCAmelCase  )


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


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	int    ,_UpperCAmelCase	:	Optional[int]=False  )  ->			List[Any]:
       for pattern, fname in REPLACE_FILES.items():
              update_version_in_file(_UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase  )
       if not patch:
              update_version_in_examples(_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  )  ->			Any:
       _a    : List[Any]     					="""🤗 Transformers currently provides the following architectures"""
       _a    : str     					="""1. Want to contribute a new model?"""
       with open(_UpperCAmelCase    ,"""r"""    ,encoding="""utf-8"""    ,newline="""\n"""  ) as f:
              _a    : str     					=f.readlines()

       # Find the start of the list.
       _a    : Union[str, Any]     					=0
       while not lines[start_index].startswith(_start_prompt  ):
              start_index += 1
       start_index += 1

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

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


def 	SCREAMING_SNAKE_CASE_					(  )  ->			List[Any]:
       with open(REPLACE_FILES["""init"""]    ,"""r"""  ) as f:
              _a    : List[str]     					=f.read()
       _a    : Dict     					=REPLACE_PATTERNS["""init"""][0].search(_UpperCAmelCase  ).groups()[0]
       return packaging.version.parse(_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  _UpperCAmelCase	:	Tuple=False  )  ->			str:
       _a    : Optional[int]     					=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:
              _a    : Union[str, Any]     					=default_version.base_version
       elif patch:
              _a    : str     					=F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
       else:
              _a    : Optional[int]     					=F"{default_version.major}.{default_version.minor + 1}.0"

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

       print(F"Updating version to {version}."  )
       global_version_update(_UpperCAmelCase    ,patch=_UpperCAmelCase  )


def 	SCREAMING_SNAKE_CASE_					(  )  ->			Optional[int]:
       _a    : Dict     					=get_version()
       _a    : Any     					=F"{current_version.major}.{current_version.minor + 1}.0.dev0"
       _a    : int     					=current_version.base_version

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

       print(F"Updating version to {version}."  )
       global_version_update(_UpperCAmelCase  )


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


if __name__ == "__main__":
   A__:    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.''')
   A__:    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()






'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


A__:    str					    =       {}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    Tuple					    =       ['''GPTSw3Tokenizer''']


if TYPE_CHECKING:
   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_gpt_swa import GPTSwaTokenizer

else:
   import sys

   A__:    str					    =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


