singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

singlestoredb/drivers/__init__.py

@@ -1,45 +0,0 @@
-import re
-from typing import Any
-from typing import Dict
-
-from . import base
-from .cymysql import CyMySQLDriver
-from .http import HTTPDriver
-from .http import HTTPSDriver
-from .mariadb import MariaDBDriver
-from .mysqlconnector import MySQLConnectorDriver
-from .mysqldb import MySQLdbDriver
-from .pymysql import PyMySQLDriver
-from .pymysqlsv import PyMySQLsvDriver
-from .pyodbc import PyODBCDriver
-
-
-def get_driver(name: str, params: Dict[str, Any]) -> base.Driver:
-    """
-    Return the driver with the given name.
-
-    Parameters
-    ----------
-    name : str
-        Name of the driver. All non-letters/digits will be removed
-        from the name when matching. For example, 'mysqlconnector'
-        will match 'mysql.connector' or 'mysqlconnector'. Matches
-        are also case-insensitive.
-    params : dict
-        Dictionary of connection parameters
-
-    Returns
-    -------
-    Driver
-
-    """
-    rm_symbols = re.compile(r'[^A-Z0-9]', flags=re.I)
-    new_name = rm_symbols.sub(r'', name).lower()
-    for item in globals().values():
-        if type(item) is not type:
-            continue
-        if not issubclass(item, base.Driver):
-            continue
-        if new_name == rm_symbols.sub(r'', item.name.lower()):
-            return item(**params)
-    raise RuntimeError("Could not locate driver with name '{}'".format(name))

singlestoredb/drivers/base.py

