




'''simple docstring'''



import argparse
import datetime
def 			SCREAMING_SNAKE_CASE_			(							__A    :			str  )			->			str:
   _SCREAMING_SNAKE_CASE	=				{
       "0": "Sunday",
       "1": "Monday",
       "2": "Tuesday",
       "3": "Wednesday",
       "4": "Thursday",
       "5": "Friday",
       "6": "Saturday",
   }

   _SCREAMING_SNAKE_CASE	=				{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
   _SCREAMING_SNAKE_CASE	=				int(date_input[0] + date_input[1]  )
   # Validate
   if not 0 < m < 13:
      raise ValueError("Month must be between 1 - 12"  )

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

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

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

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

   # Get datetime obj for validation
   _SCREAMING_SNAKE_CASE	=				datetime.date(int(__A  )	,					int(__A  )	,					int(__A  )  )

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


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 lowerCamelCase_			=						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)'
 )
 lowerCamelCase_			=						parser.parse_args()
 zeller(args.date_input)







'''simple docstring'''



from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
 from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


lowerCamelCase_			=						logging.get_logger(__name__)

lowerCamelCase_			=						{
    'microsoft/deberta-v2-xlarge': 'https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xxlarge': 'https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json'
    ),
    'microsoft/deberta-v2-xxlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json'
    ),
}







class 		lowercase_   (			A       ):


   """simple docstring"""

   lowerCamelCase_      =						'''deberta-v2'''



   def __init__(   self :     str  ,				__lowerCamelCase :     Union[str, Any]=1_2_8_1_0_0  ,				__lowerCamelCase :     Optional[int]=1_5_3_6  ,				__lowerCamelCase :     Optional[int]=2_4  ,				__lowerCamelCase :     Optional[int]=2_4  ,				__lowerCamelCase :     Tuple=6_1_4_4  ,				__lowerCamelCase :     List[str]="gelu"  ,				__lowerCamelCase :     int=0.1  ,				__lowerCamelCase :     Optional[Any]=0.1  ,				__lowerCamelCase :     Union[str, Any]=5_1_2  ,				__lowerCamelCase :     Optional[Any]=0  ,				__lowerCamelCase :     str=0.0_2  ,				__lowerCamelCase :     int=1e-7  ,				__lowerCamelCase :     Any=False  ,				__lowerCamelCase :     Any=-1  ,				__lowerCamelCase :     Tuple=0  ,				__lowerCamelCase :     str=True  ,				__lowerCamelCase :     List[Any]=None  ,				__lowerCamelCase :     Optional[int]=0  ,				__lowerCamelCase :     Any="gelu"  ,				**__lowerCamelCase :     Union[str, Any]  ,				):

      """simple docstring"""
      super().__init__(**__lowerCamelCase   )

      _SCREAMING_SNAKE_CASE	=				hidden_size
      _SCREAMING_SNAKE_CASE	=				num_hidden_layers
      _SCREAMING_SNAKE_CASE	=				num_attention_heads
      _SCREAMING_SNAKE_CASE	=				intermediate_size
      _SCREAMING_SNAKE_CASE	=				hidden_act
      _SCREAMING_SNAKE_CASE	=				hidden_dropout_prob
      _SCREAMING_SNAKE_CASE	=				attention_probs_dropout_prob
      _SCREAMING_SNAKE_CASE	=				max_position_embeddings
      _SCREAMING_SNAKE_CASE	=				type_vocab_size
      _SCREAMING_SNAKE_CASE	=				initializer_range
      _SCREAMING_SNAKE_CASE	=				relative_attention
      _SCREAMING_SNAKE_CASE	=				max_relative_positions
      _SCREAMING_SNAKE_CASE	=				pad_token_id
      _SCREAMING_SNAKE_CASE	=				position_biased_input

      # Backwards compatibility
      if type(__lowerCamelCase   ) == str:
         _SCREAMING_SNAKE_CASE	=				[x.strip() for x in pos_att_type.lower().split("|"   )]

      _SCREAMING_SNAKE_CASE	=				pos_att_type
      _SCREAMING_SNAKE_CASE	=				vocab_size
      _SCREAMING_SNAKE_CASE	=				layer_norm_eps

      _SCREAMING_SNAKE_CASE	=				kwargs.get("pooler_hidden_size"  ,				__lowerCamelCase   )
      _SCREAMING_SNAKE_CASE	=				pooler_dropout
      _SCREAMING_SNAKE_CASE	=				pooler_hidden_act







class 		lowercase_   (			A       ):


   """simple docstring"""

   @property
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      if self.task == "multiple-choice":
         _SCREAMING_SNAKE_CASE	=				{0: "batch", 1: "choice", 2: "sequence"}
      else:
         _SCREAMING_SNAKE_CASE	=				{0: "batch", 1: "sequence"}
      if self._config.type_vocab_size > 0:
         return OrderedDict(
             [("input_ids", dynamic_axis), ("attention_mask", dynamic_axis), ("token_type_ids", dynamic_axis)]   )
      else:
         return OrderedDict([("input_ids", dynamic_axis), ("attention_mask", dynamic_axis)]   )



   @property
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      return 1_2



   def 							lowerCAmelCase_      (   self :     List[str]  ,				__lowerCamelCase :     Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     int = -1  ,				__lowerCamelCase :     bool = False  ,				__lowerCamelCase :     Optional["TensorType"] = None  ,				__lowerCamelCase :     int = 3  ,				__lowerCamelCase :     int = 4_0  ,				__lowerCamelCase :     int = 4_0  ,				__lowerCamelCase :     "PreTrainedTokenizerBase" = None  ,				):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				super().generate_dummy_inputs(preprocessor=__lowerCamelCase  ,				framework=__lowerCamelCase   )
      if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
         del dummy_inputs["token_type_ids"]
      return dummy_inputs

