



"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase				:     Tuple								=  {"""configuration_umt5""": ["""UMT5Config""", """UMT5OnnxConfig"""]}


try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase				:     Any								=  [
        """UMT5EncoderModel""",
        """UMT5ForConditionalGeneration""",
        """UMT5ForQuestionAnswering""",
        """UMT5Model""",
        """UMT5PreTrainedModel""",
    ]

if TYPE_CHECKING:
    from .configuration_umta import UMTaConfig, UMTaOnnxConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_umta import (
            UMTaEncoderModel,
            UMTaForConditionalGeneration,
            UMTaForQuestionAnswering,
            UMTaModel,
            UMTaPreTrainedModel,
        )
else:
    import sys

    lowerCamelCase				:     List[str]								=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



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


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


@dataclass
class 					A		(				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 		snake_case__	( self					:			Tuple						)->       Optional[int]:





        '''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 		snake_case__	( self					:			Dict,lowercase_					:			dict,lowercase_					:			Optional[datasets.Features] = None,)->       str:





        '''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 		snake_case__	( self					:			Union[str, Any]						)->       Any:





        '''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 					A		(				datasets.ArrowBasedBuilder					):







    """simple docstring"""





    lowerCamelCase						      =				SqlConfig


    def 		snake_case__	( self					:			Any						)->       Any:





        '''simple docstring'''







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


    def 		snake_case__	( self					:			Tuple,lowercase_					:			List[Any]						)->       Union[str, Any]:





        '''simple docstring'''







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


    def 		snake_case__	( self					:			Any,lowercase_					:			pa.Table						)->       pa.Table:





        '''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 		snake_case__	( self					:			List[str]						)->       Union[str, Any]:





        '''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_						)

