singlestoredb 1.15.0__cp38-abi3-win_amd64.whl → 1.15.2__cp38-abi3-win_amd64.whl

singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '1.15.0'
+__version__ = '1.15.2'
 
 from typing import Any
 

singlestoredb/ai/chat.py

@@ -24,3 +24,17 @@ class SingleStoreChatOpenAI(ChatOpenAI):
             model=model_name,
             **kwargs,
         )
+
+
+class SingleStoreChat(ChatOpenAI):
+    def __init__(self, model_name: str, **kwargs: Any):
+        inference_api_manger = (
+            get_workspace_manager().organizations.current.inference_apis
+        )
+        info = inference_api_manger.get(model_name=model_name)
+        super().__init__(
+            base_url=info.connection_url,
+            api_key=os.environ.get('SINGLESTOREDB_USER_TOKEN'),
+            model=model_name,
+            **kwargs,
+        )

singlestoredb/apps/_python_udfs.py

@@ -13,6 +13,9 @@ if typing.TYPE_CHECKING:
 # Keep track of currently running server
 _running_server: 'typing.Optional[AwaitableUvicornServer]' = None
 
+# Maximum number of UDFs allowed
+MAX_UDFS_LIMIT = 10
+
 
 async def run_udf_app(
     log_level: str = 'error',
@@ -44,20 +47,32 @@ async def run_udf_app(
     udf_suffix = ''
     if app_config.running_interactively:
         udf_suffix = '_test'
-    app = Application(url=base_url, app_mode='managed', name_suffix=udf_suffix)
+    app = Application(
+        url=base_url,
+        app_mode='managed',
+        name_suffix=udf_suffix,
+        log_level=log_level,
+    )
+
+    if not app.endpoints:
+        raise ValueError('You must define at least one function.')
+    if len(app.endpoints) > MAX_UDFS_LIMIT:
+        raise ValueError(
+            f'You can only define a maximum of {MAX_UDFS_LIMIT} functions.',
+        )
 
     config = uvicorn.Config(
         app,
         host='0.0.0.0',
         port=app_config.listen_port,
-        log_level=log_level,
+        log_config=app.get_uvicorn_log_config(),
     )
-    _running_server = AwaitableUvicornServer(config)
 
     # Register the functions only if the app is running interactively.
     if app_config.running_interactively:
         app.register_functions(replace=True)
 
+    _running_server = AwaitableUvicornServer(config)
     asyncio.create_task(_running_server.serve())
     await _running_server.wait_for_startup()
 

singlestoredb/apps/_stdout_supress.py

@@ -9,7 +9,7 @@ class StdoutSuppressor:
     This should not be used for asynchronous or threaded executions.
 
     ```py
-    with Supressor():
+    with StdoutSupressor():
         print("This won't be printed")
     ```
 

singlestoredb/apps/_uvicorn_util.py

@@ -30,3 +30,7 @@ class AwaitableUvicornServer(uvicorn.Server):
 
     async def wait_for_startup(self) -> None:
         await self._startup_future
+
+    async def shutdown(self, sockets: Optional[list[socket.socket]] = None) -> None:
+        if self.started:
+            await super().shutdown(sockets)

singlestoredb/config.py

@@ -407,6 +407,12 @@ register_option(
     environ=['SINGLESTOREDB_EXT_FUNC_LOG_LEVEL'],
 )
 
+register_option(
+    'external_function.log_file', 'string', check_str, None,
+    'File path to write logs to instead of console.',
+    environ=['SINGLESTOREDB_EXT_FUNC_LOG_FILE'],
+)
+
 register_option(
     'external_function.name_prefix', 'string', check_str, '',
     'Prefix to add to external function names.',
@@ -419,6 +425,12 @@ register_option(
     environ=['SINGLESTOREDB_EXT_FUNC_NAME_SUFFIX'],
 )
 
+register_option(
+    'external_function.function_database', 'string', check_str, '',
+    'Database to use for the function definitions.',
+    environ=['SINGLESTOREDB_EXT_FUNC_FUNCTION_DATABASE'],
+)
+
 register_option(
     'external_function.connection', 'string', check_str,
     os.environ.get('SINGLESTOREDB_URL') or None,
@@ -444,6 +456,18 @@ register_option(
     environ=['SINGLESTOREDB_EXT_FUNC_TIMEOUT'],
 )
 
+register_option(
+    'external_function.disable_metrics', 'bool', check_bool, False,
+    'Disable logging of function call metrics.',
+    environ=['SINGLESTOREDB_EXT_FUNC_DISABLE_METRICS'],
+)
+
+register_option(
+    'external_function.app_name', 'string', check_str, None,
+    'Name for the external function application instance.',
+    environ=['SINGLESTOREDB_EXT_FUNC_APP_NAME'],
+)
+
 #
 # Debugging options
 #

singlestoredb/converters.py

@@ -23,7 +23,7 @@ except ImportError:
 try:
     import pygeos
     has_pygeos = True
-except ImportError:
+except (AttributeError, ImportError):
     has_pygeos = False
 
 try:

singlestoredb/docstring/__init__.py

@@ -0,0 +1,33 @@
+"""Parse docstrings as per Sphinx notation."""
+from .common import Docstring
+from .common import DocstringDeprecated
+from .common import DocstringMeta
+from .common import DocstringParam
+from .common import DocstringRaises
+from .common import DocstringReturns
+from .common import DocstringStyle
+from .common import ParseError
+from .common import RenderingStyle
+from .parser import compose
+from .parser import parse
+from .parser import parse_from_object
+from .util import combine_docstrings
+
+Style = DocstringStyle  # backwards compatibility
+
+__all__ = [
+    'parse',
+    'parse_from_object',
+    'combine_docstrings',
+    'compose',
+    'ParseError',
+    'Docstring',
+    'DocstringMeta',
+    'DocstringParam',
+    'DocstringRaises',
+    'DocstringReturns',
+    'DocstringDeprecated',
+    'DocstringStyle',
+    'RenderingStyle',
+    'Style',
+]

singlestoredb/docstring/attrdoc.py

@@ -0,0 +1,126 @@
+"""Attribute docstrings parsing.
+
+.. seealso:: https://peps.python.org/pep-0257/#what-is-a-docstring
+"""
+import ast
+import inspect
+import textwrap
+import typing as T
+from types import ModuleType
+
+from .common import Docstring
+from .common import DocstringParam
+
+
+def ast_get_constant_value(node: ast.AST) -> T.Any:
+    """Return the constant's value if the given node is a constant."""
+    return getattr(node, 'value')
+
+
+def ast_unparse(node: ast.AST) -> T.Optional[str]:
+    """Convert the AST node to source code as a string."""
+    if hasattr(ast, 'unparse'):
+        return ast.unparse(node)
+    # Support simple cases in Python < 3.9
+    if isinstance(node, ast.Constant):
+        return str(ast_get_constant_value(node))
+    if isinstance(node, ast.Name):
+        return node.id
+    return None
+
+
+def ast_is_literal_str(node: ast.AST) -> bool:
+    """Return True if the given node is a literal string."""
+    return (
+        isinstance(node, ast.Expr)
+        and isinstance(node.value, ast.Constant)
+        and isinstance(ast_get_constant_value(node.value), str)
+    )
+
+
+def ast_get_attribute(
+    node: ast.AST,
+) -> T.Optional[T.Tuple[str, T.Optional[str], T.Optional[str]]]:
+    """Return name, type and default if the given node is an attribute."""
+    if isinstance(node, (ast.Assign, ast.AnnAssign)):
+        target = (
+            node.targets[0] if isinstance(node, ast.Assign) else node.target
+        )
+        if isinstance(target, ast.Name):
+            type_str = None
+            if isinstance(node, ast.AnnAssign):
+                type_str = ast_unparse(node.annotation)
+            default = None
+            if node.value:
+                default = ast_unparse(node.value)
+            return target.id, type_str, default
+    return None
+
+
+class AttributeDocstrings(ast.NodeVisitor):
+    """An ast.NodeVisitor that collects attribute docstrings."""
+
+    attr_docs: T.Dict[str, T.Tuple[str, T.Optional[str], T.Optional[str]]] = {}
+    prev_attr = None
+
+    def visit(self, node: T.Any) -> None:
+        if self.prev_attr and ast_is_literal_str(node):
+            attr_name, attr_type, attr_default = self.prev_attr
+            self.attr_docs[attr_name] = (
+                ast_get_constant_value(node.value),
+                attr_type,
+                attr_default,
+            )
+        self.prev_attr = ast_get_attribute(node)
+        if isinstance(node, (ast.ClassDef, ast.Module)):
+            self.generic_visit(node)
+
+    def get_attr_docs(
+        self, component: T.Any,
+    ) -> T.Dict[str, T.Tuple[str, T.Optional[str], T.Optional[str]]]:
+        """Get attribute docstrings from the given component.
+
+        :param component: component to process (class or module)
+        :returns: for each attribute docstring, a tuple with (description,
+            type, default)
+        """
+        self.attr_docs = {}
+        self.prev_attr = None
+        try:
+            source = textwrap.dedent(inspect.getsource(component))
+        except OSError:
+            pass
+        else:
+            tree = ast.parse(source)
+            if inspect.ismodule(component):
+                self.visit(tree)
+            elif isinstance(tree, ast.Module) and isinstance(
+                tree.body[0], ast.ClassDef,
+            ):
+                self.visit(tree.body[0])
+        return self.attr_docs
+
+
+def add_attribute_docstrings(
+    obj: T.Union[type, ModuleType], docstring: Docstring,
+) -> None:
+    """Add attribute docstrings found in the object's source code.
+
+    :param obj: object from which to parse attribute docstrings
+    :param docstring: Docstring object where found attributes are added
+    :returns: list with names of added attributes
+    """
+    params = set(p.arg_name for p in docstring.params)
+    for arg_name, (description, type_name, default) in (
+        AttributeDocstrings().get_attr_docs(obj).items()
+    ):
+        if arg_name not in params:
+            param = DocstringParam(
+                args=['attribute', arg_name],
+                description=description,
+                arg_name=arg_name,
+                type_name=type_name,
+                is_optional=default is not None,
+                default=default,
+            )
+            docstring.meta.append(param)

singlestoredb/docstring/common.py

@@ -0,0 +1,230 @@
+"""Common methods for parsing."""
+import enum
+import typing as T
+
+PARAM_KEYWORDS = {
+    'param',
+    'parameter',
+    'arg',
+    'argument',
+    'attribute',
+    'key',
+    'keyword',
+}
+RAISES_KEYWORDS = {'raises', 'raise', 'except', 'exception'}
+DEPRECATION_KEYWORDS = {'deprecation', 'deprecated'}
+RETURNS_KEYWORDS = {'return', 'returns'}
+YIELDS_KEYWORDS = {'yield', 'yields'}
+EXAMPLES_KEYWORDS = {'example', 'examples'}
+
+
+class ParseError(RuntimeError):
+    """Base class for all parsing related errors."""
+
+
+class DocstringStyle(enum.Enum):
+    """Docstring style."""
+
+    REST = 1
+    GOOGLE = 2
+    NUMPYDOC = 3
+    EPYDOC = 4
+    AUTO = 255
+
+
+class RenderingStyle(enum.Enum):
+    """Rendering style when unparsing parsed docstrings."""
+
+    COMPACT = 1
+    CLEAN = 2
+    EXPANDED = 3
+
+
+class DocstringMeta:
+    """Docstring meta information.
+
+    Symbolizes lines in form of
+
+        :param arg: description
+        :raises ValueError: if something happens
+    """
+
+    def __init__(
+        self, args: T.List[str], description: T.Optional[str],
+    ) -> None:
+        """Initialize self.
+
+        :param args: list of arguments. The exact content of this variable is
+            dependent on the kind of docstring; it's used to distinguish
+            between custom docstring meta information items.
+        :param description: associated docstring description.
+        """
+        self.args = args
+        self.description = description
+
+
+class DocstringParam(DocstringMeta):
+    """DocstringMeta symbolizing :param metadata."""
+
+    def __init__(
+        self,
+        args: T.List[str],
+        description: T.Optional[str],
+        arg_name: str,
+        type_name: T.Optional[str],
+        is_optional: T.Optional[bool],
+        default: T.Optional[str],
+    ) -> None:
+        """Initialize self."""
+        super().__init__(args, description)
+        self.arg_name = arg_name
+        self.type_name = type_name
+        self.is_optional = is_optional
+        self.default = default
+
+
+class DocstringReturns(DocstringMeta):
+    """DocstringMeta symbolizing :returns or :yields metadata."""
+
+    def __init__(
+        self,
+        args: T.List[str],
+        description: T.Optional[str],
+        type_name: T.Optional[str],
+        is_generator: bool,
+        return_name: T.Optional[str] = None,
+    ) -> None:
+        """Initialize self."""
+        super().__init__(args, description)
+        self.type_name = type_name
+        self.is_generator = is_generator
+        self.return_name = return_name
+
+
+class DocstringRaises(DocstringMeta):
+    """DocstringMeta symbolizing :raises metadata."""
+
+    def __init__(
+        self,
+        args: T.List[str],
+        description: T.Optional[str],
+        type_name: T.Optional[str],
+    ) -> None:
+        """Initialize self."""
+        super().__init__(args, description)
+        self.type_name = type_name
+        self.description = description
+
+
+class DocstringDeprecated(DocstringMeta):
+    """DocstringMeta symbolizing deprecation metadata."""
+
+    def __init__(
+        self,
+        args: T.List[str],
+        description: T.Optional[str],
+        version: T.Optional[str],
+    ) -> None:
+        """Initialize self."""
+        super().__init__(args, description)
+        self.version = version
+        self.description = description
+
+
+class DocstringExample(DocstringMeta):
+    """DocstringMeta symbolizing example metadata."""
+
+    def __init__(
+        self,
+        args: T.List[str],
+        snippet: T.Optional[str],
+        description: T.Optional[str],
+        post_snippet: T.Optional[str] = None,
+    ) -> None:
+        """Initialize self."""
+        super().__init__(args, description)
+        self.snippet = snippet
+        self.description = description
+        self.post_snippet = post_snippet
+
+
+class Docstring:
+    """Docstring object representation."""
+
+    def __init__(
+        self,
+        style=None,  # type: T.Optional[DocstringStyle]
+    ) -> None:
+        """Initialize self."""
+        self.short_description = None  # type: T.Optional[str]
+        self.long_description = None  # type: T.Optional[str]
+        self.blank_after_short_description = False
+        self.blank_after_long_description = False
+        self.meta = []  # type: T.List[DocstringMeta]
+        self.style = style  # type: T.Optional[DocstringStyle]
+
+    @property
+    def description(self) -> T.Optional[str]:
+        """Return the full description of the function
+
+        Returns None if the docstring did not include any description
+        """
+        ret = []
+        if self.short_description:
+            ret.append(self.short_description)
+            if self.blank_after_short_description:
+                ret.append('')
+        if self.long_description:
+            ret.append(self.long_description)
+
+        if not ret:
+            return None
+
+        return '\n'.join(ret)
+
+    @property
+    def params(self) -> T.List[DocstringParam]:
+        """Return a list of information on function params."""
+        return [item for item in self.meta if isinstance(item, DocstringParam)]
+
+    @property
+    def raises(self) -> T.List[DocstringRaises]:
+        """Return a list of information on the exceptions that the function
+        may raise.
+        """
+        return [
+            item for item in self.meta if isinstance(item, DocstringRaises)
+        ]
+
+    @property
+    def returns(self) -> T.Optional[DocstringReturns]:
+        """Return a single information on function return.
+
+        Takes the first return information.
+        """
+        for item in self.meta:
+            if isinstance(item, DocstringReturns):
+                return item
+        return None
+
+    @property
+    def many_returns(self) -> T.List[DocstringReturns]:
+        """Return a list of information on function return."""
+        return [
+            item for item in self.meta if isinstance(item, DocstringReturns)
+        ]
+
+    @property
+    def deprecation(self) -> T.Optional[DocstringDeprecated]:
+        """Return a single information on function deprecation notes."""
+        for item in self.meta:
+            if isinstance(item, DocstringDeprecated):
+                return item
+        return None
+
+    @property
+    def examples(self) -> T.List[DocstringExample]:
+        """Return a list of information on function examples."""
+        return [
+            item for item in self.meta if isinstance(item, DocstringExample)
+        ]