
"""simple docstring"""

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import CLIPSegProcessor, ViTImageProcessor
@require_vision
class      _UpperCAmelCase							(		unittest.TestCase							):




      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					tempfile.mkdtemp()

          # fmt: off
          UpperCAmelCase									=					['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
          # fmt: on
          UpperCAmelCase									=					dict(zip(lowercase_   ,       range(len(lowercase_							)							)							)							)
          UpperCAmelCase									=					['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
          UpperCAmelCase									=					{'unk_token': '<unk>'}

          UpperCAmelCase									=					os.path.join(self.tmpdirname   ,       VOCAB_FILES_NAMES['vocab_file']							)
          UpperCAmelCase									=					os.path.join(self.tmpdirname   ,       VOCAB_FILES_NAMES['merges_file']							)
          with open(self.vocab_file   ,       'w'   ,       encoding='utf-8'							) as fp:
              fp.write(json.dumps(lowercase_							) + '\n'							)
          with open(self.merges_file   ,       'w'   ,       encoding='utf-8'							) as fp:
              fp.write('\n'.join(lowercase_							)							)

          UpperCAmelCase									=					{
              'do_resize': True,
              'size': 2_0,
              'do_center_crop': True,
              'crop_size': 1_8,
              'do_normalize': True,
              'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
              'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
          }
          UpperCAmelCase									=					os.path.join(self.tmpdirname   ,       lowercase_							)
          with open(self.image_processor_file   ,       'w'   ,       encoding='utf-8'							) as fp:
              json.dump(lowercase_   ,       lowercase_							)




      def     a_      (							self   ,       **lowercase_							)						->					str:
          return CLIPTokenizer.from_pretrained(self.tmpdirname   ,       **lowercase_							)




      def     a_      (							self   ,       **lowercase_							)						->					List[str]:
          return CLIPTokenizerFast.from_pretrained(self.tmpdirname   ,       **lowercase_							)




      def     a_      (							self   ,       **lowercase_							)						->					List[str]:
          return ViTImageProcessor.from_pretrained(self.tmpdirname   ,       **lowercase_							)




      def     a_      (							self							)						->					List[Any]:
          shutil.rmtree(self.tmpdirname							)




      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					[np.random.randint(2_5_5   ,       size=(3, 3_0, 4_0_0)   ,       dtype=np.uinta							)]

          UpperCAmelCase									=					[Image.fromarray(np.moveaxis(lowercase_   ,       0   ,       -1							)							) for x in image_inputs]

          return image_inputs




      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					self.get_tokenizer()
          UpperCAmelCase									=					self.get_rust_tokenizer()
          UpperCAmelCase									=					self.get_image_processor()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)
          processor_slow.save_pretrained(self.tmpdirname							)
          UpperCAmelCase									=					CLIPSegProcessor.from_pretrained(self.tmpdirname   ,       use_fast=lowercase_							)

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)
          processor_fast.save_pretrained(self.tmpdirname							)
          UpperCAmelCase									=					CLIPSegProcessor.from_pretrained(self.tmpdirname							)

          self.assertEqual(processor_slow.tokenizer.get_vocab()   ,       tokenizer_slow.get_vocab()							)
          self.assertEqual(processor_fast.tokenizer.get_vocab()   ,       tokenizer_fast.get_vocab()							)
          self.assertEqual(tokenizer_slow.get_vocab()   ,       tokenizer_fast.get_vocab()							)
          self.assertIsInstance(processor_slow.tokenizer   ,       lowercase_							)
          self.assertIsInstance(processor_fast.tokenizer   ,       lowercase_							)

          self.assertEqual(processor_slow.image_processor.to_json_string()   ,       image_processor.to_json_string()							)
          self.assertEqual(processor_fast.image_processor.to_json_string()   ,       image_processor.to_json_string()							)
          self.assertIsInstance(processor_slow.image_processor   ,       lowercase_							)
          self.assertIsInstance(processor_fast.image_processor   ,       lowercase_							)




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=self.get_tokenizer()   ,       image_processor=self.get_image_processor()							)
          processor.save_pretrained(self.tmpdirname							)

          UpperCAmelCase									=					self.get_tokenizer(bos_token='(BOS)'   ,       eos_token='(EOS)'							)
          UpperCAmelCase									=					self.get_image_processor(do_normalize=lowercase_   ,       padding_value=1.0							)

          UpperCAmelCase									=					CLIPSegProcessor.from_pretrained(
              self.tmpdirname   ,       bos_token='(BOS)'   ,       eos_token='(EOS)'   ,       do_normalize=lowercase_   ,       padding_value=1.0							)

          self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer_add_kwargs.get_vocab()							)
          self.assertIsInstance(processor.tokenizer   ,       lowercase_							)

          self.assertEqual(processor.image_processor.to_json_string()   ,       image_processor_add_kwargs.to_json_string()							)
          self.assertIsInstance(processor.image_processor   ,       lowercase_							)




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					self.get_image_processor()
          UpperCAmelCase									=					self.get_tokenizer()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)

          UpperCAmelCase									=					self.prepare_image_inputs()

          UpperCAmelCase									=					image_processor(lowercase_   ,       return_tensors='np'							)
          UpperCAmelCase									=					processor(images=lowercase_   ,       return_tensors='np'							)

          for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()   ,       input_processor[key].sum()   ,       delta=1E-2							)




      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					self.get_image_processor()
          UpperCAmelCase									=					self.get_tokenizer()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)

          UpperCAmelCase									=					'lower newer'

          UpperCAmelCase									=					processor(text=lowercase_							)

          UpperCAmelCase									=					tokenizer(lowercase_							)

          for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]							)




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					self.get_image_processor()
          UpperCAmelCase									=					self.get_tokenizer()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)

          UpperCAmelCase									=					'lower newer'
          UpperCAmelCase									=					self.prepare_image_inputs()

          UpperCAmelCase									=					processor(text=lowercase_   ,       images=lowercase_							)

          self.assertListEqual(list(inputs.keys()							)   ,       ['input_ids', 'attention_mask', 'pixel_values']							)

          # test if it raises when no input is passed
          with pytest.raises(lowercase_							):
              processor()




      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					self.get_image_processor()
          UpperCAmelCase									=					self.get_tokenizer()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)

          UpperCAmelCase									=					self.prepare_image_inputs()
          UpperCAmelCase									=					self.prepare_image_inputs()

          UpperCAmelCase									=					processor(images=lowercase_   ,       visual_prompt=lowercase_							)

          self.assertListEqual(list(inputs.keys()							)   ,       ['pixel_values', 'conditional_pixel_values']							)

          # test if it raises when no input is passed
          with pytest.raises(lowercase_							):
              processor()




      def     a_      (							self							)						->					int:
          UpperCAmelCase									=					self.get_image_processor()
          UpperCAmelCase									=					self.get_tokenizer()

          UpperCAmelCase									=					CLIPSegProcessor(tokenizer=lowercase_   ,       image_processor=lowercase_							)

          UpperCAmelCase									=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          UpperCAmelCase									=					processor.batch_decode(lowercase_							)
          UpperCAmelCase									=					tokenizer.batch_decode(lowercase_							)

          self.assertListEqual(lowercase_   ,       lowercase_							)





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



