


'''simple docstring'''




import json
import os
import shutil
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 AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


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

from test_module.custom_configuration import CustomConfig  # noqa E402


UpperCAmelCase_      :		int          =		{
    "return_dict": False,
    "output_hidden_states": True,
    "output_attentions": True,
    "torchscript": True,
    "torch_dtype": "float16",
    "use_bfloat16": True,
    "tf_legacy_loss": True,
    "pruned_heads": {"a": 1},
    "tie_word_embeddings": False,
    "is_decoder": True,
    "cross_attention_hidden_size": 128,
    "add_cross_attention": True,
    "tie_encoder_decoder": True,
    "max_length": 50,
    "min_length": 3,
    "do_sample": True,
    "early_stopping": True,
    "num_beams": 3,
    "num_beam_groups": 3,
    "diversity_penalty": 0.5,
    "temperature": 2.0,
    "top_k": 10,
    "top_p": 0.7,
    "typical_p": 0.2,
    "repetition_penalty": 0.8,
    "length_penalty": 0.8,
    "no_repeat_ngram_size": 5,
    "encoder_no_repeat_ngram_size": 5,
    "bad_words_ids": [1, 2, 3],
    "num_return_sequences": 3,
    "chunk_size_feed_forward": 5,
    "output_scores": True,
    "return_dict_in_generate": True,
    "forced_bos_token_id": 2,
    "forced_eos_token_id": 3,
    "remove_invalid_values": True,
    "architectures": ["BertModel"],
    "finetuning_task": "translation",
    "id2label": {0: "label"},
    "label2id": {"label": "0"},
    "tokenizer_class": "BertTokenizerFast",
    "prefix": "prefix",
    "bos_token_id": 6,
    "pad_token_id": 7,
    "eos_token_id": 8,
    "sep_token_id": 9,
    "decoder_start_token_id": 10,
    "exponential_decay_length_penalty": (5, 1.01),
    "suppress_tokens": [0, 1],
    "begin_suppress_tokens": 2,
    "task_specific_params": {"translation": "some_params"},
    "problem_type": "regression",
}







@is_staging_test
class 					a			(				unittest.TestCase  ):
 '''simple docstring'''




 @classmethod
 def   __UpperCamelCase   (    cls      )      ->    Union[str, Any]:
    _a					:  Tuple						=  TOKEN
    HfFolder.save_token(lowerCamelCase_      )




 @classmethod
 def   __UpperCamelCase   (    cls      )      ->    Optional[int]:
    try:
       delete_repo(token=cls._token		,      repo_id='test-config'      )
    except HTTPError:
       pass

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

    try:
       delete_repo(token=cls._token		,      repo_id='test-dynamic-config'      )
    except HTTPError:
       pass




 def   __UpperCamelCase   (    self      )      ->    Any:
    _a					:  List[str]						=  BertConfig(
        vocab_size=9_9		,      hidden_size=3_2		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=3_7      )
    config.push_to_hub('test-config'		,      use_auth_token=self._token      )

    _a					:  Optional[Any]						=  BertConfig.from_pretrained(F'''{USER}/test-config'''      )
    for k, v in config.to_dict().items():
       if k != "transformers_version":
          self.assertEqual(lowerCamelCase_		,      getattr(lowerCamelCase_		,      lowerCamelCase_      )      )

        # Reset repo
    delete_repo(token=self._token		,      repo_id='test-config'      )

    # Push to hub via save_pretrained
    with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(lowerCamelCase_		,      repo_id='test-config'		,      push_to_hub=lowerCamelCase_		,      use_auth_token=self._token      )

    _a					:  str						=  BertConfig.from_pretrained(F'''{USER}/test-config'''      )
    for k, v in config.to_dict().items():
       if k != "transformers_version":
          self.assertEqual(lowerCamelCase_		,      getattr(lowerCamelCase_		,      lowerCamelCase_      )      )




 def   __UpperCamelCase   (    self      )      ->    Optional[Any]:
    _a					:  Union[str, Any]						=  BertConfig(
        vocab_size=9_9		,      hidden_size=3_2		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=3_7      )
    config.push_to_hub('valid_org/test-config-org'		,      use_auth_token=self._token      )

    _a					:  Tuple						=  BertConfig.from_pretrained('valid_org/test-config-org'      )
    for k, v in config.to_dict().items():
       if k != "transformers_version":
          self.assertEqual(lowerCamelCase_		,      getattr(lowerCamelCase_		,      lowerCamelCase_      )      )

        # Reset repo
    delete_repo(token=self._token		,      repo_id='valid_org/test-config-org'      )

    # Push to hub via save_pretrained
    with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(
           lowerCamelCase_		,      repo_id='valid_org/test-config-org'		,      push_to_hub=lowerCamelCase_		,      use_auth_token=self._token      )

    _a					:  int						=  BertConfig.from_pretrained('valid_org/test-config-org'      )
    for k, v in config.to_dict().items():
       if k != "transformers_version":
          self.assertEqual(lowerCamelCase_		,      getattr(lowerCamelCase_		,      lowerCamelCase_      )      )




 def   __UpperCamelCase   (    self      )      ->    Dict:
    CustomConfig.register_for_auto_class()
    _a					:  Union[str, Any]						=  CustomConfig(attribute=4_2      )

    config.push_to_hub('test-dynamic-config'		,      use_auth_token=self._token      )

    # This has added the proper auto_map field to the config
    self.assertDictEqual(config.auto_map		,      {'AutoConfig': 'custom_configuration.CustomConfig'}      )

    _a					:  List[str]						=  AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''		,      trust_remote_code=lowerCamelCase_      )
    # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
    self.assertEqual(new_config.__class__.__name__		,      'CustomConfig'      )
    self.assertEqual(new_config.attribute		,      4_2      )







