






import argparse
import datetime





def    __lowerCAmelCase   (    __snake_case							):
     __lowerCAmelCase             =       {
         "0": "Sunday",
         "1": "Monday",
         "2": "Tuesday",
         "3": "Wednesday",
         "4": "Thursday",
         "5": "Friday",
         "6": "Saturday",
     }

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

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

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

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

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

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

     # Get year
     __lowerCAmelCase             =       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
     __lowerCAmelCase             =       datetime.date(int(__snake_case							)       ,			int(__snake_case							)       ,			int(__snake_case							)							)

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


if __name__ == "__main__":
 import doctest

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














import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class 				_UpperCamelCase      (a_      ):
      snake_case_	=				["""image_processor""", """tokenizer"""]
      snake_case_	=				"""FlavaImageProcessor"""
      snake_case_	=				("""BertTokenizer""", """BertTokenizerFast""")


      def __init__(						self       ,    __UpperCamelCase=None       ,    __UpperCamelCase=None       ,    **__UpperCamelCase						)->						Tuple:
           __lowerCAmelCase             =       None
           if "feature_extractor" in kwargs:
                warnings.warn(
                    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
                    " instead."       ,    __UpperCamelCase       ,    )
                __lowerCAmelCase             =       kwargs.pop("feature_extractor"						)

           __lowerCAmelCase             =       image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
                raise ValueError("You need to specify an `image_processor`."						)
           if tokenizer is None:
                raise ValueError("You need to specify a `tokenizer`."						)

           super().__init__(__UpperCamelCase       ,    __UpperCamelCase						)
           __lowerCAmelCase             =       self.image_processor


      def __call__(						self       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = True       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = None       ,    __UpperCamelCase = 0       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = True       ,    __UpperCamelCase = None       ,    **__UpperCamelCase       ,    )->						int:

           if text is None and images is None:
                raise ValueError("You have to specify either text or images. Both cannot be none."						)

           if text is not None:
                __lowerCAmelCase             =       self.tokenizer(
                    text=__UpperCamelCase       ,    add_special_tokens=__UpperCamelCase       ,    padding=__UpperCamelCase       ,    truncation=__UpperCamelCase       ,    max_length=__UpperCamelCase       ,    stride=__UpperCamelCase       ,    pad_to_multiple_of=__UpperCamelCase       ,    return_token_type_ids=__UpperCamelCase       ,    return_attention_mask=__UpperCamelCase       ,    return_overflowing_tokens=__UpperCamelCase       ,    return_special_tokens_mask=__UpperCamelCase       ,    return_offsets_mapping=__UpperCamelCase       ,    return_length=__UpperCamelCase       ,    verbose=__UpperCamelCase       ,    return_tensors=__UpperCamelCase       ,    **__UpperCamelCase       ,    )
           if images is not None:
                __lowerCAmelCase             =       self.image_processor(
                    __UpperCamelCase       ,    return_image_mask=__UpperCamelCase       ,    return_codebook_pixels=__UpperCamelCase       ,    return_tensors=__UpperCamelCase       ,    **__UpperCamelCase       ,    )

           if text is not None and images is not None:
                encoding.update(__UpperCamelCase						)
                return encoding
           elif text is not None:
                return encoding
           else:
                return BatchEncoding(data=dict(**__UpperCamelCase						)       ,    tensor_type=__UpperCamelCase						)


      def 			__UpperCAmelCase		(						self       ,    *__UpperCamelCase       ,    **__UpperCamelCase						)->						int:
           return self.tokenizer.batch_decode(*__UpperCamelCase       ,    **__UpperCamelCase						)


      def 			__UpperCAmelCase		(						self       ,    *__UpperCamelCase       ,    **__UpperCamelCase						)->						Optional[int]:
           return self.tokenizer.decode(*__UpperCamelCase       ,    **__UpperCamelCase						)


      @property
      def 			__UpperCAmelCase		(						self						)->						Any:
           __lowerCAmelCase             =       self.tokenizer.model_input_names
           __lowerCAmelCase             =       self.image_processor.model_input_names
           return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names						)						)


      @property
      def 			__UpperCAmelCase		(						self						)->						Dict:
           warnings.warn(
               "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."       ,    __UpperCamelCase       ,    )
           return self.image_processor_class


      @property
      def 			__UpperCAmelCase		(						self						)->						Union[str, Any]:
           warnings.warn(
               "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."       ,    __UpperCamelCase       ,    )
           return self.image_processor






