code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  import os
  import random
  from pathlib import Path
  from typing import List
  
  import numpy as np
  import torch
  from torch.cuda.amp import GradScaler
  
  from .utils import (
      MODEL_NAME,
      OPTIMIZER_NAME,
      RNG_STATE_NAME,
      SCALER_NAME,
      SCHEDULER_NAME,
      get_pretty_name,
      is_tpu_available,
      is_xpu_available,
      save,
  )
  
  
  if is_tpu_available(check_device=False):
  			import torch_xla.core.xla_model as xm
  
  from .logging import get_logger
  from .state import PartialState
  
  
  a__				: Union[str, Any]									=    get_logger(__name__)
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_ = None				,							)      ->Optional[int]:
  	# Model states
  	for i, state in enumerate(snake_case__       ):
  		snake_case__  					=      f'''{MODEL_NAME}.bin''' if i == 0 else f'''{MODEL_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		save(snake_case__				,							snake_case__       )
  		logger.info(f'''Model weights saved in {output_model_file}'''       )
  	# Optimizer states
  	for i, opt in enumerate(snake_case__       ):
  		snake_case__  					=      opt.state_dict()
  		snake_case__  					=      f'''{OPTIMIZER_NAME}.bin''' if i == 0 else f'''{OPTIMIZER_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		save(snake_case__				,							snake_case__       )
  		logger.info(f'''Optimizer state saved in {output_optimizer_file}'''       )
  	# Scheduler states
  	for i, scheduler in enumerate(snake_case__       ):
  		snake_case__  					=      scheduler.state_dict()
  		snake_case__  					=      f'''{SCHEDULER_NAME}.bin''' if i == 0 else f'''{SCHEDULER_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		save(snake_case__				,							snake_case__       )
  		logger.info(f'''Scheduler state saved in {output_scheduler_file}'''       )
  	# GradScaler state
  	if scaler is not None:
  		snake_case__  					=      scaler.state_dict()
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		torch.save(snake_case__				,							snake_case__       )
  		logger.info(f'''Gradient scaler state saved in {output_scaler_file}'''       )
  	# Random number generator states
  	snake_case__  					=      {}
  	snake_case__  					=      f'''{RNG_STATE_NAME}_{process_index}.pkl'''
  	snake_case__  					=      random.getstate()
  	snake_case__  					=      np.random.get_state()
  	snake_case__  					=      torch.get_rng_state()
  	if is_xpu_available():
  		snake_case__  					=      torch.xpu.get_rng_state_all()
  	else:
  		snake_case__  					=      torch.cuda.get_rng_state_all()
  	if is_tpu_available():
  		snake_case__  					=      xm.get_rng_state()
  	snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  	torch.save(snake_case__				,							snake_case__       )
  	logger.info(f'''Random states saved in {output_states_file}'''       )
  	return output_dir
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_=None				,							UpperCAmelCase_=None				,							**UpperCAmelCase_				,							)      ->List[str]:
  	if map_location not in [None, "cpu", "on_device"]:
  		raise TypeError(
  		    'Unsupported optimizer map location passed, please choose one of `None`, `\'cpu\'`, or `\'on_device\'`'       )
  	if map_location is None:
  		snake_case__  					=      'cpu'
  	elif map_location == "on_device":
  		snake_case__  					=      PartialState().device
  	# Model states
  	for i, model in enumerate(snake_case__       ):
  		snake_case__  					=      f'''{MODEL_NAME}.bin''' if i == 0 else f'''{MODEL_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		models[i].load_state_dict(torch.load(snake_case__				,							map_location=snake_case__       )				,							**snake_case__       )
  	logger.info('All model weights loaded successfully'       )
  
  	# Optimizer states
  	for i, opt in enumerate(snake_case__       ):
  		snake_case__  					=      f'''{OPTIMIZER_NAME}.bin''' if i == 0 else f'''{OPTIMIZER_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		snake_case__  					=      torch.load(snake_case__				,							map_location=snake_case__       )
  		optimizers[i].load_state_dict(snake_case__       )
  	logger.info('All optimizer states loaded successfully'       )
  
  	# Scheduler states
  	for i, scheduler in enumerate(snake_case__       ):
  		snake_case__  					=      f'''{SCHEDULER_NAME}.bin''' if i == 0 else f'''{SCHEDULER_NAME}_{i}.bin'''
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		scheduler.load_state_dict(torch.load(snake_case__       )       )
  	logger.info('All scheduler states loaded successfully'       )
  
  	# GradScaler state
  	if scaler is not None:
  		snake_case__  					=      os.path.join(snake_case__				,							snake_case__       )
  		scaler.load_state_dict(torch.load(snake_case__       )       )
  		logger.info('GradScaler state loaded successfully'       )
  
  	# Random states
  	try:
  		snake_case__  					=      torch.load(os.path.join(snake_case__				,							f'''{RNG_STATE_NAME}_{process_index}.pkl'''       )       )
  		random.setstate(states['random_state']       )
  		np.random.set_state(states['numpy_random_seed']       )
  		torch.set_rng_state(states['torch_manual_seed']       )
  		if is_xpu_available():
  			torch.xpu.set_rng_state_all(states['torch_xpu_manual_seed']       )
  		else:
  			torch.cuda.set_rng_state_all(states['torch_cuda_manual_seed']       )
  		if is_tpu_available():
  			xm.set_rng_state(states['xm_seed']       )
  		logger.info('All random states loaded successfully'       )
  	except Exception:
  		logger.info('Could not load random states'       )
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_ = 0       )      ->Union[str, Any]:
  	snake_case__  					=      Path(snake_case__       ) / f'''custom_checkpoint_{index}.pkl'''
  	logger.info(f'''Saving the state of {get_pretty_name(snake_case__       )} to {save_location}'''       )
  	torch.save(obj.state_dict()				,							snake_case__       )
  
  
  
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_ = 0       )      ->Optional[int]:
  	snake_case__  					=      f'''{path}/custom_checkpoint_{index}.pkl'''
  	logger.info(f'''Loading the state of {get_pretty_name(snake_case__       )} from {load_location}'''       )
  	obj.load_state_dict(torch.load(snake_case__				,							map_location='cpu'       )       )
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_       )      ->int:
  	return 1 if input_a == 0 else 0
  
  
  
  
  def 	__lowerCamelCase (  )      ->None:
  	assert not_gate(0       ) == 1
  	assert not_gate(1       ) == 0
  
  
  if __name__ == "__main__":
  			print(not_gate(0))
  			print(not_gate(1))
  
  
  
  