





'''simple docstring'''

import json
import os
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import ImageGPTImageProcessor
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def __init__(							self       :		Any	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Any=7	,			lowerCAmelCase__       :		List[Any]=3	,			lowerCAmelCase__       :		Tuple=18	,			lowerCAmelCase__       :		Tuple=30	,			lowerCAmelCase__       :		Union[str, Any]=400	,			lowerCAmelCase__       :		List[str]=True	,			lowerCAmelCase__       :		Optional[int]=None	,			lowerCAmelCase__       :		int=True	,			)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	size if size is not None else {'''height''': 18, '''width''': 18}
            _UpperCamelCase       =	parent
            _UpperCamelCase       =	batch_size
            _UpperCamelCase       =	num_channels
            _UpperCamelCase       =	image_size
            _UpperCamelCase       =	min_resolution
            _UpperCamelCase       =	max_resolution
            _UpperCamelCase       =	do_resize
            _UpperCamelCase       =	size
            _UpperCamelCase       =	do_normalize







       def snake_case__						(							self       :		Optional[int]					)   ->					Optional[Any]:

            '''simple docstring'''




            return {
                # here we create 2 clusters for the sake of simplicity
                "clusters": np.asarray(
                    [
                        [0.8866443634033203, 0.6618829369544983, 0.3891746401786804],
                        [-0.6042559146881104, -0.02295008860528469, 0.5423797369003296],
                    ]					),
                "do_resize": self.do_resize,
                "size": self.size,
                "do_normalize": self.do_normalize,
            }

