






"""simple docstring"""







from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available







@dataclass
class 					lowerCamelCase__					(       _lowerCamelCase ):
    SCREAMING_SNAKE_CASE		=			{
        '''sld_warmup_steps''': 15,
        '''sld_guidance_scale''': 20,
        '''sld_threshold''': 0.0,
        '''sld_momentum_scale''': 0.0,
        '''sld_mom_beta''': 0.0,
    }
    SCREAMING_SNAKE_CASE		=			{
        '''sld_warmup_steps''': 10,
        '''sld_guidance_scale''': 1_000,
        '''sld_threshold''': 0.01,
        '''sld_momentum_scale''': 0.3,
        '''sld_mom_beta''': 0.4,
    }
    SCREAMING_SNAKE_CASE		=			{
        '''sld_warmup_steps''': 7,
        '''sld_guidance_scale''': 2_000,
        '''sld_threshold''': 0.0_25,
        '''sld_momentum_scale''': 0.5,
        '''sld_mom_beta''': 0.7,
    }
    SCREAMING_SNAKE_CASE		=			{
        '''sld_warmup_steps''': 0,
        '''sld_guidance_scale''': 5_000,
        '''sld_threshold''': 1.0,
        '''sld_momentum_scale''': 0.5,
        '''sld_mom_beta''': 0.7,
    }







@dataclass
class 					lowerCamelCase__					(       _lowerCamelCase ):
    SCREAMING_SNAKE_CASE		=			42
    SCREAMING_SNAKE_CASE		=			42
    SCREAMING_SNAKE_CASE		=			42
    SCREAMING_SNAKE_CASE		=			42


if is_transformers_available() and is_torch_available():
  from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
  from .safety_checker import SafeStableDiffusionSafetyChecker





'''simple docstring'''



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


UpperCamelCase__					:						Tuple											=     datasets.utils.logging.get_logger(__name__)

@dataclass
class       _a (datasets.BuilderConfig):





       """simple docstring"""




       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     True
       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     None
       SCREAMING_SNAKE_CASE					=     1_00_00
       SCREAMING_SNAKE_CASE					=     None






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






       def 				UpperCamelCase (							self				,							A__				,							A__ = None				,							)			->	str:
          _SCREAMING_SNAKE_CASE          = 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
          _SCREAMING_SNAKE_CASE          = config_kwargs["""sql"""]
          if not isinstance(A__				,							A__					):
             if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                import sqlalchemy

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

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






       @property
       def 				UpperCamelCase (							self					)			->	Any:
          _SCREAMING_SNAKE_CASE          = {
              """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"""




       SCREAMING_SNAKE_CASE					=     SqlConfig






       def 				UpperCamelCase (							self					)			->	Optional[Any]:
          return datasets.DatasetInfo(features=self.config.features					)






       def 				UpperCamelCase (							self				,							A__					)			->	Dict:
          return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,							gen_kwargs={}					)]






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






       def 				UpperCamelCase (							self					)			->	Optional[int]:
          _SCREAMING_SNAKE_CASE          = self.config.chunksize
          _SCREAMING_SNAKE_CASE          = pd.read_sql(
              self.config.sql				,							self.config.con				,							chunksize=A__				,							**self.config.pd_read_sql_kwargs					)
          _SCREAMING_SNAKE_CASE          = [sql_reader] if chunksize is None else sql_reader
          for chunk_idx, df in enumerate(A__					):
             _SCREAMING_SNAKE_CASE          = pa.Table.from_pandas(A__					)
             yield chunk_idx, self._cast_table(A__					)






