
"""simple docstring"""

import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_							):




      @require_torch
      def     a_      (							self							)						->					str:
          # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
          # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
          # while running an external program

          # python one-liner segments

          # this must be loaded before socket.socket is monkey-patched
          UpperCAmelCase									=					'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

          UpperCAmelCase									=					'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

          UpperCAmelCase									=					'\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

          # Force fetching the files so that we can use the cache
          UpperCAmelCase									=					'hf-internal-testing/tiny-random-bert'
          BertConfig.from_pretrained(lowercase_							)
          BertModel.from_pretrained(lowercase_							)
          BertTokenizer.from_pretrained(lowercase_							)
          pipeline(task='fill-mask'   ,       model=lowercase_							)

          # baseline - just load from_pretrained with normal network
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, run, mock]							)]

          # should succeed
          UpperCAmelCase									=					self.get_env()
          # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
          UpperCAmelCase									=					'1'
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)




      @require_torch
      def     a_      (							self							)						->					str:
          # python one-liner segments
          # this must be loaded before socket.socket is monkey-patched
          UpperCAmelCase									=					'\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

          UpperCAmelCase									=					'\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

          UpperCAmelCase									=					'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

          # Force fetching the files so that we can use the cache
          UpperCAmelCase									=					'hf-internal-testing/tiny-random-bert'
          BertConfig.from_pretrained(lowercase_							)
          BertModel.from_pretrained(lowercase_							)
          BertTokenizer.from_pretrained(lowercase_							)
          pipeline(task='fill-mask'   ,       model=lowercase_							)

          # baseline - just load from_pretrained with normal network
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, run, mock]							)]

          # should succeed
          UpperCAmelCase									=					self.get_env()
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)




      @require_torch
      def     a_      (							self							)						->					int:
          # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
          # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
          # while running an external program

          # python one-liner segments

          # this must be loaded before socket.socket is monkey-patched
          UpperCAmelCase									=					'\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

          UpperCAmelCase									=					'\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

          UpperCAmelCase									=					'\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

          # baseline - just load from_pretrained with normal network
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, run]							)]

          # should succeed
          UpperCAmelCase									=					self.get_env()
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)

          # next emulate no network
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, mock, run]							)]

          # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
          # env["TRANSFORMERS_OFFLINE"] = "0"
          # result = subprocess.run(cmd, env=env, check=False, capture_output=True)
          # self.assertEqual(result.returncode, 1, result.stderr)

          # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
          UpperCAmelCase									=					'1'
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)




      @require_torch
      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					'\nfrom transformers import pipeline\n        '
          UpperCAmelCase									=					'\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

          UpperCAmelCase									=					'\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
          UpperCAmelCase									=					self.get_env()
          UpperCAmelCase									=					'1'
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, mock, run]							)]
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       1   ,       result.stderr							)
          self.assertIn(
              'You cannot infer task automatically within `pipeline` when using offline mode'   ,       result.stderr.decode().replace('\n'   ,       ''							)   ,       )




      @require_torch
      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					'\nfrom transformers import AutoModel\n        '
          UpperCAmelCase									=					'\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

          # baseline - just load from_pretrained with normal network
          UpperCAmelCase									=					[sys.executable, '-c', '\n'.join([load, run]							)]

          # should succeed
          UpperCAmelCase									=					self.get_env()
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)

          # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
          UpperCAmelCase									=					'1'
          UpperCAmelCase									=					subprocess.run(lowercase_   ,       env=lowercase_   ,       check=lowercase_   ,       capture_output=lowercase_							)
          self.assertEqual(result.returncode   ,       0   ,       result.stderr							)
          self.assertIn('success'   ,       result.stdout.decode()							)





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



