






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


@dataclass
class  __lowercase (		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 						lowerCAmelCase_       (			self    :     List[str]			):


         """simple docstring"""



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




     def 						lowerCAmelCase_       (			self    :     str	,		UpperCamelCase_    :     Tuple	,		UpperCamelCase_    :     int = None	,		):


         """simple docstring"""



         __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(lowercase__	,		lowercase__			):
             if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                 import sqlalchemy

                 if isinstance(lowercase__	,		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(lowercase__			)}: {sql}"			)
             else:
                 raise TypeError(
                     F"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(lowercase__			)}: {sql}"			)
         __A             =		config_kwargs["con"]
         if not isinstance(lowercase__	,		lowercase__			):
             __A             =		id(lowercase__			)
             logger.info(
                 F"SQL connection 'con' of type {type(lowercase__			)} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."			)

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





     @property
     def 						lowerCAmelCase_       (			self    :     Optional[int]			):


         """simple docstring"""



         __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  __lowercase (		datasets.ArrowBasedBuilder					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			SqlConfig




     def 						lowerCAmelCase_       (			self    :     Optional[int]			):


         """simple docstring"""



         return datasets.DatasetInfo(features=self.config.features			)




     def 						lowerCAmelCase_       (			self    :     Any	,		UpperCamelCase_    :     Optional[int]			):


         """simple docstring"""



         return [datasets.SplitGenerator(name=datasets.Split.TRAIN	,		gen_kwargs={}			)]




     def 						lowerCAmelCase_       (			self    :     List[Any]	,		UpperCamelCase_    :     Tuple			):


         """simple docstring"""



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





     def 						lowerCAmelCase_       (			self    :     Dict			):


         """simple docstring"""



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












import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


__a :    List[str]								=				get_logger(__name__)


if TYPE_CHECKING:
  from .builder import DatasetBuilder



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     Dict     ,			__lowercase				:     Optional[Union[str, bool]] = None      )  -> List[str]:





    """simple docstring"""

    __A             =		importlib.import_module(__lowercase      )

    # TODO(QL): always update the module to add subsequent new authentication
    if hasattr(__lowercase     ,			"""_patched_for_streaming"""      ) and module._patched_for_streaming:
        return

    def wrap_auth(__lowercase				:     int      ):
        @wraps(__lowercase      )
        def wrapper(*__lowercase				:     Tuple     ,			**__lowercase				:     List[str]      ):
            return function(*__lowercase     ,			use_auth_token=__lowercase     ,			**__lowercase      )

        __A             =		"""wrap_auth"""
        return wrapper

    # open files in a streaming fashion
    patch_submodule(__lowercase     ,			"""open"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""os.listdir"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""os.walk"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""glob.glob"""     ,			wrap_auth(__lowercase      )      ).start()
    # allow to navigate in remote zip files
    patch_submodule(__lowercase     ,			"""os.path.join"""     ,			__lowercase      ).start()
    patch_submodule(__lowercase     ,			"""os.path.dirname"""     ,			__lowercase      ).start()
    patch_submodule(__lowercase     ,			"""os.path.basename"""     ,			__lowercase      ).start()
    patch_submodule(__lowercase     ,			"""os.path.relpath"""     ,			__lowercase      ).start()
    patch_submodule(__lowercase     ,			"""os.path.split"""     ,			__lowercase      ).start()
    patch_submodule(__lowercase     ,			"""os.path.splitext"""     ,			__lowercase      ).start()
    # allow checks on paths
    patch_submodule(__lowercase     ,			"""os.path.exists"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""os.path.isdir"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""os.path.isfile"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""os.path.getsize"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""pathlib.Path"""     ,			__lowercase      ).start()
    # file readers
    patch_submodule(__lowercase     ,			"""gzip.open"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""numpy.load"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""pandas.read_csv"""     ,			wrap_auth(__lowercase      )     ,			attrs=["""__version__"""]      ).start()
    patch_submodule(__lowercase     ,			"""pandas.read_excel"""     ,			wrap_auth(__lowercase      )     ,			attrs=["""__version__"""]      ).start()
    patch_submodule(__lowercase     ,			"""scipy.io.loadmat"""     ,			wrap_auth(__lowercase      )     ,			attrs=["""__version__"""]      ).start()
    patch_submodule(__lowercase     ,			"""xml.etree.ElementTree.parse"""     ,			wrap_auth(__lowercase      )      ).start()
    patch_submodule(__lowercase     ,			"""xml.dom.minidom.parse"""     ,			wrap_auth(__lowercase      )      ).start()
    __A             =		True






def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     "DatasetBuilder"      )  -> Union[str, Any]:





    """simple docstring"""

    extend_module_for_streaming(builder.__module__     ,			use_auth_token=builder.use_auth_token      )
    # if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
    if not builder.__module__.startswith("""datasets."""      ):  # check that it's not a packaged builder like csv
        for imports in get_imports(inspect.getfile(builder.__class__      )      ):
            if imports[0] == "internal":
                __A             =		imports[1]
                __A             =		""".""".join(builder.__module__.split("""."""      )[:-1] + [internal_import_name]      )
                extend_module_for_streaming(__lowercase     ,			use_auth_token=builder.use_auth_token      )

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
    from .builder import DatasetBuilder

    __A             =		[
        cls.__module__
        for cls in type(__lowercase      ).__mro__[1:]  # make sure it's not the same module we've already patched
        if issubclass(cls     ,			__lowercase      ) and cls.__module__ != DatasetBuilder.__module__
    ]  # check it's not a standard builder from datasets.builder
    for module in parent_builder_modules:
        extend_module_for_streaming(__lowercase     ,			use_auth_token=builder.use_auth_token      )




