




from string import ascii_uppercase




def    lowerCamelCase__			(		A__			:   Union[str, Any]    ,     A__			:   Union[str, Any]    ,     A__			:   Optional[Any] = False    ,     A__			:   Dict = ascii_uppercase      ):





       '''simple docstring'''



       __lowerCamelCase  =		keyword.upper()
       __lowerCamelCase  =		plaintext.upper()
       __lowerCamelCase  =		set(__snake_case      )

       # create a list of unique characters in the keyword - their order matters
       # it determines how we will map plaintext characters to the ciphertext
       __lowerCamelCase  =		[]
       for char in keyword:
              if char in alphabet_set and char not in unique_chars:
                     unique_chars.append(__snake_case      )
    # the number of those unique characters will determine the number of rows
       __lowerCamelCase  =		len(__snake_case      )

       # create a shifted version of the alphabet
       __lowerCamelCase  =		unique_chars + [
           char for char in alphabet if char not in unique_chars
       ]

       # create a modified alphabet by splitting the shifted alphabet into rows
       __lowerCamelCase  =		[
           shifted_alphabet[k : k + num_unique_chars_in_keyword]
           for k in range(0    ,     26    ,     __snake_case      )
       ]

       # map the alphabet characters to the modified alphabet characters
       # going 'vertically' through the modified alphabet - consider columns first
       __lowerCamelCase  =		{}
       __lowerCamelCase  =		0
       for column in range(__snake_case      ):
              for row in modified_alphabet:
                     # if current row (the last one) is too short, break out of loop
                     if len(__snake_case      ) <= column:
                            break

                     # map current letter to letter in modified alphabet
                     __lowerCamelCase  =		row[column]
                     letter_index += 1

       if verbose:
              print(__snake_case      )
       # create the encrypted text by mapping the plaintext to the modified alphabet
       return "".join(mapping[char] if char in mapping else char for char in plaintext      )


if __name__ == "__main__":
       # example use
       print(mixed_keyword('college', 'UNIVERSITY'))






from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase								=      logging.get_logger(__name__)

__lowerCamelCase								=      {
    '''MCG-NJU/videomae-base''': '''https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json''',
}


class 	snake_case_			(lowercase__	):




       """simple docstring"""






       _lowerCamelCase           =					"""videomae"""



       def __init__(  self  ,lowercase=224  ,lowercase=16  ,lowercase=3  ,lowercase=16  ,lowercase=2  ,lowercase=768  ,lowercase=12  ,lowercase=12  ,lowercase=3072  ,lowercase="gelu"  ,lowercase=0.0  ,lowercase=0.0  ,lowercase=0.02  ,lowercase=1E-12  ,lowercase=True  ,lowercase=True  ,lowercase=6  ,lowercase=384  ,lowercase=4  ,lowercase=1536  ,lowercase=True  ,**lowercase  ,):

             """simple docstring"""





             super().__init__(**lowercase)

             UpperCAmelCase_	:						Optional[int]					   =		image_size
             UpperCAmelCase_	:						Optional[Any]					   =		patch_size
             UpperCAmelCase_	:						Tuple					   =		num_channels
             UpperCAmelCase_	:						Optional[int]					   =		num_frames
             UpperCAmelCase_	:						str					   =		tubelet_size

             UpperCAmelCase_	:						Any					   =		hidden_size
             UpperCAmelCase_	:						List[str]					   =		num_hidden_layers
             UpperCAmelCase_	:						List[str]					   =		num_attention_heads
             UpperCAmelCase_	:						Union[str, Any]					   =		intermediate_size
             UpperCAmelCase_	:						List[str]					   =		hidden_act
             UpperCAmelCase_	:						Tuple					   =		hidden_dropout_prob
             UpperCAmelCase_	:						Optional[Any]					   =		attention_probs_dropout_prob
             UpperCAmelCase_	:						Optional[Any]					   =		initializer_range
             UpperCAmelCase_	:						Dict					   =		layer_norm_eps
             UpperCAmelCase_	:						Tuple					   =		qkv_bias
             UpperCAmelCase_	:						int					   =		use_mean_pooling

             UpperCAmelCase_	:						List[Any]					   =		decoder_num_attention_heads
             UpperCAmelCase_	:						Optional[int]					   =		decoder_hidden_size
             UpperCAmelCase_	:						Any					   =		decoder_num_hidden_layers
             UpperCAmelCase_	:						Dict					   =		decoder_intermediate_size
             UpperCAmelCase_	:						str					   =		norm_pix_loss
