


'''simple docstring'''






from __future__ import annotations

from math import pi, sqrt






def 		_A			(lowerCAmelCase__					:float			,  lowerCAmelCase__					:float						)				->					tuple:




     '''simple docstring'''



     if inductance <= 0:
          raise ValueError('Inductance cannot be 0 or negative'						)

     elif capacitance <= 0:
          raise ValueError('Capacitance cannot be 0 or negative'						)

     else:
          return (
              "Resonant frequency",
              float(1 / (2 * pi * (sqrt(inductance * capacitance						)))						),
          )


if __name__ == "__main__":
 import doctest

 doctest.testmod()





'''simple docstring'''






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 AutoImageProcessor, ViTImageProcessor
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_image_processing import CustomImageProcessor  # noqa E402


a_   :      Tuple				    =      get_tests_dir("fixtures")




class 	a       (       unittest.TestCase    ):
 def 							__UpperCAmelCase						(	self  )   ->							str:
      # A mock response for an HTTP head request to emulate server down
      _a      =							mock.Mock()
      _a      =							5_00
      _a      =							{}
      _a      =							HTTPError
      _a      =							{}

      # Download this model to make sure it's in the cache.
      _a      =							ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
      # 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:
           _a      =							ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'  )
           # This check we did call the fake head request
           mock_head.assert_called()
 def 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      # This test is for deprecated behavior and can be removed in v5
      _a      =							ViTImageProcessor.from_pretrained(
          'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'  )




 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      with self.assertRaises(__magic_name__  ):
           # config is in subfolder, the following should not work without specifying the subfolder
           _a      =							AutoImageProcessor.from_pretrained('hf-internal-testing/stable-diffusion-all-variants'  )

      _a      =							AutoImageProcessor.from_pretrained(
          'hf-internal-testing/stable-diffusion-all-variants' ,			subfolder='feature_extractor'  )

      self.assertIsNotNone(__magic_name__  )





@is_staging_test
class 	a       (       unittest.TestCase    ):
 @classmethod
 def 							__UpperCAmelCase						(	cls  )   ->							Dict:
      _a      =							TOKEN
      HfFolder.save_token(__magic_name__  )
 @classmethod
 def 							__UpperCAmelCase						(	cls  )   ->							List[Any]:
      try:
           delete_repo(token=cls._token ,			repo_id='test-image-processor'  )
      except HTTPError:
           pass

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

      try:
           delete_repo(token=cls._token ,			repo_id='test-dynamic-image-processor'  )
      except HTTPError:
           pass
 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							ViTImageProcessor.from_pretrained(__magic_name__  )
      image_processor.push_to_hub('test-image-processor' ,			use_auth_token=self._token  )

      _a      =							ViTImageProcessor.from_pretrained(f'{USER}/test-image-processor'  )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(__magic_name__ ,			getattr(__magic_name__ ,			__magic_name__  )  )

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

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

      _a      =							ViTImageProcessor.from_pretrained(f'{USER}/test-image-processor'  )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(__magic_name__ ,			getattr(__magic_name__ ,			__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _a      =							ViTImageProcessor.from_pretrained(__magic_name__  )
      image_processor.push_to_hub('valid_org/test-image-processor' ,			use_auth_token=self._token  )

      _a      =							ViTImageProcessor.from_pretrained('valid_org/test-image-processor'  )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(__magic_name__ ,			getattr(__magic_name__ ,			__magic_name__  )  )

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

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

      _a      =							ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'  )
      for k, v in image_processor.__dict__.items():
           self.assertEqual(__magic_name__ ,			getattr(__magic_name__ ,			__magic_name__  )  )




 def 							__UpperCAmelCase						(	self  )   ->							Any:
      CustomImageProcessor.register_for_auto_class()
      _a      =							CustomImageProcessor.from_pretrained(__magic_name__  )

      image_processor.push_to_hub('test-dynamic-image-processor' ,			use_auth_token=self._token  )

      # This has added the proper auto_map field to the config
      self.assertDictEqual(
          image_processor.auto_map ,			{'AutoImageProcessor': 'custom_image_processing.CustomImageProcessor'} ,			)

      _a      =							AutoImageProcessor.from_pretrained(
          f'{USER}/test-dynamic-image-processor' ,			trust_remote_code=__magic_name__  )
      # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
      self.assertEqual(new_image_processor.__class__.__name__ ,			'CustomImageProcessor'  )

