






import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
   import sqlitea

   import sqlalchemy


__A  							=  datasets.utils.logging.get_logger(__name__)



@dataclass
class 							_A (    datasets.BuilderConfig							):
    """simple docstring"""

    lowerCamelCase  :       Union[str, "sqlalchemy.sql.Selectable"]   =   None
    lowerCamelCase  :       Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]   =   None
    lowerCamelCase  :       Optional[Union[str, List[str]]]   =   None
    lowerCamelCase  :       bool   =   True
    lowerCamelCase  :       Optional[Union[List, Tuple, Dict]]   =   None
    lowerCamelCase  :       Optional[Union[List, Dict]]   =   None
    lowerCamelCase  :       Optional[List[str]]   =   None
    lowerCamelCase  :       Optional[int]   =   10_000
    lowerCamelCase  :       Optional[datasets.Features]   =   None



    def _a       (							self			:    List[str]			)			->       str:
           if self.sql is None:
                  raise ValueError("""sql must be specified"""			)
           if self.con is None:
                  raise ValueError("""con must be specified"""			)



    def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[datasets.Features] = None   ,    )			->       str:
           __UpperCAmelCase    							=config_kwargs.copy()
           # We need to stringify the Selectable object to make its hash deterministic

           # The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
           __UpperCAmelCase    							=config_kwargs["""sql"""]
           if not isinstance(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                  if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                         import sqlalchemy

                         if isinstance(__SCREAMING_SNAKE_CASE   ,    sqlalchemy.sql.Selectable			):
                                __UpperCAmelCase    							=sqlalchemy.create_engine(config_kwargs["""con"""].split("""://"""			)[0] + """://"""			)
                                __UpperCAmelCase    							=str(sql.compile(dialect=engine.dialect			)			)
                                __UpperCAmelCase    							=sql_str
                         else:
                                raise TypeError(
                                    f'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(__SCREAMING_SNAKE_CASE			)}: {sql}'''			)
                  else:
                         raise TypeError(
                             f'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(__SCREAMING_SNAKE_CASE			)}: {sql}'''			)
           __UpperCAmelCase    							=config_kwargs["""con"""]
           if not isinstance(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                  __UpperCAmelCase    							=id(__SCREAMING_SNAKE_CASE			)
                  logger.info(
                      f'''SQL connection \'con\' of type {type(__SCREAMING_SNAKE_CASE			)} couldn\'t be hashed properly. To enable hashing, specify \'con\' as URI string instead.'''			)

           return super().create_config_id(__SCREAMING_SNAKE_CASE   ,    custom_features=__SCREAMING_SNAKE_CASE			)



    @property
    def _a       (							self			:    Optional[int]			)			->       Union[str, Any]:
           __UpperCAmelCase    							={
               """index_col""": self.index_col,
               """columns""": self.columns,
               """params""": self.params,
               """coerce_float""": self.coerce_float,
               """parse_dates""": self.parse_dates,
           }
           return pd_read_sql_kwargs




class 							_A (    datasets.ArrowBasedBuilder							):
    """simple docstring"""

    lowerCamelCase  :       Optional[int]   =   SqlConfig



    def _a       (							self			:    int			)			->       int:
           return datasets.DatasetInfo(features=self.config.features			)



    def _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    Any			)			->       Tuple:
           return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,    gen_kwargs={}			)]



    def _a       (							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    pa.Table			)			->       pa.Table:
           if self.config.features is not None:
                  __UpperCAmelCase    							=self.config.features.arrow_schema
                  if all(not require_storage_cast(__SCREAMING_SNAKE_CASE			) for feature in self.config.features.values()			):
                         # cheaper cast
                         __UpperCAmelCase    							=pa.Table.from_arrays([pa_table[field.name] for field in schema]   ,    schema=__SCREAMING_SNAKE_CASE			)
                  else:
                         # more expensive cast; allows str <-> int/float or str to Audio for example
                         __UpperCAmelCase    							=table_cast(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
           return pa_table



    def _a       (							self			:    str			)			->       List[str]:
           __UpperCAmelCase    							=self.config.chunksize
           __UpperCAmelCase    							=pd.read_sql(
               self.config.sql   ,    self.config.con   ,    chunksize=__SCREAMING_SNAKE_CASE   ,    **self.config.pd_read_sql_kwargs			)
           __UpperCAmelCase    							=[sql_reader] if chunksize is None else sql_reader
           for chunk_idx, df in enumerate(__SCREAMING_SNAKE_CASE			):
                  __UpperCAmelCase    							=pa.Table.from_pandas(__SCREAMING_SNAKE_CASE			)
                  yield chunk_idx, self._cast_table(__SCREAMING_SNAKE_CASE			)












import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest



class 							_A (    UpperCamelCase							):
    """simple docstring"""

    lowerCamelCase  :       str   =   (DPMSolverMultistepScheduler,)
    lowerCamelCase  :       List[str]   =   (('num_inference_steps', 25),)



    def _a       (							self			:    Dict   ,    **__SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       Dict:
           __UpperCAmelCase    							={
               """num_train_timesteps""": 1000,
               """beta_start""": 0.0_001,
               """beta_end""": 0.02,
               """beta_schedule""": """linear""",
               """solver_order""": 2,
               """prediction_type""": """epsilon""",
               """thresholding""": False,
               """sample_max_value""": 1.0,
               """algorithm_type""": """dpmsolver++""",
               """solver_type""": """midpoint""",
               """lower_order_final""": False,
               """lambda_min_clipped""": -float("""inf"""			),
               """variance_type""": None,
           }

           config.update(**__SCREAMING_SNAKE_CASE			)
           return config



    def _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=0   ,    **__SCREAMING_SNAKE_CASE			:    int			)			->       Dict:
           __UpperCAmelCase    							=dict(self.forward_default_kwargs			)
           __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)
           __UpperCAmelCase    							=self.dummy_sample
           __UpperCAmelCase    							=0.1 * sample
           __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]

           for scheduler_class in self.scheduler_classes:
                  __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                  __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
                  scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                  # copy over dummy past residuals
                  __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]

                  with tempfile.TemporaryDirectory() as tmpdirname:
                         scheduler.save_config(__SCREAMING_SNAKE_CASE			)
                         __UpperCAmelCase    							=scheduler_class.from_pretrained(__SCREAMING_SNAKE_CASE			)
                         new_scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                         # copy over dummy past residuals
                         __UpperCAmelCase    							=dummy_past_residuals[: new_scheduler.config.solver_order]

                  __UpperCAmelCase							,   __UpperCAmelCase    							=sample, sample
                  for t in range(__SCREAMING_SNAKE_CASE   ,    time_step + scheduler.config.solver_order + 1			):
                         __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                         __UpperCAmelCase    							=new_scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample

                         assert torch.sum(torch.abs(output - new_output			)			) < 1e-5, "Scheduler outputs are not identical"



    def _a       (							self			:    Any			)			->       Union[str, Any]:
           pass



    def _a       (							self			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    List[str]=0   ,    **__SCREAMING_SNAKE_CASE			:    Dict			)			->       Optional[Any]:
           __UpperCAmelCase    							=dict(self.forward_default_kwargs			)
           __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)
           __UpperCAmelCase    							=self.dummy_sample
           __UpperCAmelCase    							=0.1 * sample
           __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]

           for scheduler_class in self.scheduler_classes:
                  __UpperCAmelCase    							=self.get_scheduler_config()
                  __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
                  scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)

                  # copy over dummy past residuals (must be after setting timesteps)
                  __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]

                  with tempfile.TemporaryDirectory() as tmpdirname:
                         scheduler.save_config(__SCREAMING_SNAKE_CASE			)
                         __UpperCAmelCase    							=scheduler_class.from_pretrained(__SCREAMING_SNAKE_CASE			)
                         # copy over dummy past residuals
                         new_scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)

                         # copy over dummy past residual (must be after setting timesteps)
                         __UpperCAmelCase    							=dummy_past_residuals[: new_scheduler.config.solver_order]

                  __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                  __UpperCAmelCase    							=new_scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample

                  assert torch.sum(torch.abs(output - new_output			)			) < 1e-5, "Scheduler outputs are not identical"



    def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]=None   ,    **__SCREAMING_SNAKE_CASE			:    Optional[int]			)			->       Optional[Any]:
           if scheduler is None:
                  __UpperCAmelCase    							=self.scheduler_classes[0]
                  __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                  __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)

           __UpperCAmelCase    							=10
           __UpperCAmelCase    							=self.dummy_model()
           __UpperCAmelCase    							=self.dummy_sample_deter
           scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)

           for i, t in enumerate(scheduler.timesteps			):
                  __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
                  __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).prev_sample

           return sample



    def _a       (							self			:    Dict			)			->       Optional[int]:
           __UpperCAmelCase    							=dict(self.forward_default_kwargs			)

           __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)

           for scheduler_class in self.scheduler_classes:
                  __UpperCAmelCase    							=self.get_scheduler_config()
                  __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)

                  __UpperCAmelCase    							=self.dummy_sample
                  __UpperCAmelCase    							=0.1 * sample

                  if num_inference_steps is not None and hasattr(__SCREAMING_SNAKE_CASE   ,    """set_timesteps"""			):
                         scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                  elif num_inference_steps is not None and not hasattr(__SCREAMING_SNAKE_CASE   ,    """set_timesteps"""			):
                         __UpperCAmelCase    							=num_inference_steps

                  # copy over dummy past residuals (must be done after set_timesteps)
                  __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]
                  __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]

                  __UpperCAmelCase    							=scheduler.timesteps[5]
                  __UpperCAmelCase    							=scheduler.timesteps[6]

                  __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                  __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample

                  self.assertEqual(output_a.shape   ,    sample.shape			)
                  self.assertEqual(output_a.shape   ,    output_a.shape			)



    def _a       (							self			:    List[Any]			)			->       Tuple:
           for timesteps in [25, 50, 100, 999, 1000]:
                  self.check_over_configs(num_train_timesteps=__SCREAMING_SNAKE_CASE			)



    def _a       (							self			:    Union[str, Any]			)			->       int:
           self.check_over_configs(thresholding=__SCREAMING_SNAKE_CASE			)
           for order in [1, 2, 3]:
                  for solver_type in ["midpoint", "heun"]:
                         for threshold in [0.5, 1.0, 2.0]:
                                for prediction_type in ["epsilon", "sample"]:
                                       self.check_over_configs(
                                           thresholding=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    sample_max_value=__SCREAMING_SNAKE_CASE   ,    algorithm_type="""dpmsolver++"""   ,    solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    )



    def _a       (							self			:    Union[str, Any]			)			->       List[str]:
           for prediction_type in ["epsilon", "v_prediction"]:
                  self.check_over_configs(prediction_type=__SCREAMING_SNAKE_CASE			)



    def _a       (							self			:    Union[str, Any]			)			->       Tuple:
           for algorithm_type in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]:
                  for solver_type in ["midpoint", "heun"]:
                         for order in [1, 2, 3]:
                                for prediction_type in ["epsilon", "sample"]:
                                       if algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]:
                                              if order == 3:
                                                     continue
                                       else:
                                              self.check_over_configs(
                                                  solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    algorithm_type=__SCREAMING_SNAKE_CASE   ,    )
                                       __UpperCAmelCase    							=self.full_loop(
                                           solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    algorithm_type=__SCREAMING_SNAKE_CASE   ,    )
                                       assert not torch.isnan(__SCREAMING_SNAKE_CASE			).any(), "Samples have nan numbers"



    def _a       (							self			:    Dict			)			->       str:
           self.check_over_configs(lower_order_final=__SCREAMING_SNAKE_CASE			)
           self.check_over_configs(lower_order_final=__SCREAMING_SNAKE_CASE			)



    def _a       (							self			:    Union[str, Any]			)			->       Optional[Any]:
           self.check_over_configs(lambda_min_clipped=-float("""inf"""			)			)
           self.check_over_configs(lambda_min_clipped=-5.1			)



    def _a       (							self			:    Any			)			->       List[str]:
           self.check_over_configs(variance_type=__SCREAMING_SNAKE_CASE			)
           self.check_over_configs(variance_type="""learned_range"""			)



    def _a       (							self			:    List[Any]			)			->       int:
           for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
                  self.check_over_forward(num_inference_steps=__SCREAMING_SNAKE_CASE   ,    time_step=0			)



    def _a       (							self			:    Optional[int]			)			->       str:
           __UpperCAmelCase    							=self.full_loop()
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 0.3_301			) < 1e-3



    def _a       (							self			:    Union[str, Any]			)			->       str:
           __UpperCAmelCase    							=self.full_loop(thresholding=__SCREAMING_SNAKE_CASE   ,    dynamic_thresholding_ratio=0.87   ,    sample_max_value=0.5			)
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 1.1_364			) < 1e-3



    def _a       (							self			:    List[Any]			)			->       List[Any]:
           __UpperCAmelCase    							=self.full_loop(prediction_type="""v_prediction"""			)
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 0.2_251			) < 1e-3



    def _a       (							self			:    int			)			->       Union[str, Any]:
           __UpperCAmelCase    							=self.full_loop(prediction_type="""v_prediction"""   ,    use_karras_sigmas=__SCREAMING_SNAKE_CASE			)
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 0.2_096			) < 1e-3



    def _a       (							self			:    int			)			->       Optional[Any]:
           # make sure that iterating over schedulers with same config names gives same results
           # for defaults
           __UpperCAmelCase    							=DPMSolverMultistepScheduler(**self.get_scheduler_config()			)
           __UpperCAmelCase    							=self.full_loop(scheduler=__SCREAMING_SNAKE_CASE			)
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 0.3_301			) < 1e-3

           __UpperCAmelCase    							=DPMSolverSinglestepScheduler.from_config(scheduler.config			)
           __UpperCAmelCase    							=UniPCMultistepScheduler.from_config(scheduler.config			)
           __UpperCAmelCase    							=DEISMultistepScheduler.from_config(scheduler.config			)
           __UpperCAmelCase    							=DPMSolverMultistepScheduler.from_config(scheduler.config			)

           __UpperCAmelCase    							=self.full_loop(scheduler=__SCREAMING_SNAKE_CASE			)
           __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)

           assert abs(result_mean.item() - 0.3_301			) < 1e-3



    def _a       (							self			:    List[Any]			)			->       str:
           __UpperCAmelCase    							=self.scheduler_classes[0]
           __UpperCAmelCase    							=self.get_scheduler_config(thresholding=__SCREAMING_SNAKE_CASE   ,    dynamic_thresholding_ratio=0			)
           __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)

           __UpperCAmelCase    							=10
           __UpperCAmelCase    							=self.dummy_model()
           __UpperCAmelCase    							=self.dummy_sample_deter.half()
           scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)

           for i, t in enumerate(scheduler.timesteps			):
                  __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
                  __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).prev_sample

           assert sample.dtype == torch.floataa



    def _a       (							self			:    Optional[int]   ,    **__SCREAMING_SNAKE_CASE			:    Tuple			)			->       Optional[int]:
           for scheduler_class in self.scheduler_classes:
                  __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                  __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)

                  scheduler.set_timesteps(scheduler.config.num_train_timesteps			)
                  assert len(scheduler.timesteps.unique()			) == scheduler.num_inference_steps




