



"""simple docstring"""

import argparse
import os
import re

import packaging.version


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




def __lowercase			(							_a		,			_a		,			_a    ):
    with open(_a		,			'''r'''		,			encoding='''utf-8'''		,			newline='''\n'''    ) as f:
        snake_case_ :     Union[str, Any]				=	f.read()
    snake_case_,	snake_case_ :     List[Any]				=	REPLACE_PATTERNS[pattern]
    snake_case_ :     Tuple				=	replace.replace('''VERSION'''		,			_a    )
    snake_case_ :     List[Any]				=	re_pattern.sub(_a		,			_a    )
    with open(_a		,			'''w'''		,			encoding='''utf-8'''		,			newline='''\n'''    ) as f:
        f.write(_a    )




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




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




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

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

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

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




def __lowercase			(							):
    with open(REPLACE_FILES['''init''']		,			'''r'''    ) as f:
        snake_case_ :     Dict				=	f.read()
    snake_case_ :     List[Any]				=	REPLACE_PATTERNS['''init'''][0].search(_a    ).groups()[0]
    return packaging.version.parse(_a    )




def __lowercase			(							_a=False    ):
    snake_case_ :     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:
        snake_case_ :     Dict				=	default_version.base_version
    elif patch:
        snake_case_ :     Optional[Any]				=	f"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
    else:
        snake_case_ :     Dict				=	f"{default_version.major}.{default_version.minor + 1}.0"

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

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




def __lowercase			(							):
    snake_case_ :     Union[str, Any]				=	get_version()
    snake_case_ :     Optional[Any]				=	f"{current_version.major}.{current_version.minor + 1}.0.dev0"
    snake_case_ :     str				=	current_version.base_version

    # Check with the user we got that right.
    snake_case_ :     Optional[Any]				=	input(f"Which version are we developing now? [{dev_version}]"    )
    if len(_a    ) == 0:
        snake_case_ :     Union[str, Any]				=	dev_version

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


if __name__ == "__main__":
     lowercase__    :  List[str]							    =	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.''')
     lowercase__    :  Any							    =	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"""

import os
import tempfile
import unittest
import uuid
from pathlib import Path

from transformers.testing_utils import get_tests_dir, require_soundfile, require_torch, require_vision
from transformers.tools.agent_types import AgentAudio, AgentImage, AgentText
from transformers.utils import is_soundfile_availble, is_torch_available, is_vision_available


if is_torch_available():
     import torch

if is_soundfile_availble():
     import soundfile as sf

if is_vision_available():
     from PIL import Image




def __lowercase			(							_a=""    ):
    snake_case_ :     List[str]				=	tempfile.mkdtemp()
    return os.path.join(_a		,			str(uuid.uuida()    ) + suffix    )




@require_soundfile
@require_torch
class        _UpperCAmelCase       (			unittest.TestCase):

 def 						_snake_case					(     self		:       str				):
     snake_case_ :     int				=	torch.rand(12  ,     dtype=torch.floataa				) - 0.5
     snake_case_ :     Optional[int]				=	AgentAudio(lowercase_				)
     snake_case_ :     List[str]				=	str(agent_type.to_string()				)

     # Ensure that the tensor and the agent_type's tensor are the same
     self.assertTrue(torch.allclose(lowercase_  ,     agent_type.to_raw()  ,     atol=1E-4				)				)

     del agent_type

     # Ensure the path remains even after the object deletion
     self.assertTrue(os.path.exists(lowercase_				)				)

     # Ensure that the file contains the same value as the original tensor
     snake_case_,	snake_case_ :     int				=	sf.read(lowercase_				)
     self.assertTrue(torch.allclose(lowercase_  ,     torch.tensor(lowercase_				)  ,     atol=1E-4				)				)






 def 						_snake_case					(     self		:       Optional[int]				):
     snake_case_ :     Any				=	torch.rand(12  ,     dtype=torch.floataa				) - 0.5
     snake_case_ :     List[str]				=	get_new_path(suffix='''.wav'''				)
     sf.write(lowercase_  ,     lowercase_  ,     16000				)

     snake_case_ :     Tuple				=	AgentAudio(lowercase_				)

     self.assertTrue(torch.allclose(lowercase_  ,     agent_type.to_raw()  ,     atol=1E-4				)				)
     self.assertEqual(agent_type.to_string()  ,     lowercase_				)





@require_vision
@require_torch
class        _UpperCAmelCase       (			unittest.TestCase):

 def 						_snake_case					(     self		:       Tuple				):
     snake_case_ :     List[Any]				=	torch.randint(0  ,     256  ,     (64, 64, 3)				)
     snake_case_ :     str				=	AgentImage(lowercase_				)
     snake_case_ :     Union[str, Any]				=	str(agent_type.to_string()				)

     # Ensure that the tensor and the agent_type's tensor are the same
     self.assertTrue(torch.allclose(lowercase_  ,     agent_type._tensor  ,     atol=1E-4				)				)

     self.assertIsInstance(agent_type.to_raw()  ,     Image.Image				)

     # Ensure the path remains even after the object deletion
     del agent_type
     self.assertTrue(os.path.exists(lowercase_				)				)

 def 						_snake_case					(     self		:       str				):
     snake_case_ :     Any				=	Path(get_tests_dir('''fixtures/tests_samples/COCO'''				)				) / '''000000039769.png'''
     snake_case_ :     Optional[int]				=	Image.open(lowercase_				)
     snake_case_ :     Tuple				=	AgentImage(lowercase_				)

     self.assertTrue(path.samefile(agent_type.to_string()				)				)
     self.assertTrue(image == agent_type.to_raw()				)

     # Ensure the path remains even after the object deletion
     del agent_type
     self.assertTrue(os.path.exists(lowercase_				)				)






 def 						_snake_case					(     self		:       str				):
     snake_case_ :     int				=	Path(get_tests_dir('''fixtures/tests_samples/COCO'''				)				) / '''000000039769.png'''
     snake_case_ :     Dict				=	Image.open(lowercase_				)
     snake_case_ :     List[str]				=	AgentImage(lowercase_				)

     self.assertFalse(path.samefile(agent_type.to_string()				)				)
     self.assertTrue(image == agent_type.to_raw()				)

     # Ensure the path remains even after the object deletion
     del agent_type
     self.assertTrue(os.path.exists(lowercase_				)				)





class        _UpperCAmelCase       (			unittest.TestCase):

 def 						_snake_case					(     self		:       Any				):
     snake_case_ :     Tuple				=	'''Hey!'''
     snake_case_ :     Optional[Any]				=	AgentText(lowercase_				)

     self.assertEqual(lowercase_  ,     agent_type.to_string()				)
     self.assertEqual(lowercase_  ,     agent_type.to_raw()				)
     self.assertEqual(lowercase_  ,     lowercase_				)





