

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 	_snake_case		(    SCREAMING_SNAKE_CASE=None		,							SCREAMING_SNAKE_CASE=None				)       ->      Union[str, Any]:

     """simple docstring"""







     return field(default_factory=lambda: default		,							metadata=SCREAMING_SNAKE_CASE				)





@dataclass
class A__    :



 """simple docstring"""







 _lowercase     :					int
 _lowercase     :					float
 _lowercase     :					str
 _lowercase     :					bool





@dataclass
class A__    :



 """simple docstring"""







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





@dataclass
class A__    :



 """simple docstring"""







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





class A__    ( A ):



 """simple docstring"""







 _lowercase     :					Tuple      =					'''titi'''
 _lowercase     :					Union[str, Any]      =					'''toto'''





class A__    ( A ):



 """simple docstring"""







 _lowercase     :					Tuple      =					'''titi'''
 _lowercase     :					List[Any]      =					'''toto'''
 _lowercase     :					Optional[int]      =					42





@dataclass
class A__    :



 """simple docstring"""







 _lowercase     :					BasicEnum      =					"toto"

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    BasicEnum(self.foo       )





@dataclass
class A__    :



 """simple docstring"""







 _lowercase     :					MixedTypeEnum      =					"toto"

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    MixedTypeEnum(self.foo       )





@dataclass
class A__    :



 """simple docstring"""







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





@dataclass
class A__    :



 """simple docstring"""







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





@dataclass
class A__    :



 """simple docstring"""







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

 def    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    BasicEnum(self.required_enum       )





@dataclass
class A__    :



 """simple docstring"""







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


if is_python_no_less_than_3_10:





  @dataclass
  class A__    :



   """simple docstring"""







   _lowercase     :					bool      =					False
   _lowercase     :					bool      =					True
   _lowercase     :					bool | None      =					None





  @dataclass
  class A__    :



   """simple docstring"""







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





