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
  
  
  _lowerCAmelCase					:Dict  =      get_logger(__name__)
  
  
  
  
  
  def 				lowerCamelCase_		(UpperCamelCase__	:	str  , UpperCamelCase__	:	List[dict]  , UpperCamelCase__	:	list  , UpperCamelCase__	:	list  , UpperCamelCase__	:	int  , UpperCamelCase__	:	GradScaler = None  , ):
      # Model states
      for i, state in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						Union[str, Any]       							=					F'{MODEL_NAME}.bin' if i == 0 else F'{MODEL_NAME}_{i}.bin'
          _UpperCAmelCase							:						str       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          save(UpperCamelCase__  , UpperCamelCase__							)
          logger.info(F'Model weights saved in {output_model_file}'							)
      # Optimizer states
      for i, opt in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						List[str]       							=					opt.state_dict()
          _UpperCAmelCase							:						Optional[Any]       							=					F'{OPTIMIZER_NAME}.bin' if i == 0 else F'{OPTIMIZER_NAME}_{i}.bin'
          _UpperCAmelCase							:						int       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          save(UpperCamelCase__  , UpperCamelCase__							)
          logger.info(F'Optimizer state saved in {output_optimizer_file}'							)
      # Scheduler states
      for i, scheduler in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						Optional[Any]       							=					scheduler.state_dict()
          _UpperCAmelCase							:						Optional[Any]       							=					F'{SCHEDULER_NAME}.bin' if i == 0 else F'{SCHEDULER_NAME}_{i}.bin'
          _UpperCAmelCase							:						Optional[Any]       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          save(UpperCamelCase__  , UpperCamelCase__							)
          logger.info(F'Scheduler state saved in {output_scheduler_file}'							)
      # GradScaler state
      if scaler is not None:
          _UpperCAmelCase							:						List[str]       							=					scaler.state_dict()
          _UpperCAmelCase							:						List[str]       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          torch.save(UpperCamelCase__  , UpperCamelCase__							)
          logger.info(F'Gradient scaler state saved in {output_scaler_file}'							)
      # Random number generator states
      _UpperCAmelCase							:						str       							=					{}
      _UpperCAmelCase							:						Any       							=					F'{RNG_STATE_NAME}_{process_index}.pkl'
      _UpperCAmelCase							:						Optional[int]       							=					random.getstate()
      _UpperCAmelCase							:						Any       							=					np.random.get_state()
      _UpperCAmelCase							:						Union[str, Any]       							=					torch.get_rng_state()
      if is_xpu_available():
          _UpperCAmelCase							:						int       							=					torch.xpu.get_rng_state_all()
      else:
          _UpperCAmelCase							:						Optional[Any]       							=					torch.cuda.get_rng_state_all()
      if is_tpu_available():
          _UpperCAmelCase							:						int       							=					xm.get_rng_state()
      _UpperCAmelCase							:						Optional[int]       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
      torch.save(UpperCamelCase__  , UpperCamelCase__							)
      logger.info(F'Random states saved in {output_states_file}'							)
      return output_dir
  
  
  
  
  
  def 				lowerCamelCase_		(UpperCamelCase__	:	int  , UpperCamelCase__	:	int  , UpperCamelCase__	:	Union[str, Any]  , UpperCamelCase__	:	Any  , UpperCamelCase__	:	Any  , UpperCamelCase__	:	Any=None  , UpperCamelCase__	:	Optional[int]=None  , **UpperCamelCase__	:	Tuple  , ):
      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:
          _UpperCAmelCase							:						Dict       							=					'''cpu'''
      elif map_location == "on_device":
          _UpperCAmelCase							:						List[Any]       							=					PartialState().device
      # Model states
      for i, model in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						Dict       							=					F'{MODEL_NAME}.bin' if i == 0 else F'{MODEL_NAME}_{i}.bin'
          _UpperCAmelCase							:						Tuple       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          models[i].load_state_dict(torch.load(UpperCamelCase__  , map_location=UpperCamelCase__							)  , **UpperCamelCase__							)
      logger.info('''All model weights loaded successfully'''							)
  
      # Optimizer states
      for i, opt in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						List[Any]       							=					F'{OPTIMIZER_NAME}.bin' if i == 0 else F'{OPTIMIZER_NAME}_{i}.bin'
          _UpperCAmelCase							:						Tuple       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          _UpperCAmelCase							:						str       							=					torch.load(UpperCamelCase__  , map_location=UpperCamelCase__							)
          optimizers[i].load_state_dict(UpperCamelCase__							)
      logger.info('''All optimizer states loaded successfully'''							)
  
      # Scheduler states
      for i, scheduler in enumerate(UpperCamelCase__							):
          _UpperCAmelCase							:						List[str]       							=					F'{SCHEDULER_NAME}.bin' if i == 0 else F'{SCHEDULER_NAME}_{i}.bin'
          _UpperCAmelCase							:						str       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          scheduler.load_state_dict(torch.load(UpperCamelCase__							)							)
      logger.info('''All scheduler states loaded successfully'''							)
  
      # GradScaler state
      if scaler is not None:
          _UpperCAmelCase							:						Optional[int]       							=					os.path.join(UpperCamelCase__  , UpperCamelCase__							)
          scaler.load_state_dict(torch.load(UpperCamelCase__							)							)
          logger.info('''GradScaler state loaded successfully'''							)
  
      # Random states
      try:
          _UpperCAmelCase							:						Optional[int]       							=					torch.load(os.path.join(UpperCamelCase__  , 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__	:	Any  , UpperCamelCase__	:	Any  , UpperCamelCase__	:	int = 0							):
      _UpperCAmelCase							:						Optional[Any]       							=					Path(UpperCamelCase__							) / F'custom_checkpoint_{index}.pkl'
      logger.info(F'Saving the state of {get_pretty_name(UpperCamelCase__							)} to {save_location}'							)
      torch.save(obj.state_dict()  , UpperCamelCase__							)
  
  
  
  
  
  def 				lowerCamelCase_		(UpperCamelCase__	:	List[Any]  , UpperCamelCase__	:	Dict  , UpperCamelCase__	:	int = 0							):
      _UpperCAmelCase							:						Optional[int]       							=					F'{path}/custom_checkpoint_{index}.pkl'
      logger.info(F'Loading the state of {get_pretty_name(UpperCamelCase__							)} from {load_location}'							)
      obj.load_state_dict(torch.load(UpperCamelCase__  , map_location='''cpu'''							)							)
  
  
  
style_context: 
  
  
  
  """simple docstring"""
  import os
  
  from apache_beam.io.filesystems import FileSystems
  from apache_beam.pipeline import Pipeline
  
  from .logging import get_logger
  
  
  _lowerCAmelCase					:Optional[int]  =      2 << 20  # 2mb
  _lowerCAmelCase					:Union[str, Any]  =      get_logger(__name__)
  class 							_UpperCAmelCase							(				a   ):
  
  
  
  
  
       '''simple docstring'''
  
  
  
       def 				__lowerCAmelCase			(      self	)							->      Any:
           _UpperCAmelCase							:						str       							=					self._options.get_all_options().get('''runner'''	)
           return runner in [None, "DirectRunner", "PortableRunner"]
  
  
  
  
  
  def 				lowerCamelCase_		(UpperCamelCase__	:	List[str]  , UpperCamelCase__	:	str  , UpperCamelCase__	:	Dict=False							):
      _UpperCAmelCase							:						Union[str, Any]       							=					FileSystems
      if fs.exists(UpperCamelCase__							):
          if force_upload:
              logger.info(F'Remote path already exist: {remote_file_path}. Overwriting it as force_upload=True.'							)
          else:
              logger.info(F'Remote path already exist: {remote_file_path}. Skipping it as force_upload=False.'							)
              return
      with fs.create(UpperCamelCase__							) as remote_file:
          with open(UpperCamelCase__  , '''rb'''							) as local_file:
              _UpperCAmelCase							:						Optional[Any]       							=					local_file.read(UpperCamelCase__							)
              while chunk:
                  remote_file.write(UpperCamelCase__							)
                  _UpperCAmelCase							:						List[Any]       							=					local_file.read(UpperCamelCase__							)
  
  
  
  
  
  def 				lowerCamelCase_		(UpperCamelCase__	:	int  , UpperCamelCase__	:	Dict  , UpperCamelCase__	:	str=False							):
      _UpperCAmelCase							:						int       							=					FileSystems
      if os.path.exists(UpperCamelCase__							):
          if force_download:
              logger.info(F'Local path already exist: {remote_file_path}. Overwriting it as force_upload=True.'							)
          else:
              logger.info(F'Local path already exist: {remote_file_path}. Skipping it as force_upload=False.'							)
              return
      with fs.open(UpperCamelCase__							) as remote_file:
          with open(UpperCamelCase__  , '''wb'''							) as local_file:
              _UpperCAmelCase							:						List[str]       							=					remote_file.read(UpperCamelCase__							)
              while chunk:
                  local_file.write(UpperCamelCase__							)
                  _UpperCAmelCase							:						List[Any]       							=					remote_file.read(UpperCamelCase__							)
  
  
  