

"""simple docstring"""

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_UpperCamelCase		     =    logging.get_logger(__name__)

_UpperCamelCase		     =    {
    """shi-labs/dinat-mini-in1k-224""": """https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json""",
    # See all Dinat models at https://huggingface.co/models?filter=dinat
}






class 			__a					(						__magic_name__       ,	__magic_name__       ):





       """simple docstring"""


       __UpperCamelCase					:      Tuple    =						'dinat'

       __UpperCamelCase					:      List[Any]    =						{
           'num_attention_heads': 'num_heads',
           'num_hidden_layers': 'num_layers',
       }






       def __init__(   self			,					snake_case=4			,					snake_case=3			,					snake_case=64			,					snake_case=[3, 4, 6, 5]			,					snake_case=[2, 4, 8, 16]			,					snake_case=7			,					snake_case=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]			,					snake_case=3.0			,					snake_case=True			,					snake_case=0.0			,					snake_case=0.0			,					snake_case=0.1			,					snake_case="gelu"			,					snake_case=0.02			,					snake_case=1e-5			,					snake_case=0.0			,					snake_case=None			,					snake_case=None			,					**snake_case			,					):





        """simple docstring"""

        super().__init__(**snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				patch_size
        lowerCAmelCase__   :				Tuple 			=				num_channels
        lowerCAmelCase__   :				Tuple 			=				embed_dim
        lowerCAmelCase__   :				Union[str, Any] 			=				depths
        lowerCAmelCase__   :				Optional[Any] 			=				len(snake_case   )
        lowerCAmelCase__   :				List[str] 			=				num_heads
        lowerCAmelCase__   :				Dict 			=				kernel_size
        lowerCAmelCase__   :				Any 			=				dilations
        lowerCAmelCase__   :				Any 			=				mlp_ratio
        lowerCAmelCase__   :				Tuple 			=				qkv_bias
        lowerCAmelCase__   :				int 			=				hidden_dropout_prob
        lowerCAmelCase__   :				Any 			=				attention_probs_dropout_prob
        lowerCAmelCase__   :				str 			=				drop_path_rate
        lowerCAmelCase__   :				Union[str, Any] 			=				hidden_act
        lowerCAmelCase__   :				Tuple 			=				layer_norm_eps
        lowerCAmelCase__   :				str 			=				initializer_range
        # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel
        # this indicates the channel dimension after the last stage of the model
        lowerCAmelCase__   :				int 			=				int(embed_dim * 2 ** (len(snake_case   ) - 1)   )
        lowerCAmelCase__   :				Optional[Any] 			=				layer_scale_init_value
        lowerCAmelCase__   :				List[str] 			=				["stem"] + [F"""stage{idx}""" for idx in range(1			,					len(snake_case   ) + 1   )]
        lowerCAmelCase__			,						lowerCAmelCase__   :				Union[str, Any] 			=				get_aligned_output_features_output_indices(
            out_features=snake_case			,					out_indices=snake_case			,					stage_names=self.stage_names   )









"""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
_UpperCamelCase		     =    sys.version_info >= (3, 1_0)



def       SCREAMING_SNAKE_CASE							( lowercase__=None					,					lowercase__=None   )			->						List[Any]:
 return field(default_factory=lambda: default					,					metadata=lowercase__   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      int
       __UpperCamelCase					:      float
       __UpperCamelCase					:      str
       __UpperCamelCase					:      bool






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      int    =						42
       __UpperCamelCase					:      str    =						field(default='toto'       ,	metadata={'help': 'help message'}       )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      bool    =						False
       __UpperCamelCase					:      bool    =						True
       __UpperCamelCase					:      Optional[bool]    =						None






class 			__a					(						__magic_name__       ):





       """simple docstring"""


       __UpperCamelCase					:      List[str]    =						'titi'
       __UpperCamelCase					:      Tuple    =						'toto'






class 			__a					(						__magic_name__       ):





       """simple docstring"""


       __UpperCamelCase					:      Tuple    =						'titi'
       __UpperCamelCase					:      List[Any]    =						'toto'
       __UpperCamelCase					:      List[str]    =						42






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      BasicEnum    =						"toto"






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[int] 			=				BasicEnum(self.foo   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      MixedTypeEnum    =						"toto"






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				List[str] 			=				MixedTypeEnum(self.foo   )






@dataclass
class 			__a					:





       """simple docstring"""


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






@dataclass
class 			__a					:





       """simple docstring"""


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






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      List[int]    =						field()
       __UpperCamelCase					:      str    =						field()
       __UpperCamelCase					:      BasicEnum    =						field()






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				BasicEnum(self.required_enum   )






@dataclass
class 			__a					:





       """simple docstring"""


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


if is_python_no_less_than_3_10:






    @dataclass
    class 			__a					:





           """simple docstring"""


           __UpperCamelCase					:      bool    =						False
           __UpperCamelCase					:      bool    =						True
           __UpperCamelCase					:      bool | None    =						None






    @dataclass
    class 			__a					:





           """simple docstring"""


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






class 			__a					(						unittest.TestCase       ):





       """simple docstring"""


       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case   ):





        """simple docstring"""

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

         self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--bar"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--baz"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--flag"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					nargs="?"   )
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				["--foo", "1", "--baz", "quux", "--bar", "0.5"]
        ((lowerCAmelCase__)			,						)   :				Dict 			=				parser.parse_args_into_dataclasses(snake_case			,					look_for_args_file=snake_case   )
        self.assertFalse(example.flag   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					default=42			,					type=snake_case   )
        expected.add_argument("--baz"			,					default="toto"			,					type=snake_case			,					help="help message"   )
        self.argparsersEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					nargs="?"   )
        expected.add_argument("--baz"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					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=snake_case			,					dest="baz"   )
        expected.add_argument("--opt"			,					type=snake_case			,					default=snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				[WithDefaultBoolExample]
        if is_python_no_less_than_3_10:
         dataclass_types.append(snake_case   )

        for dataclass_type in dataclass_types:
         lowerCAmelCase__   :				Optional[Any] 			=				HfArgumentParser(snake_case   )
         self.argparsersEqual(snake_case			,					snake_case   )

         lowerCAmelCase__   :				Union[str, Any] 			=				parser.parse_args([]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				List[str] 			=				parser.parse_args(["--foo", "--no_baz"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				Optional[Any] 			=				parser.parse_args(["--foo", "--baz"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				List[Any] 			=				parser.parse_args(["--foo", "True", "--baz", "True", "--opt", "True"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				Optional[int] 			=				parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				argparse.ArgumentParser()
        expected.add_argument(
            "--foo"			,					default="toto"			,					choices=["titi", "toto", 42]			,					type=make_choice_type_function(["titi", "toto", 42]   )			,					)
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				Union[str, Any] 			=				parser.parse_args([]   )
        self.assertEqual(args.foo			,					"toto"   )
        lowerCAmelCase__   :				List[str] 			=				parser.parse_args_into_dataclasses([]   )[0]
        self.assertEqual(enum_ex.foo			,					MixedTypeEnum.toto   )

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

        lowerCAmelCase__   :				Tuple 			=				parser.parse_args(["--foo", "42"]   )
        self.assertEqual(args.foo			,					42   )
        lowerCAmelCase__   :				Tuple 			=				parser.parse_args_into_dataclasses(["--foo", "42"]   )[0]
        self.assertEqual(enum_ex.foo			,					MixedTypeEnum.fourtytwo   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        @dataclass
        class 			__a					:





               """simple docstring"""


               __UpperCamelCase					:      Literal["titi", "toto", 42]    =						"toto"




        lowerCAmelCase__   :				Dict 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Dict 			=				argparse.ArgumentParser()
        expected.add_argument(
            "--foo"			,					default="toto"			,					choices=("titi", "toto", 42)			,					type=make_choice_type_function(["titi", "toto", 42]   )			,					)
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				int 			=				parser.parse_args([]   )
        self.assertEqual(args.foo			,					"toto"   )

        lowerCAmelCase__   :				Optional[int] 			=				parser.parse_args(["--foo", "titi"]   )
        self.assertEqual(args.foo			,					"titi"   )

        lowerCAmelCase__   :				int 			=				parser.parse_args(["--foo", "42"]   )
        self.assertEqual(args.foo			,					42   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Union[str, Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo_int"			,					nargs="+"			,					default=[]			,					type=snake_case   )
        expected.add_argument("--bar_int"			,					nargs="+"			,					default=[1, 2, 3]			,					type=snake_case   )
        expected.add_argument("--foo_str"			,					nargs="+"			,					default=["Hallo", "Bonjour", "Hello"]			,					type=snake_case   )
        expected.add_argument("--foo_float"			,					nargs="+"			,					default=[0.1, 0.2, 0.3]			,					type=snake_case   )

        self.argparsersEqual(snake_case			,					snake_case   )

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

        lowerCAmelCase__   :				List[Any] 			=				parser.parse_args("--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7".split()   )
        self.assertEqual(snake_case			,					Namespace(foo_int=[1]			,					bar_int=[2, 3]			,					foo_str=["a", "b", "c"]			,					foo_float=[0.1, 0.7]   )   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

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

        lowerCAmelCase__   :				Optional[Any] 			=				[OptionalExample]
        if is_python_no_less_than_3_10:
         dataclass_types.append(snake_case   )

        for dataclass_type in dataclass_types:
         lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

         self.argparsersEqual(snake_case			,					snake_case   )

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

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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--required_list"			,					nargs="+"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--required_str"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument(
            "--required_enum"			,					type=make_choice_type_function(["titi", "toto"]   )			,					choices=["titi", "toto"]			,					required=snake_case			,					)
        self.argparsersEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Dict 			=				HfArgumentParser(snake_case   )

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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
        }

        lowerCAmelCase__   :				Tuple 			=				parser.parse_dict(snake_case   )[0]
        lowerCAmelCase__   :				Any 			=				BasicExample(**snake_case   )
        self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
            "extra": 42,
        }

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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

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

        lowerCAmelCase__   :				str 			=				BasicExample(**snake_case   )
        self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				HfArgumentParser(snake_case   )

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






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )
        self.assertIsNotNone(snake_case   )






