
"""simple docstring"""

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_     ,			SCREAMING_SNAKE_CASE_							):




      @register_to_config
      def __init__(							self   ,       *,
          lowercase_ = 4   ,       lowercase_ = 7_6_8   ,       lowercase_   ,       lowercase_   ,       )						->					List[Any]:
          super().__init__()

          UpperCAmelCase									=					nn.Parameter(torch.zeros(lowercase_							)							)

          # parameters for additional clip time embeddings
          UpperCAmelCase									=					nn.Linear(lowercase_   ,       lowercase_							)
          UpperCAmelCase									=					nn.Linear(lowercase_   ,       lowercase_							)

          # parameters for encoder hidden states
          UpperCAmelCase									=					clip_extra_context_tokens
          UpperCAmelCase									=					nn.Linear(
              lowercase_   ,       self.clip_extra_context_tokens * cross_attention_dim							)
          UpperCAmelCase									=					nn.Linear(lowercase_   ,       lowercase_							)
          UpperCAmelCase									=					nn.LayerNorm(lowercase_							)




      def     a_      (							self   ,       *, lowercase_   ,       lowercase_   ,       lowercase_   ,       lowercase_							)						->					str:
          if do_classifier_free_guidance:
              # Add the classifier free guidance embeddings to the image embeddings
              UpperCAmelCase									=					image_embeddings.shape[0]
              UpperCAmelCase									=					self.learned_classifier_free_guidance_embeddings.unsqueeze(0							)
              UpperCAmelCase									=					classifier_free_guidance_embeddings.expand(
                  lowercase_   ,       -1							)
              UpperCAmelCase									=					torch.cat([classifier_free_guidance_embeddings, image_embeddings]   ,       dim=0							)

          # The image embeddings batch size and the text embeddings batch size are equal
          assert image_embeddings.shape[0] == prompt_embeds.shape[0]

          UpperCAmelCase									=					prompt_embeds.shape[0]

          # "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
          # adding CLIP embeddings to the existing timestep embedding, ...
          UpperCAmelCase									=					self.embedding_proj(lowercase_							)
          UpperCAmelCase									=					self.clip_image_embeddings_project_to_time_embeddings(lowercase_							)
          UpperCAmelCase									=					time_projected_image_embeddings + time_projected_prompt_embeds

          # ... and by projecting CLIP embeddings into four
          # extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
          UpperCAmelCase									=					self.clip_extra_context_tokens_proj(lowercase_							)
          UpperCAmelCase									=					clip_extra_context_tokens.reshape(lowercase_   ,       -1   ,       self.clip_extra_context_tokens							)
          UpperCAmelCase									=					clip_extra_context_tokens.permute(0   ,       2   ,       1							)

          UpperCAmelCase									=					self.encoder_hidden_states_proj(lowercase_							)
          UpperCAmelCase									=					self.text_encoder_hidden_states_norm(lowercase_							)
          UpperCAmelCase									=					torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]   ,       dim=1							)

          return text_encoder_hidden_states, additive_clip_time_embeddings





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



