singlestoredb 1.11.0__tar.gz → 1.12.1__tar.gz

{singlestoredb-1.11.0/singlestoredb.egg-info → singlestoredb-1.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 1.11.0
+Version: 1.12.1
 Summary: Interface to the SingleStoreDB database and workspace management APIs
 Home-page: https://github.com/singlestore-labs/singlestoredb-python
 Author: SingleStore
@@ -15,6 +15,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Provides-Extra: dataframe
 Provides-Extra: dbt
+Provides-Extra: docker
 Provides-Extra: ed22519
 Provides-Extra: gssapi
 Provides-Extra: ibis

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/accel.c

@@ -1533,6 +1533,15 @@ static PyObject *read_row_from_packet(
                     if (!py_str) goto error;
                 } else {
                     py_str = PyUnicode_Decode(out, out_l, py_state->encodings[i], py_state->encoding_errors);
+                    if (PyErr_Occurred()) {
+                        PyErr_Clear();
+                        PyErr_Format(
+                            PyExc_UnicodeDecodeError,
+                            "failed to decode string value in column '%S' using encoding '%s'; "
+                            "use the 'encoding_errors' option on the connection to specify how to handle this error",
+                            py_state->py_names[i], py_state->encodings[i]
+                        );
+                    }
                     if (!py_str) goto error;
                 }
                 if (py_state->py_converters[i] == Py_None) {
@@ -1740,6 +1749,15 @@ static PyObject *read_row_from_packet(
                     }
 
                     py_item = PyUnicode_Decode(out, out_l, py_state->encodings[i], py_state->encoding_errors);
+                    if (PyErr_Occurred()) {
+                        PyErr_Clear();
+                        PyErr_Format(
+                            PyExc_UnicodeDecodeError,
+                            "failed to decode string value in column '%S' using encoding '%s'; "
+                            "use the 'encoding_errors' option on the connection to specify how to handle this error",
+                            py_state->py_names[i], py_state->encodings[i]
+                        );
+                    }
                     if (!py_item) goto error;
 
                     // Parse JSON string.

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = singlestoredb
-version = 1.11.0
+version = 1.12.1
 description = Interface to the SingleStoreDB database and workspace management APIs
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -50,6 +50,8 @@ dataframe =
 	ibis-singlestoredb
 dbt = 
 	dbt-singlestore
+docker = 
+	docker
 ed22519 = 
 	PyNaCl>=1.4.0
 gssapi = 
@@ -81,7 +83,7 @@ exclude =
 	docs/*
 	resources/*
 	licenses/*
-max-complexity = 35
+max-complexity = 45
 max-line-length = 90
 per-file-ignores = 
 	singlestoredb/__init__.py:F401

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '1.11.0'
+__version__ = '1.12.1'
 
 from typing import Any
 

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/singlestoredb/config.py

@@ -201,6 +201,12 @@ register_option(
     environ='SINGLESTOREDB_BUFFERED',
 )
 
+register_option(
+    'parse_json', 'bool', check_bool, True,
+    'Parse JSON values into Python objects?',
+    environ='SINGLESTOREDB_PARSE_JSON',
+)
+
 register_option(
     'connect_timeout', 'int', check_int, 10,
     'The timeout for connecting to the database in seconds. '

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/singlestoredb/connection.py

@@ -541,10 +541,16 @@ class Cursor(metaclass=abc.ABCMeta):
 
         Examples
         --------
+        Query with no parameters
+
         >>> cur.execute('select * from mytable')
 
+        Query with positional parameters
+
         >>> cur.execute('select * from mytable where id < %s', [100])
 
+        Query with named parameters
+
         >>> cur.execute('select * from mytable where id < %(max)s', dict(max=100))
 
         Returns
@@ -1317,6 +1323,7 @@ def connect(
     track_env: Optional[bool] = None,
     enable_extended_data_types: Optional[bool] = None,
     vector_data_format: Optional[str] = None,
+    parse_json: Optional[bool] = None,
 ) -> Connection:
     """
     Return a SingleStoreDB connection.

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/singlestoredb/converters.py

@@ -594,7 +594,7 @@ def float32_vector_or_none(x: Optional[bytes]) -> Optional[Any]:
     if has_numpy:
         return numpy.frombuffer(x, dtype=numpy.float32)
 
-    return struct.unpack(f'<{len(x)/4}f', x)
+    return struct.unpack(f'<{len(x)//4}f', x)
 
 
 def float64_vector_json_or_none(x: Optional[str]) -> Optional[Any]:
@@ -650,7 +650,7 @@ def float64_vector_or_none(x: Optional[bytes]) -> Optional[Any]:
     if has_numpy:
         return numpy.frombuffer(x, dtype=numpy.float64)
 
-    return struct.unpack(f'<{len(x)/8}d', x)
+    return struct.unpack(f'<{len(x)//8}d', x)
 
 
 def int8_vector_json_or_none(x: Optional[str]) -> Optional[Any]:
@@ -762,7 +762,7 @@ def int16_vector_or_none(x: Optional[bytes]) -> Optional[Any]:
     if has_numpy:
         return numpy.frombuffer(x, dtype=numpy.int16)
 
-    return struct.unpack(f'<{len(x)/2}h', x)
+    return struct.unpack(f'<{len(x)//2}h', x)
 
 
 def int32_vector_json_or_none(x: Optional[str]) -> Optional[Any]:
@@ -818,7 +818,7 @@ def int32_vector_or_none(x: Optional[bytes]) -> Optional[Any]:
     if has_numpy:
         return numpy.frombuffer(x, dtype=numpy.int32)
 
-    return struct.unpack(f'<{len(x)/4}l', x)
+    return struct.unpack(f'<{len(x)//4}l', x)
 
 
 def int64_vector_json_or_none(x: Optional[str]) -> Optional[Any]:
@@ -875,7 +875,7 @@ def int64_vector_or_none(x: Optional[bytes]) -> Optional[Any]:
     if has_numpy:
         return numpy.frombuffer(x, dtype=numpy.int64)
 
-    return struct.unpack(f'<{len(x)/8}l', x)
+    return struct.unpack(f'<{len(x)//8}l', x)
 
 
 def bson_or_none(x: Optional[bytes]) -> Optional[Any]:

{singlestoredb-1.11.0 → singlestoredb-1.12.1}/singlestoredb/functions/__init__.py

@@ -1 +1,2 @@
+from .decorator import tvf  # noqa: F401
 from .decorator import udf  # noqa: F401

singlestoredb-1.12.1/singlestoredb/functions/decorator.py

@@ -0,0 +1,331 @@
+import dataclasses
+import datetime
+import functools
+import inspect
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+from . import dtypes
+from .dtypes import DataType
+from .signature import simplify_dtype
+
+try:
+    import pydantic
+    has_pydantic = True
+except ImportError:
+    has_pydantic = False
+
+python_type_map: Dict[Any, Callable[..., str]] = {
+    str: dtypes.TEXT,
+    int: dtypes.BIGINT,
+    float: dtypes.DOUBLE,
+    bool: dtypes.BOOL,
+    bytes: dtypes.BINARY,
+    bytearray: dtypes.BINARY,
+    datetime.datetime: dtypes.DATETIME,
+    datetime.date: dtypes.DATE,
+    datetime.timedelta: dtypes.TIME,
+}
+
+
+def listify(x: Any) -> List[Any]:
+    """Make sure sure value is a list."""
+    if x is None:
+        return []
+    if isinstance(x, (list, tuple, set)):
+        return list(x)
+    return [x]
+
+
+def process_annotation(annotation: Any) -> Tuple[Any, bool]:
+    types = simplify_dtype(annotation)
+    if isinstance(types, list):
+        nullable = False
+        if type(None) in types:
+            nullable = True
+            types = [x for x in types if x is not type(None)]
+        if len(types) > 1:
+            raise ValueError(f'multiple types not supported: {annotation}')
+        return types[0], nullable
+    return types, True
+
+
+def process_types(params: Any) -> Any:
+    if params is None:
+        return params, []
+
+    elif isinstance(params, (list, tuple)):
+        params = list(params)
+        for i, item in enumerate(params):
+            if params[i] in python_type_map:
+                params[i] = python_type_map[params[i]]()
+            elif callable(item):
+                params[i] = item()
+        for item in params:
+            if not isinstance(item, str):
+                raise TypeError(f'unrecognized type for parameter: {item}')
+        return params, []
+
+    elif isinstance(params, dict):
+        names = []
+        params = dict(params)
+        for k, v in list(params.items()):
+            names.append(k)
+            if params[k] in python_type_map:
+                params[k] = python_type_map[params[k]]()
+            elif callable(v):
+                params[k] = v()
+        for item in params.values():
+            if not isinstance(item, str):
+                raise TypeError(f'unrecognized type for parameter: {item}')
+        return params, names
+
+    elif dataclasses.is_dataclass(params):
+        names = []
+        out = []
+        for item in dataclasses.fields(params):
+            typ, nullable = process_annotation(item.type)
+            sql_type = process_types(typ)[0]
+            if not nullable:
+                sql_type = sql_type.replace('NULL', 'NOT NULL')
+            out.append(sql_type)
+            names.append(item.name)
+        return out, names
+
+    elif has_pydantic and inspect.isclass(params) \
+            and issubclass(params, pydantic.BaseModel):
+        names = []
+        out = []
+        for name, item in params.model_fields.items():
+            typ, nullable = process_annotation(item.annotation)
+            sql_type = process_types(typ)[0]
+            if not nullable:
+                sql_type = sql_type.replace('NULL', 'NOT NULL')
+            out.append(sql_type)
+            names.append(name)
+        return out, names
+
+    elif params in python_type_map:
+        return python_type_map[params](), []
+
+    elif callable(params):
+        return params(), []
+
+    elif isinstance(params, str):
+        return params, []
+
+    raise TypeError(f'unrecognized data type for args: {params}')
+
+
+def _func(
+    func: Optional[Callable[..., Any]] = None,
+    *,
+    name: Optional[str] = None,
+    args: Optional[
+        Union[
+            DataType,
+            List[DataType],
+            Dict[str, DataType],
+            'pydantic.BaseModel',
+            type,
+        ]
+    ] = None,
+    returns: Optional[
+        Union[
+            str,
+            List[DataType],
+            List[type],
+            'pydantic.BaseModel',
+            type,
+        ]
+    ] = None,
+    data_format: Optional[str] = None,
+    include_masks: bool = False,
+    function_type: str = 'udf',
+    output_fields: Optional[List[str]] = None,
+) -> Callable[..., Any]:
+    """Generic wrapper for UDF and TVF decorators."""
+    args, _ = process_types(args)
+    returns, fields = process_types(returns)
+
+    if not output_fields and fields:
+        output_fields = fields
+
+    if isinstance(returns, list) \
+            and isinstance(output_fields, list) \
+            and len(output_fields) != len(returns):
+        raise ValueError(
+            'The number of output fields must match the number of return types',
+        )
+
+    if include_masks and data_format == 'python':
+        raise RuntimeError(
+            'include_masks is only valid when using '
+            'vectors for input parameters',
+        )
+
+    _singlestoredb_attrs = {  # type: ignore
+        k: v for k, v in dict(
+            name=name,
+            args=args,
+            returns=returns,
+            data_format=data_format,
+            include_masks=include_masks,
+            function_type=function_type,
+            output_fields=output_fields or None,
+        ).items() if v is not None
+    }
+
+    # No func was specified, this is an uncalled decorator that will get
+    # called later, so the wrapper much be created with the func passed
+    # in at that time.
+    if func is None:
+        def decorate(func: Callable[..., Any]) -> Callable[..., Any]:
+            def wrapper(*args: Any, **kwargs: Any) -> Callable[..., Any]:
+                return func(*args, **kwargs)  # type: ignore
+            wrapper._singlestoredb_attrs = _singlestoredb_attrs  # type: ignore
+            return functools.wraps(func)(wrapper)
+        return decorate
+
+    def wrapper(*args: Any, **kwargs: Any) -> Callable[..., Any]:
+        return func(*args, **kwargs)  # type: ignore
+
+    wrapper._singlestoredb_attrs = _singlestoredb_attrs  # type: ignore
+
+    return functools.wraps(func)(wrapper)
+
+
+def udf(
+    func: Optional[Callable[..., Any]] = None,
+    *,
+    name: Optional[str] = None,
+    args: Optional[Union[DataType, List[DataType], Dict[str, DataType]]] = None,
+    returns: Optional[Union[str, List[DataType], List[type]]] = None,
+    data_format: Optional[str] = None,
+    include_masks: bool = False,
+) -> Callable[..., Any]:
+    """
+    Apply attributes to a UDF.
+
+    Parameters
+    ----------
+    func : callable, optional
+        The UDF to apply parameters to
+    name : str, optional
+        The name to use for the UDF in the database
+    args : str | Callable | List[str | Callable] | Dict[str, str | Callable], optional
+        Specifies the data types of the function arguments. Typically,
+        the function data types are derived from the function parameter
+        annotations. These annotations can be overridden. If the function
+        takes a single type for all parameters, `args` can be set to a
+        SQL string describing all parameters. If the function takes more
+        than one parameter and all of the parameters are being manually
+        defined, a list of SQL strings may be used (one for each parameter).
+        A dictionary of SQL strings may be used to specify a parameter type
+        for a subset of parameters; the keys are the names of the
+        function parameters. Callables may also be used for datatypes. This
+        is primarily for using the functions in the ``dtypes`` module that
+        are associated with SQL types with all default options (e.g., ``dt.FLOAT``).
+    returns : str, optional
+        Specifies the return data type of the function. If not specified,
+        the type annotation from the function is used.
+    data_format : str, optional
+        The data format of each parameter: python, pandas, arrow, polars
+    include_masks : bool, optional
+        Should boolean masks be included with each input parameter to indicate
+        which elements are NULL? This is only used when a input parameters are
+        configured to a vector type (numpy, pandas, polars, arrow).
+
+    Returns
+    -------
+    Callable
+
+    """
+    return _func(
+        func=func,
+        name=name,
+        args=args,
+        returns=returns,
+        data_format=data_format,
+        include_masks=include_masks,
+        function_type='udf',
+    )
+
+
+udf.pandas = functools.partial(udf, data_format='pandas')  # type: ignore
+udf.polars = functools.partial(udf, data_format='polars')  # type: ignore
+udf.arrow = functools.partial(udf, data_format='arrow')  # type: ignore
+udf.numpy = functools.partial(udf, data_format='numpy')  # type: ignore
+
+
+def tvf(
+    func: Optional[Callable[..., Any]] = None,
+    *,
+    name: Optional[str] = None,
+    args: Optional[Union[DataType, List[DataType], Dict[str, DataType]]] = None,
+    returns: Optional[Union[str, List[DataType], List[type]]] = None,
+    data_format: Optional[str] = None,
+    include_masks: bool = False,
+    output_fields: Optional[List[str]] = None,
+) -> Callable[..., Any]:
+    """
+    Apply attributes to a TVF.
+
+    Parameters
+    ----------
+    func : callable, optional
+        The TVF to apply parameters to
+    name : str, optional
+        The name to use for the TVF in the database
+    args : str | Callable | List[str | Callable] | Dict[str, str | Callable], optional
+        Specifies the data types of the function arguments. Typically,
+        the function data types are derived from the function parameter
+        annotations. These annotations can be overridden. If the function
+        takes a single type for all parameters, `args` can be set to a
+        SQL string describing all parameters. If the function takes more
+        than one parameter and all of the parameters are being manually
+        defined, a list of SQL strings may be used (one for each parameter).
+        A dictionary of SQL strings may be used to specify a parameter type
+        for a subset of parameters; the keys are the names of the
+        function parameters. Callables may also be used for datatypes. This
+        is primarily for using the functions in the ``dtypes`` module that
+        are associated with SQL types with all default options (e.g., ``dt.FLOAT``).
+    returns : str, optional
+        Specifies the return data type of the function. If not specified,
+        the type annotation from the function is used.
+    data_format : str, optional
+        The data format of each parameter: python, pandas, arrow, polars
+    include_masks : bool, optional
+        Should boolean masks be included with each input parameter to indicate
+        which elements are NULL? This is only used when a input parameters are
+        configured to a vector type (numpy, pandas, polars, arrow).
+    output_fields : List[str], optional
+        The names of the output fields for the TVF. If not specified, the
+        names are generated.
+
+    Returns
+    -------
+    Callable
+
+    """
+    return _func(
+        func=func,
+        name=name,
+        args=args,
+        returns=returns,
+        data_format=data_format,
+        include_masks=include_masks,
+        function_type='tvf',
+        output_fields=output_fields,
+    )
+
+
+tvf.pandas = functools.partial(tvf, data_format='pandas')  # type: ignore
+tvf.polars = functools.partial(tvf, data_format='polars')  # type: ignore
+tvf.arrow = functools.partial(tvf, data_format='arrow')  # type: ignore
+tvf.numpy = functools.partial(tvf, data_format='numpy')  # type: ignore