





"""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_				=    datasets.utils.logging.get_logger(__name__)






@dataclass
class 	__snake_case      (	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       UpperCamelCase__(					self						):



     '''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       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase = None      ,		):



     '''simple docstring'''




     __A					:		Tuple						=  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					:		Any						=  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					:		Any						=  sqlalchemy.create_engine(config_kwargs['''con'''].split('''://'''						)[0] + '''://'''						)
                 __A					:		int						=  str(sql.compile(dialect=engine.dialect						)						)
                 __A					:		Any						=  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					:		Tuple						=  config_kwargs['''con''']
     if not isinstance(__lowerCamelCase      ,		__lowerCamelCase						):
         __A					:		List[str]						=  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       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Any						=  {
         '''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 	__snake_case      (	datasets.ArrowBasedBuilder  ):





 """simple docstring"""


 _lowerCamelCase				 =  SqlConfig

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




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

 def       UpperCamelCase__(					self      ,		__lowerCamelCase						):



     '''simple docstring'''




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

 def       UpperCamelCase__(					self      ,		__lowerCamelCase						):



     '''simple docstring'''




     if self.config.features is not None:
         __A					:		Optional[Any]						=  self.config.features.arrow_schema
         if all(not require_storage_cast(__lowerCamelCase						) for feature in self.config.features.values()						):
             # cheaper cast
             __A					:		int						=  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					:		List[str]						=  table_cast(__lowerCamelCase      ,		__lowerCamelCase						)
     return pa_table







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




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











"""simple docstring"""



from __future__ import annotations

import sys







def 	__lowercase  (     snake_case_						:						int       ,snake_case_						:						int		)     ->tuple[int, int]:



    '''simple docstring'''







    if abs(snake_case_		) == 1:
        return a, 0
    elif abs(snake_case_		) == 1:
        return 0, b

    __A				, __A					:		int						=  a, b
    __A				, __A					:		Any						=  1, 0
    __A				, __A					:		int						=  0, 1

    while remainder != 0:
        __A					:		List[Any]						=  old_remainder // remainder
        __A				, __A					:		int						=  remainder, old_remainder - quotient * remainder
        __A				, __A					:		List[Any]						=  coeff_a, old_coeff_a - quotient * coeff_a
        __A				, __A					:		Union[str, Any]						=  coeff_b, old_coeff_b - quotient * coeff_b

    # sign correction for negative numbers
    if a < 0:
        __A					:		Optional[Any]						=  -old_coeff_a
    if b < 0:
        __A					:		List[Any]						=  -old_coeff_b

    return old_coeff_a, old_coeff_b







def 	__lowercase  (     )     ->List[str]:



    '''simple docstring'''







    if len(sys.argv		) < 3:
        print('''2 integer arguments required'''		)
        return 1
    __A					:		Optional[int]						=  int(sys.argv[1]		)
    __A					:		Tuple						=  int(sys.argv[2]		)
    print(extended_euclidean_algorithm(snake_case_       ,snake_case_		)		)
    return 0


if __name__ == "__main__":
       raise SystemExit(main())