class A__    ( unittest.TestCase ):



 """simple docstring"""







 def    __magic_name__       (		self :	Optional[Any]     ,						A_ :	argparse.ArgumentParser     ,						A_ :	argparse.ArgumentParser       ):






      '''simple docstring'''




      self.assertEqual(len(a._actions       )     ,						len(b._actions       )       )
      for x, y in zip(a._actions     ,						b._actions       ):
           _lowerCAmelCase   :					Optional[int]        =    {k: v for k, v in vars(A_       ).items() if k != "container"}
           _lowerCAmelCase   :					Tuple        =    {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    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					List[Any]        =    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_       )

      _lowerCAmelCase   :					Dict        =    ["--foo", "1", "--baz", "quux", "--bar", "0.5"]
      (_lowerCAmelCase			)   :					Union[str, Any]        =    parser.parse_args_into_dataclasses(A_     ,						look_for_args_file=A_       )
      self.assertFalse(example.flag       )

 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					List[str]        =    argparse.ArgumentParser()
      expected.add_argument("--foo"     ,						default=4_2     ,						type=A_       )
      expected.add_argument("--baz"     ,						default="toto"     ,						type=A_     ,						help="help message"       )
      self.argparsersEqual(A_     ,						A_       )

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[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_       )

      _lowerCAmelCase   :					str        =    [WithDefaultBoolExample]
      if is_python_no_less_than_3_10:
           dataclass_types.append(A_       )

      for dataclass_type in dataclass_types:
           _lowerCAmelCase   :					Dict        =    HfArgumentParser(A_       )
           self.argparsersEqual(A_     ,						A_       )

           _lowerCAmelCase   :					Optional[int]        =    parser.parse_args([]       )
           self.assertEqual(A_     ,						Namespace(foo=A_     ,						baz=A_     ,						opt=A_       )       )

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

           _lowerCAmelCase   :					Any        =    parser.parse_args(["--foo", "--baz"]       )
           self.assertEqual(A_     ,						Namespace(foo=A_     ,						baz=A_     ,						opt=A_       )       )

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

           _lowerCAmelCase   :					List[Any]        =    parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]       )
           self.assertEqual(A_     ,						Namespace(foo=A_     ,						baz=A_     ,						opt=A_       )       )

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					List[str]        =    argparse.ArgumentParser()
      expected.add_argument(
          "--foo"     ,						default="toto"     ,						choices=["titi", "toto", 4_2]     ,						type=make_choice_type_function(["titi", "toto", 4_2]       )     ,						)
      self.argparsersEqual(A_     ,						A_       )

      _lowerCAmelCase   :					Dict        =    parser.parse_args([]       )
      self.assertEqual(args.foo     ,						"toto"       )
      _lowerCAmelCase   :					Any        =    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   :					Optional[Any]        =    parser.parse_args_into_dataclasses(["--foo", "titi"]       )[0]
      self.assertEqual(enum_ex.foo     ,						MixedTypeEnum.titi       )

      _lowerCAmelCase   :					Optional[Any]        =    parser.parse_args(["--foo", "42"]       )
      self.assertEqual(args.foo     ,						4_2       )
      _lowerCAmelCase   :					Optional[Any]        =    parser.parse_args_into_dataclasses(["--foo", "42"]       )[0]
      self.assertEqual(enum_ex.foo     ,						MixedTypeEnum.fourtytwo       )

 def    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




      @dataclass
      class A__    :



       """simple docstring"""







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

      _lowerCAmelCase   :					int        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					int        =    argparse.ArgumentParser()
      expected.add_argument(
          "--foo"     ,						default="toto"     ,						choices=("titi", "toto", 4_2)     ,						type=make_choice_type_function(["titi", "toto", 4_2]       )     ,						)
      self.argparsersEqual(A_     ,						A_       )

      _lowerCAmelCase   :					Union[str, Any]        =    parser.parse_args([]       )
      self.assertEqual(args.foo     ,						"toto"       )

      _lowerCAmelCase   :					Tuple        =    parser.parse_args(["--foo", "titi"]       )
      self.assertEqual(args.foo     ,						"titi"       )

      _lowerCAmelCase   :					str        =    parser.parse_args(["--foo", "42"]       )
      self.assertEqual(args.foo     ,						4_2       )

 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					Optional[Any]        =    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_       )

      _lowerCAmelCase   :					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]       )     ,						)

      _lowerCAmelCase   :					List[str]        =    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    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Union[str, Any]        =    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_       )

      _lowerCAmelCase   :					Any        =    [OptionalExample]
      if is_python_no_less_than_3_10:
           dataclass_types.append(A_       )

      for dataclass_type in dataclass_types:
           _lowerCAmelCase   :					Tuple        =    HfArgumentParser(A_       )

           self.argparsersEqual(A_     ,						A_       )

           _lowerCAmelCase   :					str        =    parser.parse_args([]       )
           self.assertEqual(A_     ,						Namespace(foo=A_     ,						bar=A_     ,						baz=A_     ,						ces=[]     ,						des=[]       )       )

           _lowerCAmelCase   :					Union[str, Any]        =    parser.parse_args("--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3".split()       )
           self.assertEqual(A_     ,						Namespace(foo=1_2     ,						bar=3.14     ,						baz="42"     ,						ces=["a", "b", "c"]     ,						des=[1, 2, 3]       )       )

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					Optional[int]        =    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    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					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    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					Any        =    {
          "foo": 1_2,
          "bar": 3.14,
          "baz": "42",
          "flag": True,
      }

      _lowerCAmelCase   :					List[Any]        =    parser.parse_dict(A_       )[0]
      _lowerCAmelCase   :					List[Any]        =    BasicExample(**A_       )
      self.assertEqual(A_     ,						A_       )

 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					Any        =    {
          "foo": 1_2,
          "bar": 3.14,
          "baz": "42",
          "flag": True,
          "extra": 4_2,
      }

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

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Dict        =    HfArgumentParser(A_       )

      _lowerCAmelCase   :					Union[str, Any]        =    {
          "foo": 1_2,
          "bar": 3.14,
          "baz": "42",
          "flag": True,
      }
      with tempfile.TemporaryDirectory() as tmp_dir:
           _lowerCAmelCase   :					Tuple        =    os.path.join(A_     ,						"temp_json"       )
           os.mkdir(A_       )
           with open(temp_local_path + ".json"     ,						"w+"       ) as f:
                json.dump(A_     ,						A_       )
           _lowerCAmelCase   :					List[str]        =    parser.parse_yaml_file(Path(temp_local_path + ".json"       )       )[0]

      _lowerCAmelCase   :					str        =    BasicExample(**A_       )
      self.assertEqual(A_     ,						A_       )

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    HfArgumentParser(A_       )

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


 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    HfArgumentParser(A_       )
      self.assertIsNotNone(A_       )









from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import TFCvtForImageClassification, TFCvtModel
  from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor





class A__    ( A ):



 """simple docstring"""







 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    self.config_class(**self.inputs_dict       )
      self.parent.assertTrue(hasattr(A_     ,						"embed_dim"       )       )
      self.parent.assertTrue(hasattr(A_     ,						"num_heads"       )       )





