



import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


if is_tpu_available(check_device=False):
      import torch_xla.core.xla_model as xm






def 						_lowerCAmelCase    (					__lowerCamelCase :  Any		,						__lowerCamelCase :  str  ):



 """simple docstring"""





 if isinstance(__lowerCamelCase		,						(list, tuple)  ):
  return honor_type(__lowerCamelCase		,						(move_to_device(__lowerCamelCase		,						__lowerCamelCase  ) for t in state)  )
 elif isinstance(__lowerCamelCase		,						__lowerCamelCase  ):
  return type(__lowerCamelCase  )({k: move_to_device(__lowerCamelCase		,						__lowerCamelCase  ) for k, v in state.items()}  )
 elif isinstance(__lowerCamelCase		,						torch.Tensor  ):
  return state.to(__lowerCamelCase  )
 return state






class    _SCREAMING_SNAKE_CASE						(torch.optim.Optimizer			):





     def __init__(							self			:				int  ,	UpperCamelCase			:				Any  ,	UpperCamelCase			:				List[str]=True  ,	UpperCamelCase			:				List[Any]=None					)->Optional[int]:
      __SCREAMING_SNAKE_CASE							:     str							=						optimizer
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						scaler
      __SCREAMING_SNAKE_CASE							:     Any							=						AcceleratorState()
      __SCREAMING_SNAKE_CASE							:     int							=						GradientState()
      __SCREAMING_SNAKE_CASE							:     str							=						device_placement
      __SCREAMING_SNAKE_CASE							:     int							=						False
      __SCREAMING_SNAKE_CASE							:     Dict							=						None

      # Handle device placement
      if device_placement:
       __SCREAMING_SNAKE_CASE							:     List[str]							=						self.optimizer.state_dict()
       if self.accelerator_state.distributed_type == DistributedType.TPU:
        xm.send_cpu_data_to_device(UpperCamelCase  ,	self.accelerator_state.device					)
       else:
        __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						move_to_device(UpperCamelCase  ,	self.accelerator_state.device					)
       self.optimizer.load_state_dict(UpperCamelCase					)





     @property
     def 						__snake_case     (							self			:				Optional[Any]					)->List[str]:
      return self.optimizer.state





     @state.setter
     def 						__snake_case     (							self			:				Optional[int]  ,	UpperCamelCase			:				List[str]					)->Dict:
      __SCREAMING_SNAKE_CASE							:     List[str]							=						state





     @property
     def 						__snake_case     (							self			:				List[Any]					)->str:
      return self.optimizer.param_groups





     @param_groups.setter
     def 						__snake_case     (							self			:				List[str]  ,	UpperCamelCase			:				Any					)->Dict:
      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						param_groups





     @property
     def 						__snake_case     (							self			:				str					)->str:
      return self.optimizer.defaults





     @defaults.setter
     def 						__snake_case     (							self			:				int  ,	UpperCamelCase			:				Tuple					)->List[str]:
      __SCREAMING_SNAKE_CASE							:     List[str]							=						defaults





     def 						__snake_case     (							self			:				Any  ,	UpperCamelCase			:				Tuple					)->Optional[int]:
      self.optimizer.add_param_group(UpperCamelCase					)





     def 						__snake_case     (							self			:				Union[str, Any]  ,	UpperCamelCase			:				Union[str, Any]					)->Dict:
      if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
       xm.send_cpu_data_to_device(UpperCamelCase  ,	self.accelerator_state.device					)
      self.optimizer.load_state_dict(UpperCamelCase					)





     def 						__snake_case     (							self			:				List[str]					)->List[Any]:
      return self.optimizer.state_dict()





     def 						__snake_case     (							self			:				Optional[int]  ,	UpperCamelCase			:				Any=None					)->Any:
      if self.gradient_state.sync_gradients:
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						"set_to_none" in inspect.signature(self.optimizer.zero_grad					).parameters
       if accept_arg:
        if set_to_none is None:
         __SCREAMING_SNAKE_CASE							:     Optional[int]							=						False
        self.optimizer.zero_grad(set_to_none=UpperCamelCase					)
       else:
        if set_to_none is not None:
         raise ValueError("`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer."					)
        self.optimizer.zero_grad()





     def 						__snake_case     (							self			:				Dict  ,	UpperCamelCase			:				Tuple=None					)->List[Any]:
      if self.gradient_state.sync_gradients:
       if self.accelerator_state.distributed_type == DistributedType.TPU:
        __SCREAMING_SNAKE_CASE							:     List[str]							=						{"closure": closure} if closure is not None else {}
        xm.optimizer_step(self.optimizer  ,	optimizer_args=UpperCamelCase					)
       elif self.scaler is not None:
        __SCREAMING_SNAKE_CASE							:     Optional[int]							=						False
        if self._last_scale is None:
         # `get_scale` is an async operation requiring full synchronization
         # on CPU and GPUs before finishing. As a result, we store away
         # the prior one to reduce the call overhead
         __SCREAMING_SNAKE_CASE							:     List[Any]							=						self.scaler.get_scale()
         __SCREAMING_SNAKE_CASE							:     List[Any]							=						True
        self.scaler.step(self.optimizer  ,	UpperCamelCase					)
        self.scaler.update()
        __SCREAMING_SNAKE_CASE							:     Dict							=						self.scaler.get_scale()
        if not new_scale:
         # If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
         __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						scale_after < self._last_scale
        __SCREAMING_SNAKE_CASE							:     List[Any]							=						scale_after

       else:
        self.optimizer.step(UpperCamelCase					)





     def 						__snake_case     (							self			:				Optional[int]  ,	UpperCamelCase			:				Optional[Any]					)->Any:
      for param_group in self.optimizer.param_groups:
       __SCREAMING_SNAKE_CASE							:     Tuple							=						[parameters_map.get(UpperCamelCase  ,	UpperCamelCase					) for p in param_group["params"]]





     @property
     def 						__snake_case     (							self			:				List[Any]					)->int:
      warnings.warn(
          "The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use "
          "`optimizer.step_was_skipped` instead."  ,	UpperCamelCase  ,	)
      return self._is_overflow





     @property
     def 						__snake_case     (							self			:				Optional[int]					)->List[Any]:
      return self._is_overflow





     def __getstate__(							self			:				List[str]					)->List[str]:
      return self.__dict__.copy()






     def __setstate__(							self			:				Union[str, Any]  ,	UpperCamelCase			:				str					)->int:
      self.__dict__.update(UpperCamelCase					)







