
"""simple docstring"""
import argparse
import datetime





def    _lowerCAmelCase    (     lowerCamelCase__							:							str				)  ->    str:
  _SCREAMING_SNAKE_CASE   :				List[str]							    = {
      "0": "Sunday",
      "1": "Monday",
      "2": "Tuesday",
      "3": "Wednesday",
      "4": "Thursday",
      "5": "Friday",
      "6": "Saturday",
  }

  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

  # Validate
  if not 0 < len(lowerCamelCase__				) < 1_1:
    raise ValueError("Must be 10 characters long"				)

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

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

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

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

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

  # Get datetime obj for validation
  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = datetime.date(int(lowerCamelCase__				),						int(lowerCamelCase__				),						int(lowerCamelCase__				)				)

  # Start math
  if m <= 2:
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = y - 1
    _SCREAMING_SNAKE_CASE   :				str							    = m + 1_2
  # maths var
  _SCREAMING_SNAKE_CASE   :				int							    = int(str(lowerCamelCase__				)[:2]				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(str(lowerCamelCase__				)[2:]				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(2.6 * m - 5.39				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(c / 4				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(k / 4				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(d + k				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(t + u + v + x				)
  _SCREAMING_SNAKE_CASE   :				int							    = int(z - (2 * c)				)
  _SCREAMING_SNAKE_CASE   :				int							    = 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
  _SCREAMING_SNAKE_CASE   :				str							    = f'''Your date {date_input}, is a {days[str(lowerCamelCase__				)]}!'''
  return response


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      lowercase_       :						List[Any]     					=	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)'''
      )
      lowercase_       :						Tuple     					=	parser.parse_args()
      zeller(args.date_input)





"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
      import numpy as np
      import tensorflow as tf

      from transformers import TFCamembertModel
@require_tf
@require_sentencepiece
@require_tokenizers
class 			UpperCamelCase      (							unittest.TestCase  ):
     @slow
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				str							    = TFCamembertModel.from_pretrained("jplu/tf-camembert-base"				)

       _SCREAMING_SNAKE_CASE   :				str							    = tf.convert_to_tensor(
           [[5, 121, 11, 660, 16, 730, 25543, 110, 83, 6]]  ,     dtype=tf.intaa  ,     )  # J'aime le camembert !"

       _SCREAMING_SNAKE_CASE   :				str							    = model(snake_case__				)["last_hidden_state"]
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = tf.TensorShape((1, 10, 768)				)
       self.assertEqual(output.shape  ,     snake_case__				)
       # compare the actual values for a slice.
       _SCREAMING_SNAKE_CASE   :				int							    = tf.convert_to_tensor(
           [[[-0.0_254, 0.0_235, 0.1_027], [0.0_606, -0.1_811, -0.0_418], [-0.1_561, -0.1_127, 0.2_687]]]  ,     dtype=tf.floataa  ,     )
       # camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
       # camembert.eval()
       # expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

       self.assertTrue(np.allclose(output[:, :3, :3].numpy()  ,     expected_slice.numpy()  ,     atol=1E-4				)				)



