code: 
  
  
  
  
  
  
  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  							=  datasets.utils.logging.get_logger(__name__)
  
  
  
  @dataclass
  class 							_A (    datasets.BuilderConfig							):
      """simple docstring"""
  
      lowerCamelCase  :       Union[str, "sqlalchemy.sql.Selectable"]   =   None
      lowerCamelCase  :       Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]   =   None
      lowerCamelCase  :       Optional[Union[str, List[str]]]   =   None
      lowerCamelCase  :       bool   =   True
      lowerCamelCase  :       Optional[Union[List, Tuple, Dict]]   =   None
      lowerCamelCase  :       Optional[Union[List, Dict]]   =   None
      lowerCamelCase  :       Optional[List[str]]   =   None
      lowerCamelCase  :       Optional[int]   =   10_000
      lowerCamelCase  :       Optional[datasets.Features]   =   None
  
  
  
      def _a       (							self			:    List[str]			)			->       str:
             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			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[datasets.Features] = None   ,    )			->       str:
             __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(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                    if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                           import sqlalchemy
  
                           if isinstance(__SCREAMING_SNAKE_CASE   ,    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(__SCREAMING_SNAKE_CASE			)}: {sql}'''			)
                    else:
                           raise TypeError(
                               f'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(__SCREAMING_SNAKE_CASE			)}: {sql}'''			)
             __UpperCAmelCase    							=config_kwargs["""con"""]
             if not isinstance(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                    __UpperCAmelCase    							=id(__SCREAMING_SNAKE_CASE			)
                    logger.info(
                        f'''SQL connection \'con\' of type {type(__SCREAMING_SNAKE_CASE			)} couldn\'t be hashed properly. To enable hashing, specify \'con\' as URI string instead.'''			)
  
             return super().create_config_id(__SCREAMING_SNAKE_CASE   ,    custom_features=__SCREAMING_SNAKE_CASE			)
  
  
  
      @property
      def _a       (							self			:    Optional[int]			)			->       Union[str, Any]:
             __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 							_A (    datasets.ArrowBasedBuilder							):
      """simple docstring"""
  
      lowerCamelCase  :       Optional[int]   =   SqlConfig
  
  
  
      def _a       (							self			:    int			)			->       int:
             return datasets.DatasetInfo(features=self.config.features			)
  
  
  
      def _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    Any			)			->       Tuple:
             return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,    gen_kwargs={}			)]
  
  
  
      def _a       (							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    pa.Table			)			->       pa.Table:
             if self.config.features is not None:
                    __UpperCAmelCase    							=self.config.features.arrow_schema
                    if all(not require_storage_cast(__SCREAMING_SNAKE_CASE			) for feature in self.config.features.values()			):
                           # cheaper cast
                           __UpperCAmelCase    							=pa.Table.from_arrays([pa_table[field.name] for field in schema]   ,    schema=__SCREAMING_SNAKE_CASE			)
                    else:
                           # more expensive cast; allows str <-> int/float or str to Audio for example
                           __UpperCAmelCase    							=table_cast(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
             return pa_table
  
  
  
      def _a       (							self			:    str			)			->       List[str]:
             __UpperCAmelCase    							=self.config.chunksize
             __UpperCAmelCase    							=pd.read_sql(
                 self.config.sql   ,    self.config.con   ,    chunksize=__SCREAMING_SNAKE_CASE   ,    **self.config.pd_read_sql_kwargs			)
             __UpperCAmelCase    							=[sql_reader] if chunksize is None else sql_reader
             for chunk_idx, df in enumerate(__SCREAMING_SNAKE_CASE			):
                    __UpperCAmelCase    							=pa.Table.from_pandas(__SCREAMING_SNAKE_CASE			)
                    yield chunk_idx, self._cast_table(__SCREAMING_SNAKE_CASE			)
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  __A  							=  [2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]
  
  
  
  class 							_A :
      """simple docstring"""
  
      def __init__(							self			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    int			)			->       None:
             __UpperCAmelCase    							=-1
             __UpperCAmelCase    							=-1
             __UpperCAmelCase    							=[-1] * length
             __UpperCAmelCase    							=None
             __UpperCAmelCase    							=None
  
  
  
      def __repr__(							self			:    Optional[int]			)			->       str:
             return f'''Node(min_value={self.minn} max_value={self.maxx})'''
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	list[int]		)  ->							Node | None:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=Node(len(A_		)		)
         __UpperCAmelCase							,   __UpperCAmelCase    							=min(A_		), max(A_		)
         # Leaf node case where the node contains only one unique value
         if root.minn == root.maxx:
                return root
         __UpperCAmelCase    							=(root.minn + root.maxx) // 2
  
         __UpperCAmelCase    							=[]
         __UpperCAmelCase    							=[]
  
         for index, num in enumerate(A_		):
                if num <= pivot:
                       left_arr.append(A_		)
                else:
                       right_arr.append(A_		)
                __UpperCAmelCase    							=len(A_		)
         __UpperCAmelCase    							=build_tree(A_		)
         __UpperCAmelCase    							=build_tree(A_		)
         return root
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if index < 0 or node is None:
                return 0
         # Leaf node cases
         if node.minn == node.maxx:
                return index + 1 if node.minn == num else 0
         __UpperCAmelCase    							=(node.minn + node.maxx) // 2
         if num <= pivot:
                # go the left subtree and map index to the left subtree
                return rank_till_index(node.left     ,			A_     ,			node.map_left[index] - 1		)
         else:
                # go to the right subtree and map index to the right subtree
                return rank_till_index(node.right     ,			A_     ,			index - node.map_left[index]		)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if start > end:
                return 0
         __UpperCAmelCase    							=rank_till_index(A_     ,			A_     ,			A_		)
         __UpperCAmelCase    							=rank_till_index(A_     ,			A_     ,			start - 1		)
         return rank_till_end - rank_before_start
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if index > (end - start) or start > end or node is None:
                return -1
         # Leaf node case
         if node.minn == node.maxx:
                return node.minn
         # Number of elements in the left subtree in interval [start, end]
         __UpperCAmelCase    							=node.map_left[end] - (
             node.map_left[start - 1] if start else 0
         )
         if num_elements_in_left_tree > index:
                return quantile(
                    node.left     ,			A_     ,			(node.map_left[start - 1] if start else 0)     ,			node.map_left[end] - 1     ,			)
         else:
                return quantile(
                    node.right     ,			index - num_elements_in_left_tree     ,			start - (node.map_left[start - 1] if start else 0)     ,			end - node.map_left[end]     ,			)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if (
             start > end
             or node is None
             or start_num > end_num
             or node.minn > end_num
             or node.maxx < start_num
         ):
                return 0
         if start_num <= node.minn and node.maxx <= end_num:
                return end - start + 1
         __UpperCAmelCase    							=range_counting(
             node.left     ,			(node.map_left[start - 1] if start else 0)     ,			node.map_left[end] - 1     ,			A_     ,			A_     ,			)
         __UpperCAmelCase    							=range_counting(
             node.right     ,			start - (node.map_left[start - 1] if start else 0)     ,			end - node.map_left[end]     ,			A_     ,			A_     ,			)
         return left + right
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
  
  
  
  