



"""simple docstring"""




# limitations under the License.

# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works

from .pipelines import DiffusionPipeline, ImagePipelineOutput  # noqa: F401
from .utils import deprecate


deprecate(
    "pipelines_utils",
    "0.22.0",
    "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.",
    standard_warn=False,
    stacklevel=3,
)





"""simple docstring"""




# We ignore warnings about stepping the scheduler since we step it ourselves during gradient accumulation

import warnings

from .state import AcceleratorState, GradientState


warnings.filterwarnings("ignore", category=UserWarning, module="torch.optim.lr_scheduler")






class       UpperCAmelCase_    :



      def __init__(	self	:      Optional[Any]	,      A	:      List[str]	,      A	:      List[str]	,      A	:      bool = True	,      A	:      bool = False		):
           _UpperCAmelCase     :      Dict														=       scheduler
           _UpperCAmelCase     :      str														=       optimizers if isinstance(A	,      (list, tuple)		) else [optimizers]
           _UpperCAmelCase     :      List[str]														=       split_batches
           _UpperCAmelCase     :      Dict														=       step_with_optimizer
           _UpperCAmelCase     :      Tuple														=       GradientState()



      def 		snake_case_   (	self	:      Optional[int]	,      *A	:      List[Any]	,      **A	:      Optional[int]		):
           if not self.step_with_optimizer:
                # No link between scheduler and optimizer -> just step
                self.scheduler.step(*A	,      **A		)
                return

           # Otherwise, first make sure the optimizer was stepped.
           if not self.gradient_state.sync_gradients:
                if self.gradient_state.adjust_scheduler:
                     self.scheduler._step_count += 1
                return

           for opt in self.optimizers:
                if opt.step_was_skipped:
                     return
           if self.split_batches:
                # Split batches -> the training dataloader batch size is not changed so one step per training step
                self.scheduler.step(*A	,      **A		)
           else:
                # Otherwise the training dataloader batch size was multiplied by `num_processes`, so we need to do
                # num_processes steps per training step
                _UpperCAmelCase     :      int														=       AcceleratorState().num_processes
                for _ in range(A		):
                     # Special case when using OneCycle and `drop_last` was not used
                     if hasattr(self.scheduler	,      "total_steps"		):
                          if self.scheduler._step_count <= self.scheduler.total_steps:
                               self.scheduler.step(*A	,      **A		)
                     else:
                          self.scheduler.step(*A	,      **A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           return self.scheduler.get_last_lr()



      def 		snake_case_   (	self	:      str		):
           return self.scheduler.state_dict()



      def 		snake_case_   (	self	:      str	,      A	:      Optional[Any]		):
           self.scheduler.load_state_dict(A		)



      def 		snake_case_   (	self	:      Tuple		):
           return self.scheduler.get_lr()



      def 		snake_case_   (	self	:      Optional[int]	,      *A	:      List[str]	,      **A	:      Optional[Any]		):
           return self.scheduler.print_lr(*A	,      **A		)
