code: 
  
  
  
  
  
  import json
  import os
  from collections.abc import Mapping
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  import torch
  
  from .imports import is_safetensors_available
  def   _A (	SCREAMING_SNAKE_CASE  :     Optional[Any] , SCREAMING_SNAKE_CASE  :     Union[str, Any] , SCREAMING_SNAKE_CASE  :     List[str] , SCREAMING_SNAKE_CASE  :     List[str]=None		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      List[Any]            =None
    # Check the string instead of the dtype to be compatible with versions of PyTorch that don't have bfloat16.
    if str(weight.dtype		) == "torch.bfloat16":
      # Need to reinterpret the underlined data as int16 since NumPy does not handle bfloat16s.
      a__			:      List[Any]            =weight.view(torch.intaa		)
      a__			:      Optional[Any]            ="bfloat16"
    a__			:      str            =weight.cpu().numpy()
    a__			:      str            =os.path.join(SCREAMING_SNAKE_CASE , f'''{weight_name}.dat'''		)
    if index is not None:
      if dtype is None:
        a__			:      Any            =str(array.dtype		)
      a__			:      Union[str, Any]            ={"dtype": dtype, "shape": list(array.shape		)}
    if array.ndim == 0:
      a__			:      int            =array[None]
    a__			:      List[Any]            =np.memmap(SCREAMING_SNAKE_CASE , dtype=array.dtype , mode="w+" , shape=array.shape		)
    a__			:      Tuple            =array[:]
    file_array.flush()
    return index
  def   _A (	SCREAMING_SNAKE_CASE  :     List[str] , SCREAMING_SNAKE_CASE  :     List[str]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Dict            =tuple(weight_info["shape"]		)
    if shape == ():
      # NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
      a__			:      str            =(1,)
  
    a__			:      Union[str, Any]            =weight_info["dtype"]
    if dtype == "bfloat16":
      # NumPy does not support bfloat16 so this was saved as a int16
      a__			:      Any            ="int16"
  
    a__			:      Dict            =np.memmap(SCREAMING_SNAKE_CASE , dtype=SCREAMING_SNAKE_CASE , shape=SCREAMING_SNAKE_CASE , mode="r"		)
  
    if len(weight_info["shape"]		) == 0:
      a__			:      List[Any]            =weight[0]
    a__			:      Tuple            =torch.tensor(SCREAMING_SNAKE_CASE		)
    if weight_info["dtype"] == "bfloat16":
      a__			:      Dict            =weight.view(torch.bfloataa		)
  
    return weight
  def   _A (	SCREAMING_SNAKE_CASE  :     List[Any] , SCREAMING_SNAKE_CASE  :     Union[str, Any]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    if index is None or len(SCREAMING_SNAKE_CASE		) == 0:
      # Nothing to save
      return
  
    a__			:      Optional[int]            =os.path.join(SCREAMING_SNAKE_CASE , "index.json"		)
    if os.path.isfile(SCREAMING_SNAKE_CASE		):
      with open(SCREAMING_SNAKE_CASE , "r" , encoding="utf-8"		) as f:
        a__			:      Any            =json.load(SCREAMING_SNAKE_CASE		)
    else:
      a__			:      Any            ={}
    current_index.update(SCREAMING_SNAKE_CASE		)
  
    with open(SCREAMING_SNAKE_CASE , "w" , encoding="utf-8"		) as f:
      json.dump(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , indent=2		)
  def   _A (	SCREAMING_SNAKE_CASE  :     Union[str, os.PathLike] , SCREAMING_SNAKE_CASE  :     Dict[str, torch.Tensor]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    os.makedirs(SCREAMING_SNAKE_CASE , exist_ok=SCREAMING_SNAKE_CASE		)
    a__			:      Any            ={}
    for name, parameter in state_dict.items():
      a__			:      List[str]            =offload_weight(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , index=SCREAMING_SNAKE_CASE		)
  
    # Update index
    save_offload_index(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__):
  
  
  
  
  
  
  
        def __init__(					self	,   lowerCAmelCase__	,   lowerCAmelCase__							)     ->		Optional[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Optional[Any]            =dataset
          a__			:      str            =prefix
  
  
  
  
  
  
  
        def __getitem__(					self	,   lowerCAmelCase__							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self.dataset[F'''{self.prefix}{key}''']
  
  
  
  
  
  
  
        def __iter__(					self							)     ->		Union[str, Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return iter([key for key in self.dataset if key.startswith(self.prefix							)]							)
  
  
  
  
  
  
  
        def __len__(					self							)     ->		Optional[int]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return len(self.dataset							)
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__):
  
  
  
  
  
  
  
        def __init__(					self	,   lowerCAmelCase__ = None	,   lowerCAmelCase__ = None	,   lowerCAmelCase__ = None	,   lowerCAmelCase__=None	,   )     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          if state_dict is None and save_folder is None:
            raise ValueError("Need either a `state_dict` or a `save_folder` containing offloaded weights."							)
  
          a__			:      int            ={} if state_dict is None else state_dict
          a__			:      int            =save_folder
          if index is None and save_folder is not None:
            with open(os.path.join(lowerCAmelCase__	,   "index.json"							)							) as f:
              a__			:      str            =json.load(lowerCAmelCase__							)
          a__			:      Tuple            ={} if index is None else index
          a__			:      Union[str, Any]            =list(self.state_dict.keys()							)
          self.all_keys.extend([key for key in self.index if key not in self.all_keys]							)
          a__			:      List[Any]            =device
  
  
  
  
  
  
  
        def __getitem__(					self	,   lowerCAmelCase__							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          if key in self.state_dict:
            return self.state_dict[key]
          a__			:      str            =self.index[key]
          if weight_info.get("safetensors_file"							) is not None:
            if not is_safetensors_available():
              raise ImportError("These offloaded weights require the use of safetensors: `pip install safetensors`."							)
  
            from safetensors import safe_open
  
            a__			:      Optional[Any]            ="cpu" if self.device is None else self.device
            with safe_open(weight_info["safetensors_file"]	,   framework="pt"	,   device=lowerCAmelCase__							) as f:
              a__			:      Optional[int]            =f.get_tensor(weight_info.get("weight_name"	,   lowerCAmelCase__							)							)
  
            if "dtype" in weight_info:
              return tensor.to(getattr(lowerCAmelCase__	,   weight_info["dtype"]							)							)
            else:
              return tensor
  
          a__			:      Any            =os.path.join(self.save_folder	,   F'''{key}.dat'''							)
          return load_offloaded_weight(lowerCAmelCase__	,   lowerCAmelCase__							)
  
  
  
  
  
  
  
        def __iter__(					self							)     ->		Optional[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return iter(self.all_keys							)
  
  
  
  
  
  
  
        def __len__(					self							)     ->		Optional[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return len(self.all_keys							)
  def   _A (	SCREAMING_SNAKE_CASE  :     Dict[str, torch.Tensor] , SCREAMING_SNAKE_CASE  :     List[str]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            ={}
    for module_name in submodule_names:
      # We want to catch module_name parameter (module_name.xxx) or potentially module_name, but not any of the
      # submodules that could being like module_name (transformers.h.1 and transformers.h.10 for instance)
      result.update(
          {
              key: param
              for key, param in state_dict.items()
              if key == module_name or key.startswith(module_name + "."		)
          }		)
    return result
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  from __future__ import annotations
  def   _A (	SCREAMING_SNAKE_CASE  :     str , SCREAMING_SNAKE_CASE  :     dict[str, str]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__      ,							a__      ,							a__			:      Optional[int]            ="", "", ""
    a__			:      str            =[]
  
    for character in message_part:
      tmp.append(character_to_number[character]		)
  
    for each in tmp:
      one += each[0]
      two += each[1]
      three += each[2]
  
    return one + two + three
  def   _A (	SCREAMING_SNAKE_CASE  :     str , SCREAMING_SNAKE_CASE  :     dict[str, str]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__      ,							a__			:      Any            ="", ""
    a__			:      Optional[int]            =[]
  
    for character in message_part:
      this_part += character_to_number[character]
  
    for digit in this_part:
      tmp += digit
      if len(SCREAMING_SNAKE_CASE		) == len(SCREAMING_SNAKE_CASE		):
        result.append(SCREAMING_SNAKE_CASE		)
        a__			:      str            =""
  
    return result[0], result[1], result[2]
  def   _A (	SCREAMING_SNAKE_CASE  :     str , SCREAMING_SNAKE_CASE  :     str		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            =alphabet.replace(" " , ""		).upper()
    a__			:      List[str]            =message.replace(" " , ""		).upper()
  
    # Check length and characters
    if len(SCREAMING_SNAKE_CASE		) != 27:
      raise KeyError("Length of alphabet has to be 27."		)
    for each in message:
      if each not in alphabet:
        raise ValueError("Each message character has to be included in alphabet!"		)
  
      # Generate dictionares
    a__			:      Any            =(
        "111",
        "112",
        "113",
        "121",
        "122",
        "123",
        "131",
        "132",
        "133",
        "211",
        "212",
        "213",
        "221",
        "222",
        "223",
        "231",
        "232",
        "233",
        "311",
        "312",
        "313",
        "321",
        "322",
        "323",
        "331",
        "332",
        "333",
    )
    a__			:      Tuple            ={}
    a__			:      List[str]            ={}
    for letter, number in zip(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		):
      a__			:      Dict            =number
      a__			:      Union[str, Any]            =letter
  
    return message, alphabet, character_to_number, number_to_character
  def   _A (	SCREAMING_SNAKE_CASE  :     str , SCREAMING_SNAKE_CASE  :     str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ." , SCREAMING_SNAKE_CASE  :     int = 5		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__      ,							a__      ,							a__      ,							a__			:      Union[str, Any]            =__prepare(
        SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
    a__      ,							a__			:      Union[str, Any]            ="", ""
  
    for i in range(0 , len(SCREAMING_SNAKE_CASE		) + 1 , SCREAMING_SNAKE_CASE		):
      encrypted_numeric += __encrypt_part(
          message[i : i + period] , SCREAMING_SNAKE_CASE		)
  
    for i in range(0 , len(SCREAMING_SNAKE_CASE		) , 3		):
      encrypted += number_to_character[encrypted_numeric[i : i + 3]]
  
    return encrypted
  def   _A (	SCREAMING_SNAKE_CASE  :     str , SCREAMING_SNAKE_CASE  :     str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ." , SCREAMING_SNAKE_CASE  :     int = 5		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__      ,							a__      ,							a__      ,							a__			:      Dict            =__prepare(
        SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
    a__			:      Optional[Any]            =[]
    a__			:      Any            =""
  
    for i in range(0 , len(SCREAMING_SNAKE_CASE		) + 1 , SCREAMING_SNAKE_CASE		):
      a__      ,							a__      ,							a__			:      Union[str, Any]            =__decrypt_part(message[i : i + period] , SCREAMING_SNAKE_CASE		)
  
      for j in range(0 , len(SCREAMING_SNAKE_CASE		)		):
        decrypted_numeric.append(a[j] + b[j] + c[j]		)
  
    for each in decrypted_numeric:
      decrypted += number_to_character[each]
  
    return decrypted
  
  
  if __name__ == "__main__":
       UpperCAmelCase			:			List[str]	  = """DEFEND THE EAST WALL OF THE CASTLE."""
       UpperCAmelCase			:			Optional[Any]	  = encrypt_message(msg, """EPSDUCVWYM.ZLKXNBTFGORIJHAQ""")
       UpperCAmelCase			:			Optional[int]	  = decrypt_message(encrypted, """EPSDUCVWYM.ZLKXNBTFGORIJHAQ""")
       print(F"""Encrypted: {encrypted}\nDecrypted: {decrypted}""")
  
  
  
  
  
  
  