






'''simple docstring'''







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_A	:			Union[str, Any]         =logging.get_logger(__name__)

_A	:			Dict         ={
    '''hustvl/yolos-small''': '''https://huggingface.co/hustvl/yolos-small/resolve/main/config.json''',
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}

class _lowercase	(				_lowercase		):
							a				      =       """yolos"""




							def __init__(							self:				List[Any]			,							UpperCamelCase__:				Any=768			,							UpperCamelCase__:				Optional[Any]=12			,							UpperCamelCase__:				int=12			,							UpperCamelCase__:				int=3_072			,							UpperCamelCase__:				Dict="gelu"			,							UpperCamelCase__:				int=0.0			,							UpperCamelCase__:				Dict=0.0			,							UpperCamelCase__:				int=0.02			,							UpperCamelCase__:				Optional[int]=1e-12			,							UpperCamelCase__:				Optional[Any]=[512, 864]			,							UpperCamelCase__:				List[Any]=16			,							UpperCamelCase__:				str=3			,							UpperCamelCase__:				Dict=True			,							UpperCamelCase__:				Optional[int]=100			,							UpperCamelCase__:				Union[str, Any]=True			,							UpperCamelCase__:				Tuple=False			,							UpperCamelCase__:				int=1			,							UpperCamelCase__:				str=5			,							UpperCamelCase__:				List[str]=2			,							UpperCamelCase__:				Optional[Any]=5			,							UpperCamelCase__:				Optional[int]=2			,							UpperCamelCase__:				Dict=0.1			,							**UpperCamelCase__:				List[Any]			,							):
														super().__init__(**UpperCamelCase__     )

														lowerCamelCase__					:	Any         =       hidden_size
														lowerCamelCase__					:	str         =       num_hidden_layers
														lowerCamelCase__					:	List[str]         =       num_attention_heads
														lowerCamelCase__					:	int         =       intermediate_size
														lowerCamelCase__					:	List[Any]         =       hidden_act
														lowerCamelCase__					:	Optional[int]         =       hidden_dropout_prob
														lowerCamelCase__					:	Union[str, Any]         =       attention_probs_dropout_prob
														lowerCamelCase__					:	Union[str, Any]         =       initializer_range
														lowerCamelCase__					:	Dict         =       layer_norm_eps
														lowerCamelCase__					:	List[str]         =       image_size
														lowerCamelCase__					:	Any         =       patch_size
														lowerCamelCase__					:	Union[str, Any]         =       num_channels
														lowerCamelCase__					:	Dict         =       qkv_bias
														lowerCamelCase__					:	Optional[int]         =       num_detection_tokens
														lowerCamelCase__					:	Optional[int]         =       use_mid_position_embeddings
														lowerCamelCase__					:	Union[str, Any]         =       auxiliary_loss
														# Hungarian matcher
														lowerCamelCase__					:	int         =       class_cost
														lowerCamelCase__					:	Any         =       bbox_cost
														lowerCamelCase__					:	str         =       giou_cost
														# Loss coefficients
														lowerCamelCase__					:	Dict         =       bbox_loss_coefficient
														lowerCamelCase__					:	Tuple         =       giou_loss_coefficient
														lowerCamelCase__					:	int         =       eos_coefficient



class _lowercase	(				_lowercase		):
							a				      =       version.parse("""1.11"""		)




							@property
							def 		lowerCamelCase_				(							self:				Union[str, Any]     ):
														return OrderedDict(
														    [
														        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
														    ]     )




							@property
							def 		lowerCamelCase_				(							self:				Tuple     ):
														return 1e-4




							@property
							def 		lowerCamelCase_				(							self:				str     ):
														return 12


import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


A   :     Tuple       =				get_tests_dir("fixtures")


class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  def       __A   (							self       :				Union[str, Any]      )     ->		Union[str, Any]:
        # A mock response for an HTTP head request to emulate server down
        SCREAMING_SNAKE_CASE_      =     mock.Mock()
        SCREAMING_SNAKE_CASE_      =     500
        SCREAMING_SNAKE_CASE_      =     {}
        SCREAMING_SNAKE_CASE_      =     HTTPError
        SCREAMING_SNAKE_CASE_      =     {}

        # Download this model to make sure it's in the cache.
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"      )
        # Under the mock environment we get a 500 error when trying to reach the model.
        with mock.patch("requests.Session.request"     ,   return_value=__magic_name__      ) as mock_head:
              SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"      )
              # This check we did call the fake head request
              mock_head.assert_called()







  def       __A   (							self       :				Optional[int]      )     ->		Tuple:
        # This test is for deprecated behavior and can be removed in v5
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(
            "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"      )



@is_staging_test
class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  @classmethod
  def       __A   (							cls       :				Any      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     TOKEN
        HfFolder.save_token(__magic_name__      )







  @classmethod
  def       __A   (							cls       :				int      )     ->		Optional[Any]:
        try:
              delete_repo(token=cls._token     ,   repo_id="test-feature-extractor"      )
        except HTTPError:
              pass

        try:
              delete_repo(token=cls._token     ,   repo_id="valid_org/test-feature-extractor-org"      )
        except HTTPError:
              pass

        try:
              delete_repo(token=cls._token     ,   repo_id="test-dynamic-feature-extractor"      )
        except HTTPError:
              pass







  def       __A   (							self       :				str      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(__magic_name__      )
        feature_extractor.push_to_hub("test-feature-extractor"     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )

        # Reset repo
        delete_repo(token=self._token     ,   repo_id="test-feature-extractor"      )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
              feature_extractor.save_pretrained(
                  __magic_name__     ,   repo_id="test-feature-extractor"     ,   push_to_hub=__magic_name__     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )







  def       __A   (							self       :				Dict      )     ->		str:
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(__magic_name__      )
        feature_extractor.push_to_hub("valid_org/test-feature-extractor"     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor"      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )

        # Reset repo
        delete_repo(token=self._token     ,   repo_id="valid_org/test-feature-extractor"      )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
              feature_extractor.save_pretrained(
                  __magic_name__     ,   repo_id="valid_org/test-feature-extractor-org"     ,   push_to_hub=__magic_name__     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor-org"      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )







  def       __A   (							self       :				List[Any]      )     ->		Dict:
        CustomFeatureExtractor.register_for_auto_class()
        SCREAMING_SNAKE_CASE_      =     CustomFeatureExtractor.from_pretrained(__magic_name__      )

        feature_extractor.push_to_hub("test-dynamic-feature-extractor"     ,   use_auth_token=self._token      )

        # This has added the proper auto_map field to the config
        self.assertDictEqual(
            feature_extractor.auto_map     ,   {"AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor"}     ,   )

        SCREAMING_SNAKE_CASE_      =     AutoFeatureExtractor.from_pretrained(
            F'''{USER}/test-dynamic-feature-extractor'''     ,   trust_remote_code=__magic_name__      )
        # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
        self.assertEqual(new_feature_extractor.__class__.__name__     ,   "CustomFeatureExtractor"      )