@require_torch
@require_vision
class     __lowerCAmelCase					(   __magic_name__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Union[str, Any]						    =   ImageGPTImageProcessor if is_vision_available() else None





       def snake_case__						(							self       :		int					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	ImageGPTImageProcessingTester(self					)





       @property
       def snake_case__						(							self       :		Dict					)   ->					Any:

            '''simple docstring'''




            return self.image_processor_tester.prepare_image_processor_dict()





       def snake_case__						(							self       :		Union[str, Any]					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.image_processing_class(**self.image_processor_dict					)
            self.assertTrue(hasattr(lowerCAmelCase__	,			'''clusters'''					)					)
            self.assertTrue(hasattr(lowerCAmelCase__	,			'''do_resize'''					)					)
            self.assertTrue(hasattr(lowerCAmelCase__	,			'''size'''					)					)
            self.assertTrue(hasattr(lowerCAmelCase__	,			'''do_normalize'''					)					)





       def snake_case__						(							self       :		str					)   ->					Optional[int]:

            '''simple docstring'''




            _UpperCamelCase       =	self.image_processing_class.from_dict(self.image_processor_dict					)
            self.assertEqual(image_processor.size	,			{'''height''': 18, '''width''': 18}					)

            _UpperCamelCase       =	self.image_processing_class.from_dict(self.image_processor_dict	,			size=42					)
            self.assertEqual(image_processor.size	,			{'''height''': 42, '''width''': 42}					)





       def snake_case__						(							self       :		Tuple					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	self.image_processing_class(**self.image_processor_dict					)
            _UpperCamelCase       =	json.loads(image_processor.to_json_string()					)
            for key, value in self.image_processor_dict.items():
                 if key == "clusters":
                      self.assertTrue(np.array_equal(lowerCAmelCase__	,			obj[key]					)					)
                 else:
                      self.assertEqual(obj[key]	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Union[str, Any]					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.image_processing_class(**self.image_processor_dict					)

            with tempfile.TemporaryDirectory() as tmpdirname:
                 _UpperCamelCase       =	os.path.join(lowerCAmelCase__	,			'''image_processor.json'''					)
                 image_processor_first.to_json_file(lowerCAmelCase__					)
                 _UpperCamelCase       =	self.image_processing_class.from_json_file(lowerCAmelCase__					).to_dict()

            _UpperCamelCase       =	image_processor_first.to_dict()
            for key, value in image_processor_first.items():
                 if key == "clusters":
                      self.assertTrue(np.array_equal(lowerCAmelCase__	,			image_processor_second[key]					)					)
                 else:
                      self.assertEqual(image_processor_first[key]	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Optional[Any]					)   ->					List[str]:

            '''simple docstring'''




            _UpperCamelCase       =	self.image_processing_class(**self.image_processor_dict					)

            with tempfile.TemporaryDirectory() as tmpdirname:
                 image_processor_first.save_pretrained(lowerCAmelCase__					)
                 _UpperCamelCase       =	self.image_processing_class.from_pretrained(lowerCAmelCase__					).to_dict()

            _UpperCamelCase       =	image_processor_first.to_dict()
            for key, value in image_processor_first.items():
                 if key == "clusters":
                      self.assertTrue(np.array_equal(lowerCAmelCase__	,			image_processor_second[key]					)					)
                 else:
                      self.assertEqual(image_processor_first[key]	,			lowerCAmelCase__					)







       @unittest.skip('''ImageGPT requires clusters at initialization'''					)
       def snake_case__						(							self       :		List[str]					)   ->					List[Any]:

            '''simple docstring'''




            pass







def  a__    (    )		->		Union[str, Any]:





     """simple docstring"""

     _UpperCamelCase       =	load_dataset('''hf-internal-testing/fixtures_image_utils''', split='''test'''				)

     _UpperCamelCase       =	Image.open(dataset[4]['''file''']				)
     _UpperCamelCase       =	Image.open(dataset[5]['''file''']				)

     _UpperCamelCase       =	[imagea, imagea]

     return images




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






       """simple docstring"""





       @slow
       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	ImageGPTImageProcessor.from_pretrained('''openai/imagegpt-small'''					)

            _UpperCamelCase       =	prepare_images()

            # test non-batched
            _UpperCamelCase       =	image_processing(images[0]	,			return_tensors='''pt'''					)

            self.assertIsInstance(encoding.input_ids	,			torch.LongTensor					)
            self.assertEqual(encoding.input_ids.shape	,			(1, 1024)					)

            _UpperCamelCase       =	[306, 191, 191]
            self.assertEqual(encoding.input_ids[0, :3].tolist()	,			lowerCAmelCase__					)

            # test batched
            _UpperCamelCase       =	image_processing(lowerCAmelCase__	,			return_tensors='''pt'''					)

            self.assertIsInstance(encoding.input_ids	,			torch.LongTensor					)
            self.assertEqual(encoding.input_ids.shape	,			(2, 1024)					)

            _UpperCamelCase       =	[303, 13, 13]
            self.assertEqual(encoding.input_ids[1, -3:].tolist()	,			lowerCAmelCase__					)










'''simple docstring'''

import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
lowercase__						:      List[str]	=    sys.version_info >= (3, 10)







def  a__    (    lowercase :					Dict=None, lowercase :					List[str]=None				)		->		List[Any]:





     """simple docstring"""

     return field(default_factory=lambda: default, metadata=lowercase				)
@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int
       _snake_case     :					float
       _snake_case     :					str
       _snake_case     :					bool

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int						    =   4_2
       _snake_case     :					str						    =   field(default='toto'						,						metadata={'help': 'help message'}			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					bool						    =   False
       _snake_case     :					bool						    =   True
       _snake_case     :					Optional[bool]						    =   None

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'

class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					str						    =   'titi'
       _snake_case     :					Union[str, Any]						    =   'toto'
       _snake_case     :					Any						    =   4_2

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					BasicEnum						    =   "toto"





       def snake_case__						(							self       :		List[Any]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					MixedTypeEnum						    =   "toto"





       def snake_case__						(							self       :		Dict					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	MixedTypeEnum(self.foo					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					Optional[int]						    =   None
       _snake_case     :					Optional[float]						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
       _snake_case     :					Optional[str]						    =   None
       _snake_case     :					Optional[List[str]]						    =   list_field(default=[]			)
       _snake_case     :					Optional[List[int]]						    =   list_field(default=[]			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					List[int]						    =   list_field(default=[]			)
       _snake_case     :					List[int]						    =   list_field(default=[1, 2, 3]			)
       _snake_case     :					List[str]						    =   list_field(default=['Hallo', 'Bonjour', 'Hello']			)
       _snake_case     :					List[float]						    =   list_field(default=[0.1, 0.2, 0.3]			)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					List[int]						    =   field()
       _snake_case     :					str						    =   field()
       _snake_case     :					BasicEnum						    =   field()





       def snake_case__						(							self       :		str					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	BasicEnum(self.required_enum					)

@dataclass
class     __lowerCAmelCase					:






       """simple docstring"""
       _snake_case     :					int
       _snake_case     :					"BasicEnum"						    =   field()
       _snake_case     :					"Optional[bool]"						    =   None
       _snake_case     :					"str"						    =   field(default='toto'						,						metadata={'help': 'help message'}			)
       _snake_case     :					"List[str]"						    =   list_field(default=['Hallo', 'Bonjour', 'Hello']			)


if is_python_no_less_than_3_10:
   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					bool						    =   False
          _snake_case     :					bool						    =   True
          _snake_case     :					bool | None						    =   None

   @dataclass
   class     __lowerCAmelCase					:






          """simple docstring"""
          _snake_case     :					int | None						    =   None
          _snake_case     :					float | None						    =   field(default=__magic_name__						,						metadata={'help': 'help message'}			)
          _snake_case     :					str | None						    =   None
          _snake_case     :					list[str] | None						    =   list_field(default=[]			)
          _snake_case     :					list[int] | None						    =   list_field(default=[]			)




class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       def snake_case__						(							self       :		Optional[Any]	,			lowerCAmelCase__       :		argparse.ArgumentParser	,			lowerCAmelCase__       :		argparse.ArgumentParser					)   ->					str:

            '''simple docstring'''




            self.assertEqual(len(a._actions					)	,			len(b._actions					)					)
            for x, y in zip(a._actions	,			b._actions					):
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).items() if k != '''container'''}
                 _UpperCamelCase       =	{k: v for k, v in vars(lowerCAmelCase__					).items() if k != '''container'''}

                 # Choices with mixed type have custom function as "type"
                 # So we need to compare results directly for equality
                 if xx.get('''choices'''	,			lowerCAmelCase__					) and yy.get('''choices'''	,			lowerCAmelCase__					):
                      for expected_choice in yy["choices"] + xx["choices"]:
                           self.assertEqual(xx['''type'''](lowerCAmelCase__					)	,			yy['''type'''](lowerCAmelCase__					)					)
                      del xx["type"], yy["type"]

                 self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Dict					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--flag'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
            ((_UpperCamelCase)   ,    )       =	parser.parse_args_into_dataclasses(lowerCAmelCase__	,			look_for_args_file=lowerCAmelCase__					)
            self.assertFalse(example.flag					)





       def snake_case__						(							self       :		int					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=42	,			type=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			default='''toto'''	,			type=lowerCAmelCase__	,			help='''help message'''					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            expected.add_argument('''--baz'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__	,			const=lowerCAmelCase__	,			nargs='''?'''					)
            # A boolean no_* argument always has to come after its "default: True" regular counter-part
            # and its default must be set to False
            expected.add_argument('''--no_baz'''	,			action='''store_false'''	,			default=lowerCAmelCase__	,			dest='''baz'''					)
            expected.add_argument('''--opt'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__					)

            _UpperCamelCase       =	[WithDefaultBoolExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--no_baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''--baz''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)

                 _UpperCamelCase       =	parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False''']					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			opt=lowerCAmelCase__					)					)





       def snake_case__						(							self       :		Union[str, Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=['''titi''', '''toto''', 42]	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses([]					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.toto					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''titi''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.titi					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)
            _UpperCamelCase       =	parser.parse_args_into_dataclasses(['''--foo''', '''42''']					)[0]
            self.assertEqual(enum_ex.foo	,			MixedTypeEnum.fourtytwo					)





       def snake_case__						(							self       :		Any					)   ->					List[Any]:

            '''simple docstring'''




            @dataclass
            class     __lowerCAmelCase					:






                   """simple docstring"""
                   _snake_case     :					Literal["titi", "toto", 4_2]						    =   "toto"

            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''	,			default='''toto'''	,			choices=('''titi''', '''toto''', 42)	,			type=make_choice_type_function(['''titi''', '''toto''', 42]					)	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(args.foo	,			'''toto'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''titi''']					)
            self.assertEqual(args.foo	,			'''titi'''					)

            _UpperCamelCase       =	parser.parse_args(['''--foo''', '''42''']					)
            self.assertEqual(args.foo	,			42					)





       def snake_case__						(							self       :		int					)   ->					Union[str, Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo_int'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar_int'''	,			nargs='''+'''	,			default=[1, 2, 3]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_str'''	,			nargs='''+'''	,			default=['''Hallo''', '''Bonjour''', '''Hello''']	,			type=lowerCAmelCase__					)
            expected.add_argument('''--foo_float'''	,			nargs='''+'''	,			default=[0.1, 0.2, 0.3]	,			type=lowerCAmelCase__					)

            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	parser.parse_args([]					)
            self.assertEqual(
                lowerCAmelCase__	,			Namespace(foo_int=[]	,			bar_int=[1, 2, 3]	,			foo_str=['''Hallo''', '''Bonjour''', '''Hello''']	,			foo_float=[0.1, 0.2, 0.3]					)	,			)

            _UpperCamelCase       =	parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split()					)
            self.assertEqual(lowerCAmelCase__	,			Namespace(foo_int=[1]	,			bar_int=[2, 3]	,			foo_str=['''a''', '''b''', '''c''']	,			foo_float=[0.1, 0.7]					)					)





       def snake_case__						(							self       :		List[str]					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--bar'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__	,			help='''help message'''					)
            expected.add_argument('''--baz'''	,			default=lowerCAmelCase__	,			type=lowerCAmelCase__					)
            expected.add_argument('''--ces'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)
            expected.add_argument('''--des'''	,			nargs='''+'''	,			default=[]	,			type=lowerCAmelCase__					)

            _UpperCamelCase       =	[OptionalExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(lowerCAmelCase__					)

            for dataclass_type in dataclass_types:
                 _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

                 self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

                 _UpperCamelCase       =	parser.parse_args([]					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=lowerCAmelCase__	,			bar=lowerCAmelCase__	,			baz=lowerCAmelCase__	,			ces=[]	,			des=[]					)					)

                 _UpperCamelCase       =	parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split()					)
                 self.assertEqual(lowerCAmelCase__	,			Namespace(foo=12	,			bar=3.14	,			baz='''42'''	,			ces=['''a''', '''b''', '''c''']	,			des=[1, 2, 3]					)					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--required_list'''	,			nargs='''+'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument('''--required_str'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument(
                '''--required_enum'''	,			type=make_choice_type_function(['''titi''', '''toto''']					)	,			choices=['''titi''', '''toto''']	,			required=lowerCAmelCase__	,			)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''	,			type=lowerCAmelCase__	,			required=lowerCAmelCase__					)
            expected.add_argument(
                '''--required_enum'''	,			type=make_choice_type_function(['''titi''', '''toto''']					)	,			choices=['''titi''', '''toto''']	,			required=lowerCAmelCase__	,			)
            expected.add_argument('''--opt'''	,			type=lowerCAmelCase__	,			default=lowerCAmelCase__					)
            expected.add_argument('''--baz'''	,			default='''toto'''	,			type=lowerCAmelCase__	,			help='''help message'''					)
            expected.add_argument('''--foo_str'''	,			nargs='''+'''	,			default=['''Hallo''', '''Bonjour''', '''Hello''']	,			type=lowerCAmelCase__					)
            self.argparsersEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		int					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }

            _UpperCamelCase       =	parser.parse_dict(lowerCAmelCase__					)[0]
            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Any					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
                '''extra''': 42,
            }

            self.assertRaises(lowerCAmelCase__	,			parser.parse_dict	,			lowerCAmelCase__	,			allow_extra_keys=lowerCAmelCase__					)





       def snake_case__						(							self       :		str					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 _UpperCamelCase       =	os.path.join(lowerCAmelCase__	,			'''temp_json'''					)
                 os.mkdir(lowerCAmelCase__					)
                 with open(temp_local_path + '''.json'''	,			'''w+'''					) as f:
                      json.dump(lowerCAmelCase__	,			lowerCAmelCase__					)
                 _UpperCamelCase       =	parser.parse_yaml_file(Path(temp_local_path + '''.json'''					)					)[0]

            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[int]:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)

            _UpperCamelCase       =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 _UpperCamelCase       =	os.path.join(lowerCAmelCase__	,			'''temp_yaml'''					)
                 os.mkdir(lowerCAmelCase__					)
                 with open(temp_local_path + '''.yaml'''	,			'''w+'''					) as f:
                      yaml.dump(lowerCAmelCase__	,			lowerCAmelCase__					)
                 _UpperCamelCase       =	parser.parse_yaml_file(Path(temp_local_path + '''.yaml'''					)					)[0]
            _UpperCamelCase       =	BasicExample(**lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			lowerCAmelCase__					)







       def snake_case__						(							self       :		str					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	HfArgumentParser(lowerCAmelCase__					)
            self.assertIsNotNone(lowerCAmelCase__					)



