





'''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
_A:					Optional[int]							=				sys.version_info >= (3, 10)







def _lowerCAmelCase     (      _lowerCAmelCase=None       ,    _lowerCAmelCase=None    )->     int:
 return field(default_factory=lambda: default       ,    metadata=_lowerCAmelCase    )






@dataclass
class UpperCAmelCase							:
    _A :			int
    _A :			float
    _A :			str
    _A :			bool






@dataclass
class UpperCAmelCase							:
    _A :			int						   =       42
    _A :			str						   =       field(default="""toto"""					,			metadata={"""help""": """help message"""}							)






@dataclass
class UpperCAmelCase							:
    _A :			bool						   =       False
    _A :			bool						   =       True
    _A :			Optional[bool]						   =       None






class UpperCAmelCase							(		UpperCAmelCase_							):
    _A :			List[str]						   =       """titi"""
    _A :			List[str]						   =       """toto"""






class UpperCAmelCase							(		UpperCAmelCase_							):
    _A :			Any						   =       """titi"""
    _A :			Dict						   =       """toto"""
    _A :			str						   =       42






@dataclass
class UpperCAmelCase							:
    _A :			BasicEnum						   =       "toto"



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[Any]					=   BasicEnum(self.foo					)






@dataclass
class UpperCAmelCase							:
    _A :			MixedTypeEnum						   =       "toto"



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[Any]					=   MixedTypeEnum(self.foo					)






@dataclass
class UpperCAmelCase							:
    _A :			Optional[int]						   =       None
    _A :			Optional[float]						   =       field(default=UpperCAmelCase_					,			metadata={"""help""": """help message"""}							)
    _A :			Optional[str]						   =       None
    _A :			Optional[List[str]]						   =       list_field(default=[]							)
    _A :			Optional[List[int]]						   =       list_field(default=[]							)






@dataclass
class UpperCAmelCase							:
    _A :			List[int]						   =       list_field(default=[]							)
    _A :			List[int]						   =       list_field(default=[1, 2, 3]							)
    _A :			List[str]						   =       list_field(default=["""Hallo""", """Bonjour""", """Hello"""]							)
    _A :			List[float]						   =       list_field(default=[0.1, 0.2, 0.3]							)






@dataclass
class UpperCAmelCase							:
    _A :			List[int]						   =       field()
    _A :			str						   =       field()
    _A :			BasicEnum						   =       field()



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[str]					=   BasicEnum(self.required_enum					)






@dataclass
class UpperCAmelCase							:
    _A :			int
    _A :			"BasicEnum"						   =       field()
    _A :			"Optional[bool]"						   =       None
    _A :			"str"						   =       field(default="""toto"""					,			metadata={"""help""": """help message"""}							)
    _A :			"List[str]"						   =       list_field(default=["""Hallo""", """Bonjour""", """Hello"""]							)


if is_python_no_less_than_3_10:






    @dataclass
    class UpperCAmelCase							:
        _A :			bool						   =       False
        _A :			bool						   =       True
        _A :			bool | None						   =       None






    @dataclass
    class UpperCAmelCase							:
        _A :			int | None						   =       None
        _A :			float | None						   =       field(default=UpperCAmelCase_					,			metadata={"""help""": """help message"""}							)
        _A :			str | None						   =       None
        _A :			list[str] | None						   =       list_field(default=[]							)
        _A :			list[int] | None						   =       list_field(default=[]							)






class UpperCAmelCase							(		unittest.TestCase							):



    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     self.assertEqual(len(a._actions					)     ,			len(b._actions					)					)
     for x, y in zip(a._actions     ,			b._actions					):
      __UpperCAmelCase     :   Any					=   {k: v for k, v in vars(__A					).items() if k != 'container'}
      __UpperCAmelCase     :   Optional[Any]					=   {k: v for k, v in vars(__A					).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'     ,			__A					) and yy.get('choices'     ,			__A					):
       for expected_choice in yy["choices"] + xx["choices"]:
        self.assertEqual(xx['type'](__A					)     ,			yy['type'](__A					)					)
       del xx["type"], yy["type"]

      self.assertEqual(__A     ,			__A					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Union[str, Any]					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   Dict					=   argparse.ArgumentParser()
     expected.add_argument('--foo'     ,			type=__A     ,			required=__A					)
     expected.add_argument('--bar'     ,			type=__A     ,			required=__A					)
     expected.add_argument('--baz'     ,			type=__A     ,			required=__A					)
     expected.add_argument('--flag'     ,			type=__A     ,			default=__A     ,			const=__A     ,			nargs='?'					)
     self.argparsersEqual(__A     ,			__A					)

     __UpperCAmelCase     :   str					=   ['--foo', '1', '--baz', 'quux', '--bar', '0.5']
     ((__UpperCAmelCase    )					,        )     :   List[str]					=   parser.parse_args_into_dataclasses(__A     ,			look_for_args_file=__A					)
     self.assertFalse(example.flag					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[Any]					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   Optional[Any]					=   argparse.ArgumentParser()
     expected.add_argument('--foo'     ,			default=42     ,			type=__A					)
     expected.add_argument('--baz'     ,			default='toto'     ,			type=__A     ,			help='help message'					)
     self.argparsersEqual(__A     ,			__A					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   int					=   argparse.ArgumentParser()
     expected.add_argument('--foo'     ,			type=__A     ,			default=__A     ,			const=__A     ,			nargs='?'					)
     expected.add_argument('--baz'     ,			type=__A     ,			default=__A     ,			const=__A     ,			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=__A     ,			dest='baz'					)
     expected.add_argument('--opt'     ,			type=__A     ,			default=__A					)

     __UpperCAmelCase     :   int					=   [WithDefaultBoolExample]
     if is_python_no_less_than_3_10:
      dataclass_types.append(__A					)

     for dataclass_type in dataclass_types:
      __UpperCAmelCase     :   List[str]					=   HfArgumentParser(__A					)
      self.argparsersEqual(__A     ,			__A					)

      __UpperCAmelCase     :   str					=   parser.parse_args([]					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			baz=__A     ,			opt=__A					)					)

      __UpperCAmelCase     :   int					=   parser.parse_args(['--foo', '--no_baz']					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			baz=__A     ,			opt=__A					)					)

      __UpperCAmelCase     :   List[str]					=   parser.parse_args(['--foo', '--baz']					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			baz=__A     ,			opt=__A					)					)

      __UpperCAmelCase     :   List[str]					=   parser.parse_args(['--foo', 'True', '--baz', 'True', '--opt', 'True']					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			baz=__A     ,			opt=__A					)					)

      __UpperCAmelCase     :   str					=   parser.parse_args(['--foo', 'False', '--baz', 'False', '--opt', 'False']					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			baz=__A     ,			opt=__A					)					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[str]					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   int					=   argparse.ArgumentParser()
     expected.add_argument(
         '--foo'     ,			default='toto'     ,			choices=['titi', 'toto', 42]     ,			type=make_choice_type_function(['titi', 'toto', 42]					)     ,			)
     self.argparsersEqual(__A     ,			__A					)

     __UpperCAmelCase     :   int					=   parser.parse_args([]					)
     self.assertEqual(args.foo     ,			'toto'					)
     __UpperCAmelCase     :   Union[str, Any]					=   parser.parse_args_into_dataclasses([]					)[0]
     self.assertEqual(enum_ex.foo     ,			MixedTypeEnum.toto					)

     __UpperCAmelCase     :   Tuple					=   parser.parse_args(['--foo', 'titi']					)
     self.assertEqual(args.foo     ,			'titi'					)
     __UpperCAmelCase     :   List[Any]					=   parser.parse_args_into_dataclasses(['--foo', 'titi']					)[0]
     self.assertEqual(enum_ex.foo     ,			MixedTypeEnum.titi					)

     __UpperCAmelCase     :   List[Any]					=   parser.parse_args(['--foo', '42']					)
     self.assertEqual(args.foo     ,			42					)
     __UpperCAmelCase     :   Optional[int]					=   parser.parse_args_into_dataclasses(['--foo', '42']					)[0]
     self.assertEqual(enum_ex.foo     ,			MixedTypeEnum.fourtytwo					)



    def 					__lowerCamelCase						(  self					):






     @dataclass
     class UpperCAmelCase							:
         _A :			Literal["titi", "toto", 42]						   =       "toto"



     __UpperCAmelCase     :   str					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   Union[str, Any]					=   argparse.ArgumentParser()
     expected.add_argument(
         '--foo'     ,			default='toto'     ,			choices=('titi', 'toto', 42)     ,			type=make_choice_type_function(['titi', 'toto', 42]					)     ,			)
     self.argparsersEqual(__A     ,			__A					)

     __UpperCAmelCase     :   Any					=   parser.parse_args([]					)
     self.assertEqual(args.foo     ,			'toto'					)

     __UpperCAmelCase     :   Union[str, Any]					=   parser.parse_args(['--foo', 'titi']					)
     self.assertEqual(args.foo     ,			'titi'					)

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



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Optional[int]					=   HfArgumentParser(__A					)

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

     self.argparsersEqual(__A     ,			__A					)

     __UpperCAmelCase     :   List[str]					=   parser.parse_args([]					)
     self.assertEqual(
         __A     ,			Namespace(foo_int=[]     ,			bar_int=[1, 2, 3]     ,			foo_str=['Hallo', 'Bonjour', 'Hello']     ,			foo_float=[0.1, 0.2, 0.3]					)     ,			)

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



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Dict					=   argparse.ArgumentParser()
     expected.add_argument('--foo'     ,			default=__A     ,			type=__A					)
     expected.add_argument('--bar'     ,			default=__A     ,			type=__A     ,			help='help message'					)
     expected.add_argument('--baz'     ,			default=__A     ,			type=__A					)
     expected.add_argument('--ces'     ,			nargs='+'     ,			default=[]     ,			type=__A					)
     expected.add_argument('--des'     ,			nargs='+'     ,			default=[]     ,			type=__A					)

     __UpperCAmelCase     :   int					=   [OptionalExample]
     if is_python_no_less_than_3_10:
      dataclass_types.append(__A					)

     for dataclass_type in dataclass_types:
      __UpperCAmelCase     :   Tuple					=   HfArgumentParser(__A					)

      self.argparsersEqual(__A     ,			__A					)

      __UpperCAmelCase     :   List[str]					=   parser.parse_args([]					)
      self.assertEqual(__A     ,			Namespace(foo=__A     ,			bar=__A     ,			baz=__A     ,			ces=[]     ,			des=[]					)					)

      __UpperCAmelCase     :   str					=   parser.parse_args('--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'.split()					)
      self.assertEqual(__A     ,			Namespace(foo=12     ,			bar=3.1_4     ,			baz='42'     ,			ces=['a', 'b', 'c']     ,			des=[1, 2, 3]					)					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Optional[Any]					=   HfArgumentParser(__A					)

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



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Tuple					=   HfArgumentParser(__A					)

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



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   str					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   Any					=   {
         'foo': 12,
         'bar': 3.1_4,
         'baz': '42',
         'flag': True,
     }

     __UpperCAmelCase     :   Optional[Any]					=   parser.parse_dict(__A					)[0]
     __UpperCAmelCase     :   int					=   BasicExample(**__A					)
     self.assertEqual(__A     ,			__A					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   str					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   List[str]					=   {
         'foo': 12,
         'bar': 3.1_4,
         'baz': '42',
         'flag': True,
         'extra': 42,
     }

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



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   List[str]					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   List[Any]					=   {
         'foo': 12,
         'bar': 3.1_4,
         'baz': '42',
         'flag': True,
     }
     with tempfile.TemporaryDirectory() as tmp_dir:
      __UpperCAmelCase     :   int					=   os.path.join(__A     ,			'temp_json'					)
      os.mkdir(__A					)
      with open(temp_local_path + '.json'     ,			'w+'					) as f:
       json.dump(__A     ,			__A					)
      __UpperCAmelCase     :   str					=   parser.parse_yaml_file(Path(temp_local_path + '.json'					)					)[0]

     __UpperCAmelCase     :   Optional[int]					=   BasicExample(**__A					)
     self.assertEqual(__A     ,			__A					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Optional[int]					=   HfArgumentParser(__A					)

     __UpperCAmelCase     :   Dict					=   {
         'foo': 12,
         'bar': 3.1_4,
         'baz': '42',
         'flag': True,
     }
     with tempfile.TemporaryDirectory() as tmp_dir:
      __UpperCAmelCase     :   Union[str, Any]					=   os.path.join(__A     ,			'temp_yaml'					)
      os.mkdir(__A					)
      with open(temp_local_path + '.yaml'     ,			'w+'					) as f:
       yaml.dump(__A     ,			__A					)
      __UpperCAmelCase     :   List[str]					=   parser.parse_yaml_file(Path(temp_local_path + '.yaml'					)					)[0]
     __UpperCAmelCase     :   Optional[Any]					=   BasicExample(**__A					)
     self.assertEqual(__A     ,			__A					)




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Dict					=   HfArgumentParser(__A					)
     self.assertIsNotNone(__A					)












'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A:					Tuple							=				logging.get_logger(__name__)






class UpperCAmelCase							(		UpperCAmelCase_							):
    _A :			List[Any]						   =       """timm_backbone"""



    def __init__(  self     ,			__A=None     ,			__A=3     ,			__A=True     ,			__A=True     ,			__A=None     ,			**__A     ,			):
     super().__init__(**__A					)
     __UpperCAmelCase					=   backbone
     __UpperCAmelCase					=   num_channels
     __UpperCAmelCase					=   features_only
     __UpperCAmelCase					=   use_pretrained_backbone
     __UpperCAmelCase					=   True
     __UpperCAmelCase					=   out_indices if out_indices is not None else (-1,)





