






"""simple docstring"""


import tempfile
import unittest

from diffusers import (
    DDIMScheduler,
    DDPMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    PNDMScheduler,
    logging,
)
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils.testing_utils import CaptureLogger






class 		snake_case    (    UpperCAmelCase			):
    __magic_name__       	=	'''config.json'''





    @register_to_config
    def __init__(				self      :   Optional[Any]							,						A      :   Union[str, Any]=2							,						A      :   int=5							,						A      :   Union[str, Any]=(2, 5)							,						A      :   List[Any]="for diffusion"							,						A      :   List[Any]=[1, 3]							,						):


      '''simple docstring'''




      pass






class 		snake_case    (    UpperCAmelCase			):
    __magic_name__       	=	'''config.json'''





    @register_to_config
    def __init__(				self      :   Tuple							,						A      :   Optional[int]=2							,						A      :   int=5							,						A      :   Optional[int]=(2, 5)							,						A      :   int="for diffusion"							,						A      :   str=[1, 3]							,						):


      '''simple docstring'''




      pass






class 		snake_case    (    UpperCAmelCase			):
    __magic_name__       	=	'''config.json'''





    @register_to_config
    def __init__(				self      :   Tuple							,						A      :   Dict=2							,						A      :   Tuple=5							,						A      :   str=(2, 5)							,						A      :   int="for diffusion"							,						A      :   Tuple=[1, 3]							,						A      :   Any=[1, 3]							,						):


      '''simple docstring'''




      pass






class 		snake_case    (    UpperCAmelCase			):
    __magic_name__       	=	'''config.json'''





    @register_to_config
    def __init__(				self      :   Optional[int]							,						A      :   Dict=2							,						A      :   List[str]=5							,						A      :   Optional[Any]=(2, 5)							,						A      :   Optional[int]="for diffusion"							,						A      :   Any=[1, 5]							,						A      :   str=[5, 4]							,						):


      '''simple docstring'''




      pass