class A__    :



 """simple docstring"""







 def __init__(		self :	Tuple     ,						A_ :	int     ,						A_ :	Dict=1_3     ,						A_ :	int=6_4     ,						A_ :	str=3     ,						A_ :	Optional[int]=[1_6, 4_8, 9_6]     ,						A_ :	int=[1, 3, 6]     ,						A_ :	Optional[int]=[1, 2, 1_0]     ,						A_ :	Any=[7, 3, 3]     ,						A_ :	Tuple=[4, 2, 2]     ,						A_ :	str=[2, 1, 1]     ,						A_ :	Optional[Any]=[2, 2, 2]     ,						A_ :	Union[str, Any]=[False, False, True]     ,						A_ :	Union[str, Any]=[0.0, 0.0, 0.0]     ,						A_ :	Any=0.02     ,						A_ :	Optional[int]=1E-12     ,						A_ :	str=True     ,						A_ :	List[Any]=True     ,						A_ :	Union[str, Any]=2     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Dict        =    parent
      _lowerCAmelCase   :					int        =    batch_size
      _lowerCAmelCase   :					Union[str, Any]        =    image_size
      _lowerCAmelCase   :					Optional[Any]        =    patch_sizes
      _lowerCAmelCase   :					Optional[int]        =    patch_stride
      _lowerCAmelCase   :					List[str]        =    patch_padding
      _lowerCAmelCase   :					str        =    is_training
      _lowerCAmelCase   :					Any        =    use_labels
      _lowerCAmelCase   :					Dict        =    num_labels
      _lowerCAmelCase   :					Tuple        =    num_channels
      _lowerCAmelCase   :					Tuple        =    embed_dim
      _lowerCAmelCase   :					List[Any]        =    num_heads
      _lowerCAmelCase   :					Union[str, Any]        =    stride_kv
      _lowerCAmelCase   :					Tuple        =    depth
      _lowerCAmelCase   :					List[str]        =    cls_token
      _lowerCAmelCase   :					Tuple        =    attention_drop_rate
      _lowerCAmelCase   :					Optional[Any]        =    initializer_range
      _lowerCAmelCase   :					Optional[int]        =    layer_norm_eps

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

      _lowerCAmelCase   :					int        =    None
      if self.use_labels:
           # create a random int32 tensor of given shape
           _lowerCAmelCase   :					List[Any]        =    ids_tensor([self.batch_size]     ,						self.num_labels       )

      _lowerCAmelCase   :					Tuple        =    self.get_config()
      return config, pixel_values, labels

 def    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




      return CvtConfig(
          image_size=self.image_size     ,						num_labels=self.num_labels     ,						num_channels=self.num_channels     ,						embed_dim=self.embed_dim     ,						num_heads=self.num_heads     ,						patch_sizes=self.patch_sizes     ,						patch_padding=self.patch_padding     ,						patch_stride=self.patch_stride     ,						stride_kv=self.stride_kv     ,						depth=self.depth     ,						cls_token=self.cls_token     ,						attention_drop_rate=self.attention_drop_rate     ,						initializer_range=self.initializer_range     ,						)

 def    __magic_name__       (		self :	Union[str, Any]     ,						A_ :	str     ,						A_ :	Optional[int]     ,						A_ :	str       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    TFCvtModel(config=A_       )
      _lowerCAmelCase   :					str        =    model(A_     ,						training=A_       )
      _lowerCAmelCase   :					List[Any]        =    (self.image_size, self.image_size)
      _lowerCAmelCase      ,			_lowerCAmelCase   :					Any        =    image_size[0], image_size[1]
      for i in range(len(self.depth       )       ):
           _lowerCAmelCase   :					Union[str, Any]        =    floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
           _lowerCAmelCase   :					List[Any]        =    floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
      self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.embed_dim[-1], height, width)       )

 def    __magic_name__       (		self :	Any     ,						A_ :	Tuple     ,						A_ :	int     ,						A_ :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    self.num_labels
      _lowerCAmelCase   :					Optional[Any]        =    TFCvtForImageClassification(A_       )
      _lowerCAmelCase   :					Optional[Any]        =    model(A_     ,						labels=A_     ,						training=A_       )
      self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels)       )


 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    self.prepare_config_and_inputs()
      _lowerCAmelCase      ,			_lowerCAmelCase      ,			_lowerCAmelCase   :					List[str]        =    config_and_inputs
      _lowerCAmelCase   :					Optional[int]        =    {"pixel_values": pixel_values}
      return config, inputs_dict





