




from __future__ import annotations




def 					lowerCamelCase__       (						A__       :					str  ,			A__       :					list[str] | None = None  ,			A__       :					dict[str, float] | None = None  ,			A__       :					bool = False  ,			):





       '''simple docstring'''



       __lowerCamelCase   =						cipher_alphabet or [chr(A__	) for i in range(97  ,			123	)]

       # If the argument is None or the user provided an empty dictionary
       if not frequencies_dict:
              # Frequencies of letters in the english language (how much they show up)
              __lowerCamelCase   =						{
                  """a""": 0.08_497,
                  """b""": 0.01_492,
                  """c""": 0.02_202,
                  """d""": 0.04_253,
                  """e""": 0.11_162,
                  """f""": 0.02_228,
                  """g""": 0.02_015,
                  """h""": 0.06_094,
                  """i""": 0.07_546,
                  """j""": 0.00_153,
                  """k""": 0.01_292,
                  """l""": 0.04_025,
                  """m""": 0.02_406,
                  """n""": 0.06_749,
                  """o""": 0.07_507,
                  """p""": 0.01_929,
                  """q""": 0.00_095,
                  """r""": 0.07_587,
                  """s""": 0.06_327,
                  """t""": 0.09_356,
                  """u""": 0.02_758,
                  """v""": 0.00_978,
                  """w""": 0.02_560,
                  """x""": 0.00_150,
                  """y""": 0.01_994,
                  """z""": 0.00_077,
              }
       else:
              # Custom frequencies dictionary
              __lowerCamelCase   =						frequencies_dict

       if not case_sensitive:
              __lowerCamelCase   =						ciphertext.lower()

       # Chi squared statistic values
       __lowerCamelCase   =						{}

       # cycle through all of the shifts
       for shift in range(len(A__	)	):
              __lowerCamelCase   =						""""""

              # decrypt the message with the shift
              for letter in ciphertext:
                     try:
                            # Try to index the letter in the alphabet
                            __lowerCamelCase   =						(alphabet_letters.index(letter.lower()	) - shift) % len(
                                A__	)
                            decrypted_with_shift += (
                                alphabet_letters[new_key].upper()
                                if case_sensitive and letter.isupper()
                                else alphabet_letters[new_key]
                            )
                     except ValueError:
                            # Append the character if it isn't in the alphabet
                            decrypted_with_shift += letter

              __lowerCamelCase   =						0.0

              # Loop through each letter in the decoded message with the shift
              for letter in decrypted_with_shift:
                     if case_sensitive:
                            __lowerCamelCase   =						letter.lower()
                            if letter in frequencies:
                                   # Get the amount of times the letter occurs in the message
                                   __lowerCamelCase   =						decrypted_with_shift.lower().count(A__	)

                                   # Get the excepcted amount of times the letter should appear based
                                   # on letter frequencies
                                   __lowerCamelCase   =						frequencies[letter] * occurrences

                                   # Complete the chi squared statistic formula
                                   __lowerCamelCase   =						((occurrences - expected) ** 2) / expected

                                   # Add the margin of error to the total chi squared statistic
                                   chi_squared_statistic += chi_letter_value
                     else:
                            if letter.lower() in frequencies:
                                   # Get the amount of times the letter occurs in the message
                                   __lowerCamelCase   =						decrypted_with_shift.count(A__	)

                                   # Get the excepcted amount of times the letter should appear based
                                   # on letter frequencies
                                   __lowerCamelCase   =						frequencies[letter] * occurrences

                                   # Complete the chi squared statistic formula
                                   __lowerCamelCase   =						((occurrences - expected) ** 2) / expected

                                   # Add the margin of error to the total chi squared statistic
                                   chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
              __lowerCamelCase   =						(
                  chi_squared_statistic,
                  decrypted_with_shift,
              )

       # Get the most likely cipher by finding the cipher with the smallest chi squared
       # statistic
       def chi_squared_statistic_values_sorting_key(A__       :					int	) -> tuple[float, str]:
              return chi_squared_statistic_values[key]

       __lowerCamelCase   =						min(
           A__  ,			key=A__  ,			)

       # Get all the data from the most likely cipher (key, decoded message)
       (
           (
           __lowerCamelCase
       ),   (
           __lowerCamelCase
       ),   
       )   =						chi_squared_statistic_values[most_likely_cipher]

       # Return the data on the most likely shift
       return (
           most_likely_cipher,
           most_likely_cipher_chi_squared_value,
           decoded_most_likely_cipher,
       )







