


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


a__  : Optional[int]				=	datasets.utils.logging.get_logger(__name__)
@dataclass
class  lowercase_					(   datasets.BuilderConfig       ):
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     True
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     None
				__UpperCAmelCase             =     10000
				__UpperCAmelCase             =     None


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


				def        __a							(					self  , a  , a = 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        __a							(					self   ):
										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       ):
				__UpperCAmelCase             =     SqlConfig


				def        __a							(					self   ):
										return datasets.DatasetInfo(features=self.config.features   )


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


				def        __a							(					self  , a   ):
										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        __a							(					self   ):
										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'''







# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


a__  : Any				=	{
    'configuration_tvlt': ['TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TvltConfig'],
    'feature_extraction_tvlt': ['TvltFeatureExtractor'],
    'processing_tvlt': ['TvltProcessor'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : int				=	[
      'TVLT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TvltModel',
      'TvltForPreTraining',
      'TvltForAudioVisualClassification',
      'TvltPreTrainedModel',
  ]

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : List[Any]				=	['TvltImageProcessor']


if TYPE_CHECKING:
  from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
  from .processing_tvlt import TvltProcessor
  from .feature_extraction_tvlt import TvltFeatureExtractor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tvlt import (
        TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TvltForAudioVisualClassification,
        TvltForPreTraining,
        TvltModel,
        TvltPreTrainedModel,
    )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_tvlt import TvltImageProcessor


else:
  import sys

  a__  : Any				=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