@require_tf
class A__    ( A  ,		A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					Any      =						(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
 _lowercase     :					Tuple      =						(
     {'''feature-extraction''': TFCvtModel, '''image-classification''': TFCvtForImageClassification}
     if is_tf_available()
     else {}
 )
 _lowercase     :					Optional[int]      =						False
 _lowercase     :					Any      =						False
 _lowercase     :					int      =						False
 _lowercase     :					int      =						False
 _lowercase     :					Tuple      =						False

 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    TFCvtModelTester(self       )
      _lowerCAmelCase   :					Optional[Any]        =    TFCvtConfigTester(self     ,						config_class=A_     ,						has_text_modality=A_     ,						hidden_size=3_7       )

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      self.config_tester.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()

 @unittest.skip(reason="Cvt does not output attentions"       )
 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="Cvt does not use inputs_embeds"       )
 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="Cvt does not support input and output embeddings"       )
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      pass

 @unittest.skipIf(
     not is_tf_available() or len(tf.config.list_physical_devices("GPU"       )       ) == 0     ,						reason="TF does not support backprop for grouped convolutions on CPU."     ,						)
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      super().test_dataset_conversion()

 @unittest.skipIf(
     not is_tf_available() or len(tf.config.list_physical_devices("GPU"       )       ) == 0     ,						reason="TF does not support backprop for grouped convolutions on CPU."     ,						)
 @slow
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      super().test_keras_fit()

 @unittest.skip(reason="Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8"       )
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    tf.keras.mixed_precision.Policy("mixed_float16"       )
      tf.keras.mixed_precision.set_global_policy(A_       )
      super().test_keras_fit()
      tf.keras.mixed_precision.set_global_policy("float32"       )

 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      _lowerCAmelCase      ,			_lowerCAmelCase   :					List[Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _lowerCAmelCase   :					Dict        =    model_class(A_       )
           _lowerCAmelCase   :					Optional[int]        =    inspect.signature(model.call       )
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _lowerCAmelCase   :					List[Any]        =    [*signature.parameters.keys()]

           _lowerCAmelCase   :					Union[str, Any]        =    ["pixel_values"]
           self.assertListEqual(arg_names[:1]     ,						A_       )

 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      def check_hidden_states_output(A_ :	Any     ,						A_ :	Any     ,						A_ :	Dict       ):
           _lowerCAmelCase   :					Tuple        =    model_class(A_       )

           _lowerCAmelCase   :					List[Any]        =    model(**self._prepare_for_class(A_     ,						A_       )       )
           _lowerCAmelCase   :					Tuple        =    outputs.hidden_states

           _lowerCAmelCase   :					Optional[Any]        =    len(self.model_tester.depth       )
           self.assertEqual(len(A_       )     ,						A_       )

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]       )     ,						[
                   self.model_tester.embed_dim[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ]     ,						)

      _lowerCAmelCase      ,			_lowerCAmelCase   :					Tuple        =    self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _lowerCAmelCase   :					Union[str, Any]        =    True
           check_hidden_states_output(A_     ,						A_     ,						A_       )

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _lowerCAmelCase   :					List[str]        =    True

           check_hidden_states_output(A_     ,						A_     ,						A_       )

 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A_       )

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*A_       )


 @slow
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase   :					Optional[Any]        =    TFCvtModel.from_pretrained(A_       )
           self.assertIsNotNone(A_       )







def 	_snake_case		(    )       ->      Dict:

     """simple docstring"""







     _lowerCAmelCase   :					int        =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
     return image





@require_tf
@require_vision
class A__    ( unittest.TestCase ):



 """simple docstring"""







 @cached_property
 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )


 @slow
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

      _lowerCAmelCase   :					int        =    self.default_image_processor
      _lowerCAmelCase   :					Optional[Any]        =    prepare_img()
      _lowerCAmelCase   :					Optional[Any]        =    image_processor(images=A_     ,						return_tensors="tf"       )

      # forward pass
      _lowerCAmelCase   :					str        =    model(**A_       )

      # verify the logits
      _lowerCAmelCase   :					List[str]        =    tf.TensorShape((1, 1_0_0_0)       )
      self.assertEqual(outputs.logits.shape     ,						A_       )

      _lowerCAmelCase   :					Any        =    tf.constant([0.9285, 0.9015, -0.3150]       )
      self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()     ,						A_     ,						atol=1E-4       )       )