from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


UpperCAmelCase      		=					{
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=					[
     '''Constraint''',
     '''ConstraintListState''',
     '''DisjunctiveConstraint''',
     '''PhrasalConstraint''',
 ]
 UpperCAmelCase      		=					[
     '''BeamHypotheses''',
     '''BeamScorer''',
     '''BeamSearchScorer''',
     '''ConstrainedBeamSearchScorer''',
 ]
 UpperCAmelCase      		=					[
     '''EpsilonLogitsWarper''',
     '''EtaLogitsWarper''',
     '''ForcedBOSTokenLogitsProcessor''',
     '''ForcedEOSTokenLogitsProcessor''',
     '''HammingDiversityLogitsProcessor''',
     '''InfNanRemoveLogitsProcessor''',
     '''LogitsProcessor''',
     '''LogitsProcessorList''',
     '''LogitsWarper''',
     '''MinLengthLogitsProcessor''',
     '''MinNewTokensLengthLogitsProcessor''',
     '''NoBadWordsLogitsProcessor''',
     '''NoRepeatNGramLogitsProcessor''',
     '''PrefixConstrainedLogitsProcessor''',
     '''RepetitionPenaltyLogitsProcessor''',
     '''SequenceBiasLogitsProcessor''',
     '''EncoderRepetitionPenaltyLogitsProcessor''',
     '''TemperatureLogitsWarper''',
     '''TopKLogitsWarper''',
     '''TopPLogitsWarper''',
     '''TypicalLogitsWarper''',
     '''EncoderNoRepeatNGramLogitsProcessor''',
     '''ExponentialDecayLengthPenalty''',
     '''LogitNormalization''',
 ]
 UpperCAmelCase      		=					[
     '''MaxNewTokensCriteria''',
     '''MaxLengthCriteria''',
     '''MaxTimeCriteria''',
     '''StoppingCriteria''',
     '''StoppingCriteriaList''',
     '''validate_stopping_criteria''',
 ]
 UpperCAmelCase      		=					[
     '''GenerationMixin''',
     '''top_k_top_p_filtering''',
     '''GreedySearchEncoderDecoderOutput''',
     '''GreedySearchDecoderOnlyOutput''',
     '''SampleEncoderDecoderOutput''',
     '''SampleDecoderOnlyOutput''',
     '''BeamSearchEncoderDecoderOutput''',
     '''BeamSearchDecoderOnlyOutput''',
     '''BeamSampleEncoderDecoderOutput''',
     '''BeamSampleDecoderOnlyOutput''',
     '''ContrastiveSearchEncoderDecoderOutput''',
     '''ContrastiveSearchDecoderOnlyOutput''',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=					[
     '''TFForcedBOSTokenLogitsProcessor''',
     '''TFForcedEOSTokenLogitsProcessor''',
     '''TFLogitsProcessor''',
     '''TFLogitsProcessorList''',
     '''TFLogitsWarper''',
     '''TFMinLengthLogitsProcessor''',
     '''TFNoBadWordsLogitsProcessor''',
     '''TFNoRepeatNGramLogitsProcessor''',
     '''TFRepetitionPenaltyLogitsProcessor''',
     '''TFTemperatureLogitsWarper''',
     '''TFTopKLogitsWarper''',
     '''TFTopPLogitsWarper''',
     '''TFForceTokensLogitsProcessor''',
     '''TFSuppressTokensAtBeginLogitsProcessor''',
     '''TFSuppressTokensLogitsProcessor''',
 ]
 UpperCAmelCase      		=					[
     '''TFGenerationMixin''',
     '''tf_top_k_top_p_filtering''',
     '''TFGreedySearchDecoderOnlyOutput''',
     '''TFGreedySearchEncoderDecoderOutput''',
     '''TFSampleEncoderDecoderOutput''',
     '''TFSampleDecoderOnlyOutput''',
     '''TFBeamSearchEncoderDecoderOutput''',
     '''TFBeamSearchDecoderOnlyOutput''',
     '''TFBeamSampleEncoderDecoderOutput''',
     '''TFBeamSampleDecoderOnlyOutput''',
     '''TFContrastiveSearchEncoderDecoderOutput''',
     '''TFContrastiveSearchDecoderOnlyOutput''',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=					[
     '''FlaxForcedBOSTokenLogitsProcessor''',
     '''FlaxForcedEOSTokenLogitsProcessor''',
     '''FlaxLogitsProcessor''',
     '''FlaxLogitsProcessorList''',
     '''FlaxLogitsWarper''',
     '''FlaxMinLengthLogitsProcessor''',
     '''FlaxTemperatureLogitsWarper''',
     '''FlaxTopKLogitsWarper''',
     '''FlaxTopPLogitsWarper''',
 ]
 UpperCAmelCase      		=					[
     '''FlaxGenerationMixin''',
     '''FlaxGreedySearchOutput''',
     '''FlaxSampleOutput''',
     '''FlaxBeamSearchOutput''',
 ]

if TYPE_CHECKING:
 from .configuration_utils import GenerationConfig
 from .streamers import TextIteratorStreamer, TextStreamer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
  from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
  from .logits_process import (
      EncoderNoRepeatNGramLogitsProcessor,
      EncoderRepetitionPenaltyLogitsProcessor,
      EpsilonLogitsWarper,
      EtaLogitsWarper,
      ExponentialDecayLengthPenalty,
      ForcedBOSTokenLogitsProcessor,
      ForcedEOSTokenLogitsProcessor,
      HammingDiversityLogitsProcessor,
      InfNanRemoveLogitsProcessor,
      LogitNormalization,
      LogitsProcessor,
      LogitsProcessorList,
      LogitsWarper,
      MinLengthLogitsProcessor,
      MinNewTokensLengthLogitsProcessor,
      NoBadWordsLogitsProcessor,
      NoRepeatNGramLogitsProcessor,
      PrefixConstrainedLogitsProcessor,
      RepetitionPenaltyLogitsProcessor,
      SequenceBiasLogitsProcessor,
      TemperatureLogitsWarper,
      TopKLogitsWarper,
      TopPLogitsWarper,
      TypicalLogitsWarper,
  )
  from .stopping_criteria import (
      MaxLengthCriteria,
      MaxNewTokensCriteria,
      MaxTimeCriteria,
      StoppingCriteria,
      StoppingCriteriaList,
      validate_stopping_criteria,
  )
  from .utils import (
      BeamSampleDecoderOnlyOutput,
      BeamSampleEncoderDecoderOutput,
      BeamSearchDecoderOnlyOutput,
      BeamSearchEncoderDecoderOutput,
      ContrastiveSearchDecoderOnlyOutput,
      ContrastiveSearchEncoderDecoderOutput,
      GenerationMixin,
      GreedySearchDecoderOnlyOutput,
      GreedySearchEncoderDecoderOutput,
      SampleDecoderOnlyOutput,
      SampleEncoderDecoderOutput,
      top_k_top_p_filtering,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tf_logits_process import (
      TFForcedBOSTokenLogitsProcessor,
      TFForcedEOSTokenLogitsProcessor,
      TFForceTokensLogitsProcessor,
      TFLogitsProcessor,
      TFLogitsProcessorList,
      TFLogitsWarper,
      TFMinLengthLogitsProcessor,
      TFNoBadWordsLogitsProcessor,
      TFNoRepeatNGramLogitsProcessor,
      TFRepetitionPenaltyLogitsProcessor,
      TFSuppressTokensAtBeginLogitsProcessor,
      TFSuppressTokensLogitsProcessor,
      TFTemperatureLogitsWarper,
      TFTopKLogitsWarper,
      TFTopPLogitsWarper,
  )
  from .tf_utils import (
      TFBeamSampleDecoderOnlyOutput,
      TFBeamSampleEncoderDecoderOutput,
      TFBeamSearchDecoderOnlyOutput,
      TFBeamSearchEncoderDecoderOutput,
      TFContrastiveSearchDecoderOnlyOutput,
      TFContrastiveSearchEncoderDecoderOutput,
      TFGenerationMixin,
      TFGreedySearchDecoderOnlyOutput,
      TFGreedySearchEncoderDecoderOutput,
      TFSampleDecoderOnlyOutput,
      TFSampleEncoderDecoderOutput,
      tf_top_k_top_p_filtering,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .flax_logits_process import (
      FlaxForcedBOSTokenLogitsProcessor,
      FlaxForcedEOSTokenLogitsProcessor,
      FlaxLogitsProcessor,
      FlaxLogitsProcessorList,
      FlaxLogitsWarper,
      FlaxMinLengthLogitsProcessor,
      FlaxTemperatureLogitsWarper,
      FlaxTopKLogitsWarper,
      FlaxTopPLogitsWarper,
  )
  from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
 import sys

 UpperCAmelCase      		=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



