
"""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 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


SCREAMING_SNAKE_CASE_    					=						get_tests_dir('''fixtures''')
class      _UpperCAmelCase							(		unittest.TestCase							):




      def     a_      (							self							)						->					List[Any]:
          # A mock response for an HTTP head request to emulate server down
          UpperCAmelCase									=					mock.Mock()
          UpperCAmelCase									=					5_0_0
          UpperCAmelCase									=					{}
          UpperCAmelCase									=					HTTPError
          UpperCAmelCase									=					{}

          # Download this model to make sure it's in the cache.
          UpperCAmelCase									=					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=lowercase__							) as mock_head:
              UpperCAmelCase									=					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							)						->					List[Any]:
          # This test is for deprecated behavior and can be removed in v5
          UpperCAmelCase									=					WavaVecaFeatureExtractor.from_pretrained(
              'https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'							)

@is_staging_test
class      _UpperCAmelCase							(		unittest.TestCase							):




      @classmethod
      def     a_      (							cls							)						->					str:
          UpperCAmelCase									=					TOKEN
          HfFolder.save_token(lowercase__							)




      @classmethod
      def     a_      (							cls							)						->					str:
          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							)						->					Dict:
          UpperCAmelCase									=					WavaVecaFeatureExtractor.from_pretrained(lowercase__							)
          feature_extractor.push_to_hub('test-feature-extractor'   ,       use_auth_token=self._token							)

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

          # 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(
                  lowercase__   ,       repo_id='test-feature-extractor'   ,       push_to_hub=lowercase__   ,       use_auth_token=self._token							)

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




      def     a_      (							self							)						->					Dict:
          UpperCAmelCase									=					WavaVecaFeatureExtractor.from_pretrained(lowercase__							)
          feature_extractor.push_to_hub('valid_org/test-feature-extractor'   ,       use_auth_token=self._token							)

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

          # 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(
                  lowercase__   ,       repo_id='valid_org/test-feature-extractor-org'   ,       push_to_hub=lowercase__   ,       use_auth_token=self._token							)

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




      def     a_      (							self							)						->					Optional[int]:
          CustomFeatureExtractor.register_for_auto_class()
          UpperCAmelCase									=					CustomFeatureExtractor.from_pretrained(lowercase__							)

          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'}   ,       )

          UpperCAmelCase									=					AutoFeatureExtractor.from_pretrained(
              F"{USER}/test-dynamic-feature-extractor"   ,       trust_remote_code=lowercase__							)
          # 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'							)





"""simple docstring"""

import argparse
import datetime




def     lowercase__						(					lowerCAmelCase				:					str ) ->      str:






    """simple docstring"""




    UpperCAmelCase									=					{
        '0': 'Sunday',
        '1': 'Monday',
        '2': 'Tuesday',
        '3': 'Wednesday',
        '4': 'Thursday',
        '5': 'Friday',
        '6': 'Saturday',
    }

    UpperCAmelCase									=					{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

    # Validate
    if not 0 < len(lowerCAmelCase ) < 11:
        raise ValueError('Must be 10 characters long' )

    # Get month
    UpperCAmelCase									=					int(date_input[0] + date_input[1] )
    # Validate
    if not 0 < m < 13:
        raise ValueError('Month must be between 1 - 12' )

    UpperCAmelCase									=					date_input[2]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\'' )

    # Get day
    UpperCAmelCase									=					int(date_input[3] + date_input[4] )
    # Validate
    if not 0 < d < 32:
        raise ValueError('Date must be between 1 - 31' )

    # Get second separator
    UpperCAmelCase									=					date_input[5]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\'' )

    # Get year
    UpperCAmelCase									=					int(date_input[6] + date_input[7] + date_input[8] + date_input[9] )
    # Arbitrary year range
    if not 45 < y < 8_500:
        raise ValueError(
            'Year out of range. There has to be some sort of limit...right?' )

    # Get datetime obj for validation
    UpperCAmelCase									=					datetime.date(int(lowerCAmelCase ) ,				int(lowerCAmelCase ) ,				int(lowerCAmelCase ) )

    # Start math
    if m <= 2:
        UpperCAmelCase									=					y - 1
        UpperCAmelCase									=					m + 12
    # maths var
    UpperCAmelCase									=					int(str(lowerCAmelCase )[:2] )
    UpperCAmelCase									=					int(str(lowerCAmelCase )[2:] )
    UpperCAmelCase									=					int(2.6 * m - 5.39 )
    UpperCAmelCase									=					int(c / 4 )
    UpperCAmelCase									=					int(k / 4 )
    UpperCAmelCase									=					int(d + k )
    UpperCAmelCase									=					int(t + u + v + x )
    UpperCAmelCase									=					int(z - (2 * c) )
    UpperCAmelCase									=					round(w % 7 )
    # End math

    # Validate math
    if f != convert_datetime_days[dt_ck.weekday()]:
        raise AssertionError('The date was evaluated incorrectly. Contact developer.' )

    # Response
    UpperCAmelCase									=					F"Your date {date_input}, is a {days[str(lowerCAmelCase )]}!"
    return response


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   SCREAMING_SNAKE_CASE_    					=						argparse.ArgumentParser(
       description=(
           '''Find out what day of the week nearly any date is or was. Enter '''
           '''date as a string in the mm-dd-yyyy or mm/dd/yyyy format'''
       )
   )
   parser.add_argument(
       '''date_input''', type=str, help='''Date as a string (mm-dd-yyyy or mm/dd/yyyy)'''
   )
   SCREAMING_SNAKE_CASE_    					=						parser.parse_args()
   zeller(args.date_input)