import os

import torch

from ..logging import get_logger
from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME
from .versions import is_torch_version


if is_torch_version('>=', FSDP_PYTORCH_VERSION):
       import torch.distributed.checkpoint as dist_cp
       from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner
       from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
       from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
       from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType


UpperCAmelCase_									=	get_logger(__name__)




def 					lowerCamelCase__       (						A__       :					Union[str, Any]  ,			A__       :					str  ,			A__       :					Any  ,			A__       :					Dict  ,			A__       :					Any=0	):





       '''simple docstring'''



       os.makedirs(A__  ,			exist_ok=A__	)
       with FSDP.state_dict_type(
           A__  ,			fsdp_plugin.state_dict_type  ,			fsdp_plugin.state_dict_config  ,			fsdp_plugin.optim_state_dict_config	):
              __lowerCamelCase   =						model.state_dict()
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     __lowerCamelCase   =						f'{MODEL_NAME}.bin' if model_index == 0 else f'{MODEL_NAME}_{model_index}.bin'
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     if accelerator.process_index == 0:
                            logger.info(f'Saving model to {output_model_file}'	)
                            torch.save(A__  ,			A__	)
                            logger.info(f'Model saved to {output_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
                     __lowerCamelCase   =						(
                         f'{MODEL_NAME}_rank{accelerator.process_index}.bin'
                         if model_index == 0
                         else f'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
                     )
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Saving model to {output_model_file}'	)
                     torch.save(A__  ,			A__	)
                     logger.info(f'Model saved to {output_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
                     __lowerCamelCase   =						os.path.join(A__  ,			f'{MODEL_NAME}_{model_index}'	)
                     os.makedirs(A__  ,			exist_ok=A__	)
                     logger.info(f'Saving model to {ckpt_dir}'	)
                     __lowerCamelCase   =						{"""model""": state_dict}

                     dist_cp.save_state_dict(
                         state_dict=A__  ,			storage_writer=dist_cp.FileSystemWriter(A__	)  ,			planner=DefaultSavePlanner()  ,			)
                     logger.info(f'Model saved to {ckpt_dir}'	)




def 					lowerCamelCase__       (						A__       :					int  ,			A__       :					Dict  ,			A__       :					int  ,			A__       :					List[str]  ,			A__       :					Any=0	):





       '''simple docstring'''



       accelerator.wait_for_everyone()
       with FSDP.state_dict_type(
           A__  ,			fsdp_plugin.state_dict_type  ,			fsdp_plugin.state_dict_config  ,			fsdp_plugin.optim_state_dict_config	):
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     if type(A__	) != FSDP and accelerator.process_index != 0:
                            if not fsdp_plugin.sync_module_states:
                                   raise ValueError(
                                       """Set the `sync_module_states` flag to `True` so that model states are synced across processes when """
                                       """initializing FSDP object"""	)
                            return
                     __lowerCamelCase   =						f'{MODEL_NAME}.bin' if model_index == 0 else f'{MODEL_NAME}_{model_index}.bin'
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading model from {input_model_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Model loaded from {input_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
                     __lowerCamelCase   =						(
                         f'{MODEL_NAME}_rank{accelerator.process_index}.bin'
                         if model_index == 0
                         else f'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
                     )
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading model from {input_model_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Model loaded from {input_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
                     __lowerCamelCase   =						(
                         os.path.join(A__  ,			f'{MODEL_NAME}_{model_index}'	)
                         if f'{MODEL_NAME}' not in input_dir
                         else input_dir
                     )
                     logger.info(f'Loading model from {ckpt_dir}'	)
                     __lowerCamelCase   =						{"""model""": model.state_dict()}
                     dist_cp.load_state_dict(
                         state_dict=A__  ,			storage_reader=dist_cp.FileSystemReader(A__	)  ,			planner=DefaultLoadPlanner()  ,			)
                     __lowerCamelCase   =						state_dict["""model"""]
                     logger.info(f'Model loaded from {ckpt_dir}'	)
              model.load_state_dict(A__	)




def 					lowerCamelCase__       (						A__       :					List[str]  ,			A__       :					List[str]  ,			A__       :					str  ,			A__       :					Dict  ,			A__       :					Optional[Any]  ,			A__       :					Optional[int]=0	):





       '''simple docstring'''



       os.makedirs(A__  ,			exist_ok=A__	)
       with FSDP.state_dict_type(
           A__  ,			fsdp_plugin.state_dict_type  ,			fsdp_plugin.state_dict_config  ,			fsdp_plugin.optim_state_dict_config	):
              __lowerCamelCase   =						FSDP.optim_state_dict(A__  ,			A__	)
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     if accelerator.process_index == 0:
                            __lowerCamelCase   =						(
                                f'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else f'{OPTIMIZER_NAME}_{optimizer_index}.bin'
                            )
                            __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                            logger.info(f'Saving Optimizer state to {output_optimizer_file}'	)
                            torch.save(A__  ,			A__	)
                            logger.info(f'Optimizer state saved in {output_optimizer_file}'	)
              else:
                     __lowerCamelCase   =						os.path.join(A__  ,			f'{OPTIMIZER_NAME}_{optimizer_index}'	)
                     os.makedirs(A__  ,			exist_ok=A__	)
                     logger.info(f'Saving Optimizer state to {ckpt_dir}'	)
                     dist_cp.save_state_dict(
                         state_dict={"""optimizer""": optim_state}  ,			storage_writer=dist_cp.FileSystemWriter(A__	)  ,			planner=DefaultSavePlanner()  ,			)
                     logger.info(f'Optimizer state saved in {ckpt_dir}'	)




def 					lowerCamelCase__       (						A__       :					int  ,			A__       :					List[str]  ,			A__       :					int  ,			A__       :					Any  ,			A__       :					Union[str, Any]  ,			A__       :					List[Any]=0	):





       '''simple docstring'''



       accelerator.wait_for_everyone()
       with FSDP.state_dict_type(
           A__  ,			fsdp_plugin.state_dict_type  ,			fsdp_plugin.state_dict_config  ,			fsdp_plugin.optim_state_dict_config	):
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     __lowerCamelCase   =						None
                     # below check should work but currently it isn't working (mostly opytorch issue),
                     # in the meantime disabling it at the cost of excess memory usage
                     # if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only:
                     __lowerCamelCase   =						(
                         f'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else f'{OPTIMIZER_NAME}_{optimizer_index}.bin'
                     )
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading Optimizer state from {input_optimizer_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Optimizer state loaded from {input_optimizer_file}'	)
              else:
                     __lowerCamelCase   =						(
                         os.path.join(A__  ,			f'{OPTIMIZER_NAME}_{optimizer_index}'	)
                         if f'{OPTIMIZER_NAME}' not in input_dir
                         else input_dir
                     )
                     logger.info(f'Loading Optimizer from {ckpt_dir}'	)
                     __lowerCamelCase   =						load_sharded_optimizer_state_dict(
                         model_state_dict=model.state_dict()  ,			optimizer_key="""optimizer"""  ,			storage_reader=dist_cp.FileSystemReader(A__	)  ,			)
                     __lowerCamelCase   =						optim_state["""optimizer"""]
                     logger.info(f'Optimizer loaded from {ckpt_dir}'	)
              __lowerCamelCase   =						FSDP.optim_state_dict_to_load(A__  ,			A__  ,			A__	)
              optimizer.load_state_dict(A__	)