class 		snake_case    (    unittest.TestCase			):





    def 							lowerCamelCase__ (				self      :   Tuple     ):


      '''simple docstring'''




      with self.assertRaises(A     ):
        ConfigMixin.load_config('dummy_path'     )





    def 							lowerCamelCase__ (				self      :   int     ):


      '''simple docstring'''




      a	:     Union[str, Any]							=  SampleObject()
      a	:     Dict							=  obj.config
      assert config["a"] == 2
      assert config["b"] == 5
      assert config["c"] == (2, 5)
      assert config["d"] == "for diffusion"
      assert config["e"] == [1, 3]

      # init ignore private arguments
      a	:     Union[str, Any]							=  SampleObject(_name_or_path='lalala'     )
      a	:     Optional[int]							=  obj.config
      assert config["a"] == 2
      assert config["b"] == 5
      assert config["c"] == (2, 5)
      assert config["d"] == "for diffusion"
      assert config["e"] == [1, 3]

      # can override default
      a	:     Optional[int]							=  SampleObject(c=6     )
      a	:     int							=  obj.config
      assert config["a"] == 2
      assert config["b"] == 5
      assert config["c"] == 6
      assert config["d"] == "for diffusion"
      assert config["e"] == [1, 3]

      # can use positional arguments.
      a	:     List[Any]							=  SampleObject(1							,						c=6     )
      a	:     Optional[int]							=  obj.config
      assert config["a"] == 1
      assert config["b"] == 5
      assert config["c"] == 6
      assert config["d"] == "for diffusion"
      assert config["e"] == [1, 3]





    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Dict							=  SampleObject()
      a	:     Optional[int]							=  obj.config

      assert config["a"] == 2
      assert config["b"] == 5
      assert config["c"] == (2, 5)
      assert config["d"] == "for diffusion"
      assert config["e"] == [1, 3]

      with tempfile.TemporaryDirectory() as tmpdirname:
        obj.save_config(A     )
        a	:     str							=  SampleObject.from_config(SampleObject.load_config(A     )     )
        a	:     Any							=  new_obj.config

      # unfreeze configs
      a	:     int							=  dict(A     )
      a	:     Dict							=  dict(A     )

      assert config.pop('c'     ) == (2, 5)  # instantiated as tuple
      assert new_config.pop('c'     ) == [2, 5]  # saved & loaded as list because of json
      config.pop('_use_default_values'     )
      assert config == new_config





    def 							lowerCamelCase__ (				self      :   int     ):


      '''simple docstring'''




      a	:     Optional[int]							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     Dict							=  DDIMScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'     )

      assert ddim.__class__ == DDIMScheduler
      # no warning should be thrown
      assert cap_logger.out == ""





    def 							lowerCamelCase__ (				self      :   int     ):


      '''simple docstring'''




      a	:     List[str]							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     Dict							=  EulerDiscreteScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'     )

      assert euler.__class__ == EulerDiscreteScheduler
      # no warning should be thrown
      assert cap_logger.out == ""





    def 							lowerCamelCase__ (				self      :   Optional[Any]     ):


      '''simple docstring'''




      a	:     Tuple							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     Any							=  EulerAncestralDiscreteScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'     )

      assert euler.__class__ == EulerAncestralDiscreteScheduler
      # no warning should be thrown
      assert cap_logger.out == ""





    def 							lowerCamelCase__ (				self      :   Optional[Any]     ):


      '''simple docstring'''




      a	:     Any							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     List[str]							=  PNDMScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'     )

      assert pndm.__class__ == PNDMScheduler
      # no warning should be thrown
      assert cap_logger.out == ""





    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Tuple							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     Any							=  DDPMScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'							,						prediction_type='sample'							,						beta_end=8							,						)

      with CaptureLogger(A     ) as cap_logger_a:
        a	:     List[Any]							=  DDPMScheduler.from_pretrained('google/ddpm-celebahq-256'							,						beta_start=8_8     )

      assert ddpm.__class__ == DDPMScheduler
      assert ddpm.config.prediction_type == "sample"
      assert ddpm.config.beta_end == 8
      assert ddpm_a.config.beta_start == 8_8

      # no warning should be thrown
      assert cap_logger.out == ""
      assert cap_logger_a.out == ""





    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Tuple							=  logging.get_logger('diffusers.configuration_utils'     )
      # 30 for warning
      logger.setLevel(3_0     )

      with CaptureLogger(A     ) as cap_logger:
        a	:     Tuple							=  DPMSolverMultistepScheduler.from_pretrained(
            'hf-internal-testing/tiny-stable-diffusion-torch'							,						subfolder='scheduler'     )

      assert dpm.__class__ == DPMSolverMultistepScheduler
      # no warning should be thrown
      assert cap_logger.out == ""





    def 							lowerCamelCase__ (				self      :   Union[str, Any]     ):


      '''simple docstring'''




      a	:     int							=  SampleObject()

      a	:     int							=  {k: v for k, v in config.config.items() if not k.startswith('_'     )}

      # make sure that default config has all keys in `_use_default_values`
      assert set(config_dict.keys()     ) == set(config.config._use_default_values     )

      with tempfile.TemporaryDirectory() as tmpdirname:
        config.save_config(A     )

        # now loading it with SampleObject2 should put f into `_use_default_values`
        a	:     str							=  SampleObjecta.from_config(A     )

        assert "f" in config._use_default_values
        assert config.f == [1, 3]

      # now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
      # **BECAUSE** it is part of `config._use_default_values`
      a	:     str							=  SampleObjecta.from_config(config.config     )
      assert new_config.f == [5, 4]

      config.config._use_default_values.pop()
      a	:     List[Any]							=  SampleObjecta.from_config(config.config     )
      assert new_config_a.f == [1, 3]

      # Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
      assert new_config_a.e == [1, 3]












"""simple docstring"""


from doctest import testmod
from math import sqrt




def      snake_case    (A_ :int ):







  '''simple docstring'''

  a	:     list[int]							=  []
  if num < 1:
    return facs
  facs.append(1 )
  if num == 1:
    return facs
  facs.append(A_ )
  for i in range(2      ,     int(sqrt(A_ ) ) + 1 ):
    if num % i == 0:  # If i is a factor of num
      facs.append(A_ )
      a	:     Optional[Any]							=  num // i  # num//i is the other factor of num
      if d != i:  # If d and i are distinct
        facs.append(A_ )  # we have found another factor
  facs.sort()
  return facs


if __name__ == "__main__":
   testmod(name='factors_of_a_number', verbose=True)




