





import argparse
import datetime



def A_     (		A__    )  ->		Optional[int]:
							a__						:     Union[str, Any]			=    {
							    '0': 'Sunday',
							    '1': 'Monday',
							    '2': 'Tuesday',
							    '3': 'Wednesday',
							    '4': 'Thursday',
							    '5': 'Friday',
							    '6': 'Saturday',
							}

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

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

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

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

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

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

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

							# Get datetime obj for validation
							a__						:     int			=    datetime.date(int(A__    )		,				int(A__    )		,				int(A__    )    )

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


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				lowercase				:	int      						=  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				:	int      						=  parser.parse_args()
				zeller(args.date_input)









import unittest

import numpy as np

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
    from transformers.models.bert.modeling_flax_bert import (
        FlaxBertForMaskedLM,
        FlaxBertForMultipleChoice,
        FlaxBertForNextSentencePrediction,
        FlaxBertForPreTraining,
        FlaxBertForQuestionAnswering,
        FlaxBertForSequenceClassification,
        FlaxBertForTokenClassification,
        FlaxBertModel,
    )





class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   def __init__( self ,  lowercase ,  lowercase=13 ,  lowercase=7 ,  lowercase=True ,  lowercase=True ,  lowercase=True ,  lowercase=True ,  lowercase=99 ,  lowercase=32 ,  lowercase=5 ,  lowercase=4 ,  lowercase=37 ,  lowercase="gelu" ,  lowercase=0.1 ,  lowercase=0.1 ,  lowercase=512 ,  lowercase=16 ,  lowercase=2 ,  lowercase=0.02 ,  lowercase=4 ,  )      ->						Tuple:







          '''simple docstring'''

          a__						:     str			=    parent
          a__						:     Optional[Any]			=    batch_size
          a__						:     str			=    seq_length
          a__						:     int			=    is_training
          a__						:     str			=    use_attention_mask
          a__						:     List[str]			=    use_token_type_ids
          a__						:     Optional[Any]			=    use_labels
          a__						:     List[Any]			=    vocab_size
          a__						:     Tuple			=    hidden_size
          a__						:     Dict			=    num_hidden_layers
          a__						:     List[str]			=    num_attention_heads
          a__						:     int			=    intermediate_size
          a__						:     Any			=    hidden_act
          a__						:     Optional[int]			=    hidden_dropout_prob
          a__						:     Tuple			=    attention_probs_dropout_prob
          a__						:     Tuple			=    max_position_embeddings
          a__						:     Optional[int]			=    type_vocab_size
          a__						:     List[Any]			=    type_sequence_label_size
          a__						:     Union[str, Any]			=    initializer_range
          a__						:     str			=    num_choices

   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     str			=    ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size)

          a__						:     Dict			=    None
          if self.use_attention_mask:
                 a__						:     Optional[int]			=    random_attention_mask([self.batch_size, self.seq_length])

          a__						:     Dict			=    None
          if self.use_token_type_ids:
                 a__						:     int			=    ids_tensor([self.batch_size, self.seq_length] ,  self.type_vocab_size)

          a__						:     Dict			=    BertConfig(
              vocab_size=self.vocab_size ,  hidden_size=self.hidden_size ,  num_hidden_layers=self.num_hidden_layers ,  num_attention_heads=self.num_attention_heads ,  intermediate_size=self.intermediate_size ,  hidden_act=self.hidden_act ,  hidden_dropout_prob=self.hidden_dropout_prob ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob ,  max_position_embeddings=self.max_position_embeddings ,  type_vocab_size=self.type_vocab_size ,  is_decoder=lowercase ,  initializer_range=self.initializer_range ,  )

          return config, input_ids, token_type_ids, attention_mask

   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     Tuple			=    self.prepare_config_and_inputs()
          a__			,							a__			,							a__			,							a__						:     Optional[int]			=    config_and_inputs
          a__						:     str			=    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
          return config, inputs_dict

   def 							__lowercase		( self)      ->						Optional[int]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    self.prepare_config_and_inputs()
          a__			,							a__			,							a__			,							a__						:     int			=    config_and_inputs

          a__						:     str			=    True
          a__						:     Any			=    floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
          a__						:     List[str]			=    ids_tensor([self.batch_size, self.seq_length] ,  vocab_size=2)

          return (
              config,
              input_ids,
              attention_mask,
              encoder_hidden_states,
              encoder_attention_mask,
          )





@require_flax
class 			A__   (							__UpperCAmelCase			,  unittest.TestCase     ):




   """simple docstring"""



   __A       :    Optional[Any]	  =  True

   __A       :    Tuple	  =  (
       (
           FlaxBertModel,
           FlaxBertForPreTraining,
           FlaxBertForMaskedLM,
           FlaxBertForMultipleChoice,
           FlaxBertForQuestionAnswering,
           FlaxBertForNextSentencePrediction,
           FlaxBertForSequenceClassification,
           FlaxBertForTokenClassification,
           FlaxBertForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )

   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     Optional[Any]			=    FlaxBertModelTester(self)

   @slow
   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    FlaxBertModel.from_pretrained('bert-base-cased')
          a__						:     Optional[Any]			=    model(np.ones((1, 1)))
          self.assertIsNotNone(lowercase)