class 					a			(				unittest.TestCase  ):
 '''simple docstring'''




 def   __UpperCamelCase   (    self      )      ->    int:
    _a					:  int						=  GPTaConfig()

    # attempt to modify each of int/float/bool/str config records and verify they were updated
    _a					:  List[Any]						=  c.n_embd + 1  # int
    _a					:  Tuple						=  c.resid_pdrop + 1.0  # float
    _a					:  Union[str, Any]						=  not c.scale_attn_weights  # bool
    _a					:  str						=  c.summary_type + 'foo'  # str
    c.update_from_string(
        F'''n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'''      )
    self.assertEqual(lowerCamelCase_		,      c.n_embd		,      'mismatch for key: n_embd'      )
    self.assertEqual(lowerCamelCase_		,      c.resid_pdrop		,      'mismatch for key: resid_pdrop'      )
    self.assertEqual(lowerCamelCase_		,      c.scale_attn_weights		,      'mismatch for key: scale_attn_weights'      )
    self.assertEqual(lowerCamelCase_		,      c.summary_type		,      'mismatch for key: summary_type'      )




 def   __UpperCamelCase   (    self      )      ->    Optional[int]:
    _a					:  Union[str, Any]						=  PretrainedConfig()
    _a					:  int						=  [key for key in base_config.__dict__ if key not in config_common_kwargs]
    # If this part of the test fails, you have arguments to addin config_common_kwargs above.
    self.assertListEqual(
        lowerCamelCase_		,      ['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']      )
    _a					:  Optional[int]						=  [key for key, value in config_common_kwargs.items() if value == getattr(lowerCamelCase_		,      lowerCamelCase_      )]
    if len(lowerCamelCase_      ) > 0:
       raise ValueError(
           'The following keys are set with the default values in'
           ' `test_configuration_common.config_common_kwargs` pick another value for them:'
           F''' {", ".join(lowerCamelCase_      )}.'''      )




 def   __UpperCamelCase   (    self      )      ->    List[Any]:
    with self.assertRaises(lowerCamelCase_      ):
       # config is in subfolder, the following should not work without specifying the subfolder
       _a					:  List[Any]						=  BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'      )

    _a					:  Optional[Any]						=  BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'		,      subfolder='bert'      )

    self.assertIsNotNone(lowerCamelCase_      )




 def   __UpperCamelCase   (    self      )      ->    Optional[int]:
    # A mock response for an HTTP head request to emulate server down
    _a					:  Tuple						=  mock.Mock()
    _a					:  Tuple						=  5_0_0
    _a					:  str						=  {}
    _a					:  int						=  HTTPError
    _a					:  Any						=  {}

    # Download this model to make sure it's in the cache.
    _a					:  int						=  BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert'      )

    # Under the mock environment we get a 500 error when trying to reach the model.
    with mock.patch('requests.Session.request'		,      return_value=lowerCamelCase_      ) as mock_head:
       _a					:  str						=  BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert'      )
       # This check we did call the fake head request
       mock_head.assert_called()




 def   __UpperCamelCase   (    self      )      ->    Tuple:
    # This test is for deprecated behavior and can be removed in v5
    _a					:  Tuple						=  BertConfig.from_pretrained(
        'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'      )




 def   __UpperCamelCase   (    self      )      ->    Union[str, Any]:
    _a					:  Tuple						=  AutoConfig.from_pretrained('bert-base-cased'      )
    _a					:  Tuple						=  ['config.4.0.0.json']

    with tempfile.TemporaryDirectory() as tmp_dir:
       configuration.save_pretrained(lowerCamelCase_      )
       _a					:  Tuple						=  2
       json.dump(configuration.to_dict()		,      open(os.path.join(lowerCamelCase_		,      'config.4.0.0.json'      )		,      'w'      )      )

       # This should pick the new configuration file as the version of Transformers is > 4.0.0
       _a					:  int						=  AutoConfig.from_pretrained(lowerCamelCase_      )
       self.assertEqual(new_configuration.hidden_size		,      2      )

       # Will need to be adjusted if we reach v42 and this test is still here.
       # Should pick the old configuration file as the version of Transformers is < 4.42.0
       _a					:  Optional[int]						=  ['config.42.0.0.json']
       _a					:  Tuple						=  7_6_8
       configuration.save_pretrained(lowerCamelCase_      )
       shutil.move(os.path.join(lowerCamelCase_		,      'config.4.0.0.json'      )		,      os.path.join(lowerCamelCase_		,      'config.42.0.0.json'      )      )
       _a					:  List[Any]						=  AutoConfig.from_pretrained(lowerCamelCase_      )
       self.assertEqual(new_configuration.hidden_size		,      7_6_8      )




 def   __UpperCamelCase   (    self      )      ->    int:
    # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
    _a					:  Any						=  'hf-internal-testing/test-two-configs'

    import transformers as new_transformers

    _a					:  List[Any]						=  'v4.0.0'
    _a		,						_a					:  List[Any]						=  new_transformers.models.auto.AutoConfig.from_pretrained(
        lowerCamelCase_		,      return_unused_kwargs=lowerCamelCase_      )
    self.assertEqual(new_configuration.hidden_size		,      2      )
    # This checks `_configuration_file` ia not kept in the kwargs by mistake.
    self.assertDictEqual(lowerCamelCase_		,      {}      )

    # Testing an older version by monkey-patching the version in the module it's used.
    import transformers as old_transformers

    _a					:  int						=  'v3.0.0'
    _a					:  Optional[Any]						=  old_transformers.models.auto.AutoConfig.from_pretrained(lowerCamelCase_      )
    self.assertEqual(old_configuration.hidden_size		,      7_6_8      )