@@ -1,198 +0,0 @@
-import sys
-from typing import Any
-from typing import Callable
-from typing import Dict
-from typing import Optional
-
-from .. import exceptions
-
-
-def wrap_converter(
-    outer: Optional[Callable[[Any], Any]],
-    conv: Optional[Callable[[Any], Any]],
-) -> Optional[Callable[[Any], Any]]:
-    """Create a pipeline from two functions."""
-    if outer is None:
-        return conv
-
-    if conv is None:
-        return outer
-
-    def converter(value: Any) -> Any:
-        return outer(conv(value))  # type: ignore
-
-    return converter
-
-
-class Driver(object):
-    """Base driver class."""
-
-    # Name of driver used in connections
-    name: str = ''
-
-    # Name of package to import
-    pkg_name: str = ''
-
-    # Name of the package on PyPI.org
-    pypi: str = ''
-
-    # Name of the package on Anaconda.org
-    anaconda: str = ''
-
-    # Does the driver return bytes for all data values?
-    # If true and flags are available in the description to deterimine
-    # if a character field is text or binary, the text will be automatically
-    # decoded before conversion functions are run.
-    returns_bytes: bool = False
-
-    def __init__(self, **kwargs: Any):
-        self._params = kwargs
-
-        # These converters get applied after the driver does its own
-        # conversions. This allows each driver to decide which conversions
-        # get handled internally and which get applied by this framework.
-        self.converters: Dict[int, Callable[[Any], Any]] = {}
-
-    def connect(self) -> Any:
-        """Create a new connection."""
-        params = {
-            k: v for k, v in self.remap_params(self._params).items() if v is not None
-        }
-        conn = self.dbapi.connect(**params)
-        self.after_connect(conn, self._params)
-        return conn
-
-    def merge_converters(
-        self,
-        user_converters: Dict[int, Callable[[Any], Any]],
-        driver_converters: Dict[int, Callable[[Any], Any]],
-    ) -> Dict[int, Callable[[Any], Any]]:
-        """Merge two sets of converters into pipelines as needed."""
-        out = dict(driver_converters)
-        for key, value in user_converters.items():
-            func = wrap_converter(value, out.get(key))
-            if func is not None:
-                out[key] = func
-        return out
-
-    def after_connect(self, conn: Any, params: Dict[str, Any]) -> None:
-        """
-        Callback for immediately after making a connection.
-
-        Parameters
-        ----------
-        conn : Connection
-            Connection object
-        params : dict
-            Original connection parameters
-
-        """
-        return
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        """
-        Determine if the server is still connected.
-
-        Parameters
-        ----------
-        conn : Connection
-            Connection object to test
-        reconnect : bool, optional
-            If the server is not connected, should a reconnection be attempted?
-
-        Returns
-        -------
-        bool
-
-        """
-        raise NotImplementedError
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Map generalized parameters to package-specific parameters.
-
-        Parameters
-        ----------
-        params : dict
-            Dictionary of connection parameters.
-
-        Returns
-        -------
-        dict
-
-        """
-        return params
-
-    def convert_exception(self, exc: Exception) -> Exception:
-        """Convert driver-specific exception to SingleStoreDB exception."""
-        dbapi = self.dbapi
-        if not isinstance(exc, (dbapi.Error, dbapi.Warning)):
-            return exc
-        new_exc: Optional[type] = None
-        if isinstance(exc, dbapi.NotSupportedError):
-            new_exc = exceptions.NotSupportedError
-        elif isinstance(exc, dbapi.ProgrammingError):
-            new_exc = exceptions.ProgrammingError
-        elif isinstance(exc, dbapi.InternalError):
-            new_exc = exceptions.InternalError
-        elif isinstance(exc, dbapi.IntegrityError):
-            new_exc = exceptions.IntegrityError
-        elif isinstance(exc, dbapi.OperationalError):
-            new_exc = exceptions.OperationalError
-        elif isinstance(exc, dbapi.DataError):
-            new_exc = exceptions.DataError
-        elif isinstance(exc, dbapi.DatabaseError):
-            new_exc = exceptions.DatabaseError
-        elif isinstance(exc, dbapi.InterfaceError):
-            new_exc = exceptions.InterfaceError
-        elif isinstance(exc, dbapi.Error):
-            new_exc = exceptions.Error
-        elif isinstance(exc, dbapi.Warning):
-            new_exc = exceptions.Warning
-        if new_exc is None:
-            return exc
-
-        # Check for exceptions with errno / msg first
-        errno = getattr(exc, 'errno', None)
-        msg = getattr(exc, 'msg', None)
-        if msg:
-            return new_exc(
-                errno=errno, msg=msg,
-                sqlstate=getattr(exc, 'sqlstate', None),
-            )
-
-        # Check for exceptions with just args
-        args = getattr(exc, 'args', [])
-        if len(args) > 1:
-            return new_exc(args[0], args[1])
-        if len(args):
-            return new_exc(args[0])
-
-        # Don't know what type it is
-        raise ValueError(f'Unrecognized exception format: {exc}')
-
-    @property
-    def dbapi(self) -> Any:
-        """Return imported DB-API-compatible module."""
-        if not type(self).pkg_name:
-            raise ValueError('No package name defined in driver.')
-        try:
-            return __import__(type(self).pkg_name, {}, {}, ['connect'])
-        except ModuleNotFoundError:
-            msg = []
-            msg.append('{} is not available.'.format(type(self).pkg_name))
-            msg.append(" Use 'pip install {}'".format(type(self).pypi))
-            if type(self).anaconda:
-                if '::' in type(self).anaconda:
-                    msg.append(
-                        " or 'conda install -c {} {}' (for Anaconda)"
-                        .format(*type(self).anaconda.split('::', 1)),
-                    )
-                else:
-                    msg.append(
-                        " or 'conda install {}' (for Anaconda)"
-                        .format(type(self).anaconda),
-                    )
-            msg.append(' to install it.')
-            print(''.join(msg), file=sys.stderr)
-            raise

singlestoredb/drivers/cymysql.py

@@ -1,38 +0,0 @@
-from typing import Any
-from typing import Dict
-
-try:
-    from cymysql.converters import encoders
-except ImportError:
-    encoders = {}
-
-from .base import Driver
-from ..converters import converters
-
-
-converters = dict(converters)
-converters.update(encoders)
-
-
-class CyMySQLDriver(Driver):
-
-    name = 'CyMySQL'
-
-    pkg_name = 'cymysql'
-    pypi = 'cymysql'
-    anaconda = 'cymysql'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('pure_python', None)
-        params.pop('odbc_driver', None)
-        params.pop('credential_type', None)
-        params['port'] = params['port'] or 3306
-        params['db'] = params.pop('database', None)
-        params['passwd'] = params.pop('password', None)
-        params['conv'] = self.merge_converters(params.pop('converters', {}), converters)
-        params['ssl'] = dict(cipher=params.pop('ssl_cipher'))
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        return conn.ping(reconnect=reconnect)

singlestoredb/drivers/http.py

@@ -1,47 +0,0 @@
-import warnings
-from typing import Any
-from typing import Dict
-
-from .base import Driver
-
-
-class HTTPDriver(Driver):
-
-    name = 'http'
-
-    pkg_name = 'singlestoredb.http'
-    pypi = 'singlestoredb'
-    anaconda = 'singlestore::singlestoredb'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('pure_python', False)
-        params.pop('charset', None)
-        params.pop('odbc_driver', None)
-        params.pop('credential_type', None)
-        params.pop('autocommit', None)
-        params.pop('ssl_cipher', None)
-
-        params['protocol'] = params.pop('driver', '').replace(
-            'singlestoredb+', '',
-        ) or None
-
-        if params.pop('local_infile', False):
-            warnings.warn('The HTTP driver does not support file uploads.')
-
-        if params['port'] is None:
-            if type(self).name == 'https':
-                params['port'] = 443
-            else:
-                params['port'] = 80
-
-        self.converters = params.pop('converters', {})
-
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        return conn.is_connected()
-
-
-class HTTPSDriver(HTTPDriver):
-
-    name = 'https'

singlestoredb/drivers/mariadb.py

@@ -1,40 +0,0 @@
-import json
-from typing import Any
-from typing import Dict
-
-from .base import Driver
-
-
-converters = {245: json.loads}
-
-
-class MariaDBDriver(Driver):
-
-    name = 'mariadb'
-
-    pkg_name = 'mariadb'
-    pypi = 'mariadb-connector-python'
-    anaconda = 'mariadb-connector-python'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('charset', None)
-        params.pop('odbc_driver', None)
-        params.pop('pure_python', None)
-        params.pop('credential_type', None)
-        params['converter'] = self.merge_converters(
-            params.pop('converters', {}),
-            dict(converters),
-        )
-        if params.pop('ssl_disabled', False):
-            params['ssl'] = False
-            params['ssl_verify_cert'] = False
-
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        try:
-            conn.ping()
-            return True
-        except conn.InterfaceError:
-            return False

singlestoredb/drivers/mysqlconnector.py

@@ -1,49 +0,0 @@
-from typing import Any
-from typing import Dict
-
-from .. import auth
-from ..converters import converters
-from .base import Driver
-
-
-class MySQLConnectorDriver(Driver):
-
-    name = 'mysqlconnector'
-
-    pkg_name = 'mysql.connector'
-    pypi = 'mysql-connector-python'
-    anaconda = 'mysql-connector-python'
-
-    # This flag lets the connection do the decoding of text / binary accordingly
-    returns_bytes = True
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('odbc_driver', None)
-        params.pop('ssl_cipher', None)
-        if params.pop('pure_python', False):
-            params['use_pure'] = True
-        params['port'] = params['port'] or 3306
-        params['allow_local_infile'] = params.pop('local_infile')
-
-        # Always use raw, we're doing the conversions ourselves
-        params['raw'] = True
-
-        convs = params.pop('converters', {})
-        self.converters = self.merge_converters(convs, converters)
-
-        # Check authentication method
-        cred = params.pop('credential_type', None)
-        if cred in [auth.BROWSER_SSO, auth.JWT] and not params.get('use_pure', False):
-            #           params['auth_plugin'] = 'mysql_clear_password'
-            params['ssl_verify_identity'] = True
-            params['ssl_verify_cert'] = True
-
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        try:
-            conn.ping(reconnect=reconnect)
-            return True
-        except conn.InterfaceError:
-            return False

singlestoredb/drivers/mysqldb.py

@@ -1,60 +0,0 @@
-from typing import Any
-from typing import Dict
-
-from ..converters import converters
-from .base import Driver
-
-
-class MySQLdbDriver(Driver):
-
-    name = 'MySQLdb'
-
-    pkg_name = 'MySQLdb'
-    pypi = 'mysqlclient'
-    anaconda = 'mysqlclient'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('pure_python', None)
-        params.pop('odbc_driver', None)
-        params.pop('credential_type', None)
-
-        params['conv'] = dict(converters)
-
-        ssl = dict()
-
-        if params.get('ssl_key', None):
-            ssl['key'] = params.get('ssl_key')
-        if params.get('ssl_cert', None):
-            ssl['cert'] = params.get('ssl_cert')
-        if params.get('ssl_ca', None):
-            ssl['ca'] = params.get('ssl_ca')
-        if params.get('ssl_cipher', None):
-            ssl['cipher'] = params.get('ssl_cipher')
-
-        params.pop('ssl_key', None)
-        params.pop('ssl_cert', None)
-        params.pop('ssl_ca', None)
-        params.pop('ssl_cipher', None)
-
-        if ssl:
-            params['ssl'] = dict(ssl=ssl)
-
-        if params.pop('ssl_disabled', False):
-            params['ssl_mode'] = 'DISABLED'
-
-        self.converters = params.pop('converters', {})
-
-        return params
-
-    def after_connect(self, conn: Any, params: Dict[str, Any]) -> None:
-        # This must be done afterward because use_unicode= whacks the
-        # json converter if you try to put it in earlier.
-        conn.converter[245] = converters[245]
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        try:
-            conn.ping(reconnect)
-            return True
-        except conn.InterfaceError:
-            return False

singlestoredb/drivers/pymysql.py

@@ -1,37 +0,0 @@
-from typing import Any
-from typing import Callable
-from typing import Dict
-
-try:
-    from pymysql.converters import encoders
-except ImportError:
-    encoders = {}
-
-from .base import Driver
-from ..converters import converters as convs
-
-converters: Dict[Any, Callable[..., Any]] = dict(convs)
-converters.update(encoders)
-
-
-class PyMySQLDriver(Driver):
-
-    name = 'PyMySQL'
-
-    pkg_name = 'pymysql'
-    pypi = 'pymysql'
-    anaconda = 'pymysql'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('odbc_driver', None)
-        params.pop('pure_python', None)
-        params.pop('credential_type', None)
-        # The cipher must be set to this level for SingleStoreDB Cloud.
-        params['ssl'] = dict(cipher=params.pop('ssl_cipher'))
-        params['port'] = params['port'] or 3306
-        params['conv'] = self.merge_converters(params.pop('converters', {}), converters)
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        return conn.open

singlestoredb/drivers/pymysqlsv.py

@@ -1,35 +0,0 @@
-from typing import Any
-from typing import Callable
-from typing import Dict
-
-try:
-    from ..clients.pymysqlsv.converters import encoders  # type: ignore
-except (ImportError, ModuleNotFoundError):
-    encoders = {}
-
-from .base import Driver
-from ..converters import converters as convs
-
-converters: Dict[Any, Callable[..., Any]] = dict(convs)
-converters.update(encoders)
-
-
-class PyMySQLsvDriver(Driver):
-
-    name = 'PyMySQLsv'
-
-    pkg_name = 'singlestoredb.clients.pymysqlsv'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        params.pop('driver', None)
-        params.pop('odbc_driver', None)
-        params.pop('pure_python', None)
-        params.pop('credential_type', None)
-        # The cipher must be set to this level for SingleStoreDB Cloud.
-        params['ssl'] = dict(cipher=params.pop('ssl_cipher'))
-        params['port'] = params['port'] or 3306
-        params['conv'] = self.merge_converters(params.pop('converters', {}), converters)
-        return params
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        return conn.open

singlestoredb/drivers/pyodbc.py

@@ -1,65 +0,0 @@
-import datetime
-import json
-from typing import Any
-from typing import Dict
-from typing import Optional
-
-from .base import Driver
-
-
-datetime_min = datetime.datetime.min
-date_min = datetime.date.min
-datetime_combine = datetime.datetime.combine
-
-
-def convert_time(value: Optional[datetime.time]) -> Optional[datetime.timedelta]:
-    """Convert time to timedelta."""
-    if value is None:
-        return None
-    return datetime_combine(date_min, value) - datetime_min
-
-
-def convert_json(value: Optional[str]) -> Optional[Dict[str, Any]]:
-    """Convert JSON str to dict."""
-    if value is None:
-        return None
-    return json.loads(value)
-
-
-class PyODBCDriver(Driver):
-
-    name = 'pyodbc'
-
-    pkg_name = 'pyodbc'
-    pypi = 'pyodbc'
-    anaconda = 'pyodbc'
-
-    def remap_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        out = {
-            k: v for k, v in dict(
-                server=params.get('host', '127.0.0.1'),
-                port=params.get('port', 0) or 3306,
-                database=params.get('database'),
-                uid=params.get('user'),
-                pwd=params.get('password'),
-                charset=params.get('charset'),
-                driver=params.get('odbc_driver'),
-            ).items() if v is not None
-        }
-
-        convs = params.pop('converters', {})
-        self.converters = self.merge_converters(
-            convs, {
-                11: convert_time,
-                245: convert_json,
-            },
-        )
-
-        return out
-
-    def after_connect(self, conn: Any, params: Dict[str, Any]) -> None:
-        if params.get('autocommit'):
-            conn.autocommit(True)
-
-    def is_connected(self, conn: Any, reconnect: bool = False) -> bool:
-        return not conn.closed