





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 		_lowerCAmelCase(		datasets.BuilderConfig):

  """simple docstring"""







  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       True
  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       None
  lowerCamelCase__     	=       1_00_00
  lowerCamelCase__     	=       None

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:




     if self.sql is None:
        raise ValueError('''sql must be specified'''      )
     if self.con is None:
        raise ValueError('''con must be specified'''      )

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

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

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





  @property
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     __A    =  {
         '''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 		_lowerCAmelCase(		datasets.ArrowBasedBuilder):

  """simple docstring"""







  lowerCamelCase__     	=       SqlConfig

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

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Union[str, Any]:
     return [datasets.SplitGenerator(name=datasets.Split.TRAIN    ,							gen_kwargs={}      )]

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   pa.Table:




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





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









'''simple docstring'''





def  lowerCamelCase_  (     lowercase__):
 return int(lowercase__) if x - int(lowercase__) <= 0 else int(lowercase__) + 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()

