





'''simple docstring'''




from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
)


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_pt_objects import *  # noqa F403
else:
  from .scheduling_consistency_models import CMStochasticIterativeScheduler
  from .scheduling_ddim import DDIMScheduler
  from .scheduling_ddim_inverse import DDIMInverseScheduler
  from .scheduling_ddim_parallel import DDIMParallelScheduler
  from .scheduling_ddpm import DDPMScheduler
  from .scheduling_ddpm_parallel import DDPMParallelScheduler
  from .scheduling_deis_multistep import DEISMultistepScheduler
  from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler
  from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler
  from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler
  from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler
  from .scheduling_euler_discrete import EulerDiscreteScheduler
  from .scheduling_heun_discrete import HeunDiscreteScheduler
  from .scheduling_ipndm import IPNDMScheduler
  from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler
  from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler
  from .scheduling_karras_ve import KarrasVeScheduler
  from .scheduling_pndm import PNDMScheduler
  from .scheduling_repaint import RePaintScheduler
  from .scheduling_sde_ve import ScoreSdeVeScheduler
  from .scheduling_sde_vp import ScoreSdeVpScheduler
  from .scheduling_unclip import UnCLIPScheduler
  from .scheduling_unipc_multistep import UniPCMultistepScheduler
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
  from .scheduling_vq_diffusion import VQDiffusionScheduler

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_flax_objects import *  # noqa F403
else:
  from .scheduling_ddim_flax import FlaxDDIMScheduler
  from .scheduling_ddpm_flax import FlaxDDPMScheduler
  from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler
  from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler
  from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler
  from .scheduling_pndm_flax import FlaxPNDMScheduler
  from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler
  from .scheduling_utils_flax import (
      FlaxKarrasDiffusionSchedulers,
      FlaxSchedulerMixin,
      FlaxSchedulerOutput,
      broadcast_to_shape_from_left,
  )


try:
  if not (is_torch_available() and is_scipy_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
  from .scheduling_lms_discrete import LMSDiscreteScheduler

try:
  if not (is_torch_available() and is_torchsde_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
  from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler






"""simple docstring"""





import pytest

from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs



@pytest.mark.parametrize(
    """kwargs, expected"""  ,				[
        ({"""num_shards""": 0, """max_num_jobs""": 1}, []),
        ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10				)]),
        ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(UpperCamelCase_  ,				i + 1				) for i in range(10				)]),
        ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1				)]),
        ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0  ,				4				), range(4  ,				7				), range(7  ,				10				)]),
        ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0  ,				1				), range(1  ,				2				), range(2  ,				3				)]),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = _distribute_shards(**UpperCamelCase_				)
		assert out == expected



@pytest.mark.parametrize(
    """gen_kwargs, max_num_jobs, expected"""  ,				[
        ({"""foo""": 0}, 10, [{"""foo""": 0}]),
        ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]),
        ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]),
        ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]),
        ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = _split_gen_kwargs(UpperCamelCase_  ,				UpperCamelCase_				)
		assert out == expected



@pytest.mark.parametrize(
    """gen_kwargs, expected"""  ,				[
        ({"""foo""": 0}, 1),
        ({"""shards""": [0]}, 1),
        ({"""shards""": [0, 1, 2, 3]}, 4),
        ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4),
        ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4),
        ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError),
    ]  ,				)
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_				):
		if expected is RuntimeError:
				with pytest.raises(UpperCamelCase_				):
						_number_of_shards_in_gen_kwargs(UpperCamelCase_				)
		else:
				__SCREAMING_SNAKE_CASE            = _number_of_shards_in_gen_kwargs(UpperCamelCase_				)
				assert out == expected