'''simple docstring'''




from math import cos, sin, sqrt, tau

from audio_filters.iir_filter import IIRFilter


def    UpperCAmelCase_  (       A		,	A		,	A = 1 / sqrt(2      )      ):
   '''simple docstring'''





   _a					:  List[Any]						=  tau * frequency / samplerate
   _a					:  Tuple						=  sin(A      )
   _a					:  List[Any]						=  cos(A      )
   _a					:  Union[str, Any]						=  _sin / (2 * q_factor)

   _a					:  Dict						=  (1 - _cos) / 2
   _a					:  Any						=  1 - _cos

   _a					:  Any						=  1 + alpha
   _a					:  int						=  -2 * _cos
   _a					:  str						=  1 - alpha

   _a					:  Optional[Any]						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt


def    UpperCAmelCase_  (       A		,	A		,	A = 1 / sqrt(2      )      ):
   '''simple docstring'''





   _a					:  int						=  tau * frequency / samplerate
   _a					:  int						=  sin(A      )
   _a					:  Union[str, Any]						=  cos(A      )
   _a					:  int						=  _sin / (2 * q_factor)

   _a					:  Dict						=  (1 + _cos) / 2
   _a					:  int						=  -1 - _cos

   _a					:  Optional[int]						=  1 + alpha
   _a					:  str						=  -2 * _cos
   _a					:  Dict						=  1 - alpha

   _a					:  List[str]						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt


def    UpperCAmelCase_  (       A		,	A		,	A = 1 / sqrt(2      )      ):
   '''simple docstring'''





   _a					:  str						=  tau * frequency / samplerate
   _a					:  Dict						=  sin(A      )
   _a					:  int						=  cos(A      )
   _a					:  Dict						=  _sin / (2 * q_factor)

   _a					:  List[Any]						=  _sin / 2
   _a					:  List[str]						=  0
   _a					:  Dict						=  -ba

   _a					:  List[Any]						=  1 + alpha
   _a					:  Union[str, Any]						=  -2 * _cos
   _a					:  List[Any]						=  1 - alpha

   _a					:  int						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt


def    UpperCAmelCase_  (       A		,	A		,	A = 1 / sqrt(2      )      ):
   '''simple docstring'''





   _a					:  Optional[Any]						=  tau * frequency / samplerate
   _a					:  Tuple						=  sin(A      )
   _a					:  Tuple						=  cos(A      )
   _a					:  Dict						=  _sin / (2 * q_factor)

   _a					:  List[Any]						=  1 - alpha
   _a					:  int						=  -2 * _cos
   _a					:  List[Any]						=  1 + alpha

   _a					:  str						=  IIRFilter(2      )
   filt.set_coefficients([ba, ba, ba]		,	[ba, ba, ba]      )
   return filt


def    UpperCAmelCase_  (       A		,	A		,	A		,	A = 1 / sqrt(2      )		,	):
   '''simple docstring'''





   _a					:  Union[str, Any]						=  tau * frequency / samplerate
   _a					:  str						=  sin(A      )
   _a					:  str						=  cos(A      )
   _a					:  List[Any]						=  _sin / (2 * q_factor)
   _a					:  Optional[Any]						=  1_0 ** (gain_db / 4_0)

   _a					:  Dict						=  1 + alpha * big_a
   _a					:  str						=  -2 * _cos
   _a					:  Tuple						=  1 - alpha * big_a
   _a					:  Tuple						=  1 + alpha / big_a
   _a					:  str						=  -2 * _cos
   _a					:  Union[str, Any]						=  1 - alpha / big_a

   _a					:  Optional[int]						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt


def    UpperCAmelCase_  (       A		,	A		,	A		,	A = 1 / sqrt(2      )		,	):
   '''simple docstring'''





   _a					:  Optional[int]						=  tau * frequency / samplerate
   _a					:  List[str]						=  sin(A      )
   _a					:  Tuple						=  cos(A      )
   _a					:  Union[str, Any]						=  _sin / (2 * q_factor)
   _a					:  str						=  1_0 ** (gain_db / 4_0)
   _a					:  Optional[Any]						=  (big_a + 1) - (big_a - 1) * _cos
   _a					:  List[str]						=  (big_a + 1) + (big_a - 1) * _cos
   _a					:  List[Any]						=  (big_a - 1) - (big_a + 1) * _cos
   _a					:  Dict						=  (big_a - 1) + (big_a + 1) * _cos
   _a					:  Tuple						=  2 * sqrt(A      ) * alpha

   _a					:  Any						=  big_a * (pmc + aaa)
   _a					:  Optional[int]						=  2 * big_a * mpc
   _a					:  Dict						=  big_a * (pmc - aaa)
   _a					:  List[str]						=  ppmc + aaa
   _a					:  int						=  -2 * pmpc
   _a					:  Tuple						=  ppmc - aaa

   _a					:  Tuple						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt







def    UpperCAmelCase_  (       A		,	A		,	A		,	A = 1 / sqrt(2      )		,	):
   '''simple docstring'''





   _a					:  Dict						=  tau * frequency / samplerate
   _a					:  Tuple						=  sin(A      )
   _a					:  Any						=  cos(A      )
   _a					:  int						=  _sin / (2 * q_factor)
   _a					:  str						=  1_0 ** (gain_db / 4_0)
   _a					:  List[Any]						=  (big_a + 1) - (big_a - 1) * _cos
   _a					:  Union[str, Any]						=  (big_a + 1) + (big_a - 1) * _cos
   _a					:  List[Any]						=  (big_a - 1) - (big_a + 1) * _cos
   _a					:  List[str]						=  (big_a - 1) + (big_a + 1) * _cos
   _a					:  Union[str, Any]						=  2 * sqrt(A      ) * alpha

   _a					:  Optional[Any]						=  big_a * (ppmc + aaa)
   _a					:  List[str]						=  -2 * big_a * pmpc
   _a					:  Any						=  big_a * (ppmc - aaa)
   _a					:  List[Any]						=  pmc + aaa
   _a					:  Tuple						=  2 * mpc
   _a					:  List[Any]						=  pmc - aaa

   _a					:  str						=  IIRFilter(2      )
   filt.set_coefficients([aa, aa, aa]		,	[ba, ba, ba]      )
   return filt


