'''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				:		List[Any]       			=		datasets.utils.logging.get_logger(__name__)

@dataclass
class   _lowercase(     datasets.BuilderConfig				):



   """simple docstring"""





   __lowerCamelCase    =  None
   __lowerCamelCase    =  None
   __lowerCamelCase    =  None
   __lowerCamelCase    =  True
   __lowerCamelCase    =  None
   __lowerCamelCase    =  None
   __lowerCamelCase    =  None
   __lowerCamelCase    =  10000
   __lowerCamelCase    =  None





   def 			snake_case	(							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 			snake_case	(							self:    Any			,a:    dict			,a:    Optional[datasets.Features] = None			,):
    __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(a			,a	):
     if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
      import sqlalchemy

      if isinstance(a			,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(a	)}: {sql}"""	)
     else:
      raise TypeError(
          f"""Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(a	)}: {sql}"""	)
    __UpperCAmelCase         =					config_kwargs['con']
    if not isinstance(a			,a	):
     __UpperCAmelCase         =					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 			snake_case	(							self:    Tuple	):
    __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   _lowercase(     datasets.ArrowBasedBuilder				):



   """simple docstring"""





   __lowerCamelCase    =  SqlConfig





   def 			snake_case	(							self:    List[str]	):
    return datasets.DatasetInfo(features=self.config.features	)





   def 			snake_case	(							self:    int			,a:    Optional[Any]	):
    return [datasets.SplitGenerator(name=datasets.Split.TRAIN			,gen_kwargs={}	)]





   def 			snake_case	(							self:    Optional[Any]			,a:    pa.Table	):
    if self.config.features is not None:
     __UpperCAmelCase         =					self.config.features.arrow_schema
     if all(not require_storage_cast(a	) for feature in self.config.features.values()	):
      # cheaper cast
      __UpperCAmelCase         =					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
      __UpperCAmelCase         =					table_cast(a			,a	)
    return pa_table





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




'''simple docstring'''




import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
     from .testing_utils import (
         floats_tensor,
         load_hf_numpy,
         load_image,
         load_numpy,
         load_pt,
         nightly,
         parse_flag_from_env,
         print_tensor_test,
         require_torch_a,
         require_torch_gpu,
         skip_mps,
         slow,
         torch_all_close,
         torch_device,
     )
     from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


_UpperCamelCase				:		List[Any]       			=		get_logger(__name__)



def 						__snake_case (       lowerCAmelCase       :     List[str]			):
 if version.parse(lowerCAmelCase			) < version.parse(lowerCAmelCase			):
  if "dev" in min_version:
   __UpperCAmelCase         =					(
       'This example requires a source install from HuggingFace diffusers (see '
       '`https://huggingface.co/docs/diffusers/installation#install-from-source`),'
   )
  else:
   __UpperCAmelCase         =					F"""This example requires a minimum version of {min_version},"""
  error_message += F""" but the version found is {__version__}.\n"""
  raise ImportError(lowerCAmelCase			)



