singlestoredb 1.0.2__cp38-abi3-win_amd64.whl → 1.0.4__cp38-abi3-win_amd64.whl

singlestoredb/functions/signature.py

@@ -5,7 +5,6 @@ import numbers
 import os
 import re
 import string
-import textwrap
 import typing
 from typing import Any
 from typing import Callable
@@ -16,7 +15,6 @@ from typing import Sequence
 from typing import Tuple
 from typing import TypeVar
 from typing import Union
-from urllib.parse import urljoin
 
 try:
     import numpy as np
@@ -611,8 +609,11 @@ def dtype_to_sql(dtype: str, default: Any = None) -> str:
 
 def signature_to_sql(
     signature: Dict[str, Any],
-    base_url: Optional[str] = None,
+    url: Optional[str] = None,
     data_format: str = 'rowdat_1',
+    app_mode: str = 'remote',
+    link: Optional[str] = None,
+    replace: bool = False,
 ) -> str:
     '''
     Convert a dictionary function signature into SQL.
@@ -646,37 +647,27 @@ def signature_to_sql(
     host = os.environ.get('SINGLESTOREDB_EXT_HOST', '127.0.0.1')
     port = os.environ.get('SINGLESTOREDB_EXT_PORT', '8000')
 
-    url = urljoin(base_url or f'https://{host}:{port}', signature['endpoint'])
+    if app_mode.lower() == 'remote':
+        url = url or f'https://{host}:{port}/invoke'
+    elif url is None:
+        raise ValueError('url can not be `None`')
 
     database = ''
     if signature.get('database'):
         database = escape_name(signature['database']) + '.'
 
-    replace = 'OR REPLACE ' if signature.get('replace') else ''
+    or_replace = 'OR REPLACE ' if (bool(signature.get('replace')) or replace) else ''
 
-    return (
-        f'CREATE {replace}EXTERNAL FUNCTION {database}{escape_name(signature["name"])}' +
-        '(' + ', '.join(args) + ')' + returns +
-        f' AS REMOTE SERVICE "{url}" FORMAT {data_format.upper()};'
-    )
-
-
-def func_to_env(func: Callable[..., Any]) -> str:
-    # TODO: multiple functions
-    signature = get_signature(func)
-    env_name = signature['environment']
-    replace = 'OR REPLACE ' if signature.get('replace') else ''
-    packages = ', '.join(escape_item(x, 'utf8') for x in signature.get('packages', []))
-    resources = ', '.join(escape_item(x, 'utf8') for x in signature.get('resources', []))
-    code = inspect.getsource(func)
+    link_str = ''
+    if link:
+        if not re.match(r'^[\w_]+$', link):
+            raise ValueError(f'invalid LINK name: {link}')
+        link_str = f' LINK {link}'
 
     return (
-        f'CREATE {replace}ENVIRONMENT {env_name} LANGUAGE PYTHON ' +
-        'USING EXPORTS ' + escape_name(func.__name__) + ' ' +
-        (f'\n    PACKAGES ({packages}) ' if packages else '') +
-        (f'\n    RESOURCES ({resources}) ' if resources else '') +
-        '\n    AS CLOUD SERVICE' +
-        '\n    BEGIN\n' +
-        textwrap.indent(code, '    ') +
-        '    END;'
+        f'CREATE {or_replace}EXTERNAL FUNCTION ' +
+        f'{database}{escape_name(signature["name"])}' +
+        '(' + ', '.join(args) + ')' + returns +
+        f' AS {app_mode.upper()} SERVICE "{url}" FORMAT {data_format.upper()}'
+        f'{link_str};'
     )

singlestoredb/management/manager.py

@@ -44,10 +44,10 @@ class Manager(object):
     """SingleStoreDB manager base class."""
 
     #: Management API version if none is specified.
-    default_version = 'v1'
+    default_version = config.get_option('management.version')
 
     #: Base URL if none is specified.
-    default_base_url = 'https://api.singlestore.com'
+    default_base_url = config.get_option('management.base_url')
 
     #: Object type
     obj_type = ''

singlestoredb/management/utils.py

@@ -9,6 +9,7 @@ from typing import Any
 from typing import Callable
 from typing import Dict
 from typing import List
+from typing import Mapping
 from typing import Optional
 from typing import SupportsIndex
 from typing import TypeVar
@@ -282,3 +283,32 @@ def camel_to_snake(s: Optional[str]) -> Optional[str]:
     if out and out[0] == '_':
         return out[1:]
     return out
+
+
+def snake_to_camel_dict(
+    s: Optional[Mapping[str, Any]],
+    cap_first: bool = False,
+) -> Optional[Dict[str, Any]]:
+    """Convert snake-case keys to camel-case keys."""
+    if s is None:
+        return None
+    out = {}
+    for k, v in s.items():
+        if isinstance(s, Mapping):
+            out[str(snake_to_camel(k))] = snake_to_camel_dict(v, cap_first=cap_first)
+        else:
+            out[str(snake_to_camel(k))] = v
+    return out
+
+
+def camel_to_snake_dict(s: Optional[Mapping[str, Any]]) -> Optional[Dict[str, Any]]:
+    """Convert camel-case keys to snake-case keys."""
+    if s is None:
+        return None
+    out = {}
+    for k, v in s.items():
+        if isinstance(s, Mapping):
+            out[str(camel_to_snake(k))] = camel_to_snake_dict(v)
+        else:
+            out[str(camel_to_snake(k))] = v
+    return out

singlestoredb/management/workspace.py

@@ -7,8 +7,8 @@ import glob
 import io
 import os
 import re
-import socket
 import time
+from collections.abc import Mapping
 from typing import Any
 from typing import BinaryIO
 from typing import Dict
@@ -23,10 +23,12 @@ from .billing_usage import BillingUsageItem
 from .manager import Manager
 from .organization import Organization
 from .region import Region
+from .utils import camel_to_snake_dict
 from .utils import from_datetime
 from .utils import NamedList
 from .utils import PathLike
 from .utils import snake_to_camel
+from .utils import snake_to_camel_dict
 from .utils import to_datetime
 from .utils import ttl_property
 from .utils import vars_to_str
@@ -934,6 +936,12 @@ class Workspace(object):
         created_at: Union[str, datetime.datetime],
         terminated_at: Optional[Union[str, datetime.datetime]] = None,
         endpoint: Optional[str] = None,
+        auto_suspend: Optional[Dict[str, Any]] = None,
+        cache_config: Optional[int] = None,
+        deployment_type: Optional[str] = None,
+        resume_attachments: Optional[Dict[str, Any]] = None,
+        scaling_progress: Optional[int] = None,
+        last_resumed_at: Optional[str] = None,
     ):
         #: Name of the workspace
         self.name = name
@@ -963,6 +971,24 @@ class Workspace(object):
         #: Hostname (or IP address) of the workspace database server
         self.endpoint = endpoint
 
+        #: Current auto-suspend settings
+        self.auto_suspend = camel_to_snake_dict(auto_suspend)
+
+        #: Multiplier for the persistent cache
+        self.cache_config = cache_config
+
+        #: Deployment type of the workspace
+        self.deployment_type = deployment_type
+
+        #: Database attachments
+        self.resume_attachments = camel_to_snake_dict(resume_attachments)
+
+        #: Current progress percentage for scaling the workspace
+        self.scaling_progress = scaling_progress
+
+        #: Timestamp when workspace was last resumed
+        self.last_resumed_at = to_datetime(last_resumed_at)
+
         self._manager: Optional[WorkspaceManager] = None
 
     def __str__(self) -> str:
@@ -991,15 +1017,64 @@ class Workspace(object):
 
         """
         out = cls(
-            name=obj['name'], workspace_id=obj['workspaceID'],
+            name=obj['name'],
+            workspace_id=obj['workspaceID'],
             workspace_group=obj['workspaceGroupID'],
-            size=obj.get('size', 'Unknown'), state=obj['state'],
-            created_at=obj['createdAt'], terminated_at=obj.get('terminatedAt'),
+            size=obj.get('size', 'Unknown'),
+            state=obj['state'],
+            created_at=obj['createdAt'],
+            terminated_at=obj.get('terminatedAt'),
             endpoint=obj.get('endpoint'),
+            auto_suspend=obj.get('autoSuspend'),
+            cache_config=obj.get('cacheConfig'),
+            deployment_type=obj.get('deploymentType'),
+            last_resumed_at=obj.get('lastResumedAt'),
+            resume_attachments=obj.get('resumeAttachments'),
+            scaling_progress=obj.get('scalingProgress'),
         )
         out._manager = manager
         return out
 
+    def update(
+        self,
+        auto_suspend: Optional[Dict[str, Any]] = None,
+        cache_config: Optional[int] = None,
+        deployment_type: Optional[str] = None,
+        size: Optional[str] = None,
+    ) -> None:
+        """
+        Update the workspace definition.
+
+        Parameters
+        ----------
+        auto_suspend : Dict[str, Any], optional
+            Auto-suspend mode for the workspace: IDLE, SCHEDULED, DISABLED
+        cache_config : int, optional
+            Specifies the multiplier for the persistent cache associated
+            with the workspace. If specified, it enables the cache configuration
+            multiplier. It can have one of the following values: 1, 2, or 4.
+        deployment_type : str, optional
+            The deployment type that will be applied to all the workspaces
+            within the group
+        size : str, optional
+            Size of the workspace (in workspace size notation), such as "S-1".
+
+        """
+        if self._manager is None:
+            raise ManagementError(
+                msg='No workspace manager is associated with this object.',
+            )
+        data = {
+            k: v for k, v in dict(
+                autoSuspend=snake_to_camel_dict(auto_suspend),
+                cacheConfig=cache_config,
+                deploymentType=deployment_type,
+                size=size,
+            ).items() if v is not None
+        }
+        self._manager._patch(f'workspaces/{self.id}', json=data)
+        self.refresh()
+
     def refresh(self) -> Workspace:
         """Update the object to the current state."""
         if self._manager is None:
@@ -1008,7 +1083,10 @@ class Workspace(object):
             )
         new_obj = self._manager.get_workspace(self.id)
         for name, value in vars(new_obj).items():
-            setattr(self, name, value)
+            if isinstance(value, Mapping):
+                setattr(self, name, snake_to_camel_dict(value))
+            else:
+                setattr(self, name, value)
         return self
 
     def terminate(
@@ -1111,6 +1189,7 @@ class Workspace(object):
 
     def resume(
         self,
+        disable_auto_suspend: bool = False,
         wait_on_resumed: bool = False,
         wait_interval: int = 20,
         wait_timeout: int = 600,
@@ -1120,6 +1199,8 @@ class Workspace(object):
 
         Parameters
         ----------
+        disable_auto_suspend : bool, optional
+            Should auto-suspend be disabled?
         wait_on_resumed : bool, optional
             Wait for the workspace to go into 'Resumed' or 'Active' mode before returning
         wait_interval : int, optional
@@ -1137,7 +1218,10 @@ class Workspace(object):
             raise ManagementError(
                 msg='No workspace manager is associated with this object.',
             )
-        self._manager._post(f'workspaces/{self.id}/resume')
+        self._manager._post(
+            f'workspaces/{self.id}/resume',
+            json=dict(disableAutoSuspend=disable_auto_suspend),
+        )
         if wait_on_resumed:
             self._manager._wait_on_state(
                 self._manager.get_workspace(self.id),
@@ -1170,6 +1254,7 @@ class WorkspaceGroup(object):
         region: Optional[Region],
         firewall_ranges: List[str],
         terminated_at: Optional[Union[str, datetime.datetime]],
+        allow_all_traffic: Optional[bool],
     ):
         #: Name of the workspace group
         self.name = name
@@ -1189,6 +1274,9 @@ class WorkspaceGroup(object):
         #: Timestamp of when the workspace group was terminated
         self.terminated_at = to_datetime(terminated_at)
 
+        #: Should all traffic be allowed?
+        self.allow_all_traffic = allow_all_traffic
+
         self._manager: Optional[WorkspaceManager] = None
 
     def __str__(self) -> str:
@@ -1229,6 +1317,7 @@ class WorkspaceGroup(object):
             region=region,
             firewall_ranges=obj.get('firewallRanges', []),
             terminated_at=obj.get('terminatedAt'),
+            allow_all_traffic=obj.get('allowAllTraffic'),
         )
         out._manager = manager
         return out
@@ -1260,13 +1349,20 @@ class WorkspaceGroup(object):
             )
         new_obj = self._manager.get_workspace_group(self.id)
         for name, value in vars(new_obj).items():
-            setattr(self, name, value)
+            if isinstance(value, Mapping):
+                setattr(self, name, camel_to_snake_dict(value))
+            else:
+                setattr(self, name, value)
         return self
 
     def update(
-        self, name: Optional[str] = None,
-        admin_password: Optional[str] = None,
+        self,
+        name: Optional[str] = None,
         firewall_ranges: Optional[List[str]] = None,
+        admin_password: Optional[str] = None,
+        expires_at: Optional[str] = None,
+        allow_all_traffic: Optional[bool] = None,
+        update_window: Optional[Dict[str, int]] = None,
     ) -> None:
         """
         Update the workspace group definition.
@@ -1274,11 +1370,24 @@ class WorkspaceGroup(object):
         Parameters
         ----------
         name : str, optional
-            Workspace group name
-        admim_password : str, optional
-            Admin password for the workspace group
-        firewall_ranges : Sequence[str], optional
-            List of allowed incoming IP addresses
+            Name of the workspace group
+        firewall_ranges : list[str], optional
+            List of allowed CIDR ranges. An empty list indicates that all
+            inbound requests are allowed.
+        admin_password : str, optional
+            Admin password for the workspace group. If no password is supplied,
+            a password will be generated and retured in the response.
+        expires_at : str, optional
+            The timestamp of when the workspace group will expire.
+            If the expiration time is not specified,
+            the workspace group will have no expiration time.
+            At expiration, the workspace group is terminated and all the data is lost.
+            Expiration time can be specified as a timestamp or duration.
+            Example: "2021-01-02T15:04:05Z07:00", "2021-01-02", "3h30m"
+        allow_all_traffic : bool, optional
+            Allow all traffic to the workspace group
+        update_window : Dict[str, int], optional
+            Specify the day and hour of an update window: dict(day=0-6, hour=0-23)
 
         """
         if self._manager is None:
@@ -1287,8 +1396,12 @@ class WorkspaceGroup(object):
             )
         data = {
             k: v for k, v in dict(
-                name=name, adminPassword=admin_password,
+                name=name,
                 firewallRanges=firewall_ranges,
+                adminPassword=admin_password,
+                expiresAt=expires_at,
+                allowAllTraffic=allow_all_traffic,
+                updateWindow=snake_to_camel_dict(update_window),
             ).items() if v is not None
         }
         self._manager._patch(f'workspaceGroups/{self.id}', json=data)
@@ -1338,9 +1451,15 @@ class WorkspaceGroup(object):
                 wait_timeout -= wait_interval
 
     def create_workspace(
-        self, name: str, size: Optional[str] = None,
-        wait_on_active: bool = False, wait_interval: int = 10,
-        wait_timeout: int = 600, add_endpoint_to_firewall_ranges: bool = True,
+        self,
+        name: str,
+        size: Optional[str] = None,
+        auto_suspend: Optional[Dict[str, Any]] = None,
+        cache_config: Optional[int] = None,
+        enable_kai: Optional[bool] = None,
+        wait_on_active: bool = False,
+        wait_interval: int = 10,
+        wait_timeout: int = 600,
     ) -> Workspace:
         """
         Create a new workspace.
@@ -1351,6 +1470,15 @@ class WorkspaceGroup(object):
             Name of the workspace
         size : str, optional
             Workspace size in workspace size notation (S-00, S-1, etc.)
+        auto_suspend : Dict[str, Any], optional
+            Auto suspend settings for the workspace. If this field is not
+            provided, no settings will be enabled.
+        cache_config : int, optional
+            Specifies the multiplier for the persistent cache associated
+            with the workspace. If specified, it enables the cache configuration
+            multiplier. It can have one of the following values: 1, 2, or 4.
+        enable_kai : bool, optional
+            Whether to create a SingleStore Kai-enabled workspace
         wait_on_active : bool, optional
             Wait for the workspace to be active before returning
         wait_timeout : int, optional
@@ -1358,9 +1486,6 @@ class WorkspaceGroup(object):
             if wait=True
         wait_interval : int, optional
             Number of seconds between each polling interval
-        add_endpoint_to_firewall_ranges : bool, optional
-            Should the workspace endpoint be added to the workspace group
-            firewall ranges?
 
         Returns
         -------
@@ -1373,14 +1498,17 @@ class WorkspaceGroup(object):
             )
 
         out = self._manager.create_workspace(
-            name=name, workspace_group=self, size=size, wait_on_active=wait_on_active,
-            wait_interval=wait_interval, wait_timeout=wait_timeout,
+            name=name,
+            workspace_group=self,
+            size=size,
+            auto_suspend=snake_to_camel_dict(auto_suspend),
+            cache_config=cache_config,
+            enable_kai=enable_kai,
+            wait_on_active=wait_on_active,
+            wait_interval=wait_interval,
+            wait_timeout=wait_timeout,
         )
 
-        if add_endpoint_to_firewall_ranges and out.endpoint is not None:
-            ip_address = '{}/32'.format(socket.gethostbyname(out.endpoint))
-            self.update(firewall_ranges=self.firewall_ranges+[ip_address])
-
         return out
 
     @property
@@ -1525,9 +1653,15 @@ class WorkspaceManager(Manager):
         return NamedList([Region.from_dict(item, self) for item in res.json()])
 
     def create_workspace_group(
-        self, name: str, region: Union[str, Region],
-        firewall_ranges: List[str], admin_password: Optional[str] = None,
+        self,
+        name: str,
+        region: Union[str, Region],
+        firewall_ranges: List[str],
+        admin_password: Optional[str] = None,
+        backup_bucket_kms_key_id: Optional[str] = None,
+        data_bucket_kms_key_id: Optional[str] = None,
         expires_at: Optional[str] = None,
+        smart_dr: Optional[bool] = None,
         allow_all_traffic: Optional[bool] = None,
         update_window: Optional[Dict[str, int]] = None,
     ) -> WorkspaceGroup:
@@ -1546,6 +1680,17 @@ class WorkspaceManager(Manager):
         admin_password : str, optional
             Admin password for the workspace group. If no password is supplied,
             a password will be generated and retured in the response.
+        backup_bucket_kms_key_id : str, optional
+            Specifies the KMS key ID associated with the backup bucket.
+            If specified, enables Customer-Managed Encryption Keys (CMEK)
+            encryption for the backup bucket of the workspace group.
+            This feature is only supported in workspace groups deployed in AWS.
+        data_bucket_kms_key_id : str, optional
+            Specifies the KMS key ID associated with the data bucket.
+            If specified, enables Customer-Managed Encryption Keys (CMEK)
+            encryption for the data bucket and Amazon Elastic Block Store
+            (EBS) volumes of the workspace group. This feature is only supported
+            in workspace groups deployed in AWS.
         expires_at : str, optional
             The timestamp of when the workspace group will expire.
             If the expiration time is not specified,
@@ -1553,6 +1698,10 @@ class WorkspaceManager(Manager):
             At expiration, the workspace group is terminated and all the data is lost.
             Expiration time can be specified as a timestamp or duration.
             Example: "2021-01-02T15:04:05Z07:00", "2021-01-02", "3h30m"
+        smart_dr : bool, optional
+            Enables Smart Disaster Recovery (SmartDR) for the workspace group.
+            SmartDR is a disaster recovery solution that ensures seamless and
+            continuous replication of data from the primary region to a secondary region
         allow_all_traffic : bool, optional
             Allow all traffic to the workspace group
         update_window : Dict[str, int], optional
@@ -1569,18 +1718,28 @@ class WorkspaceManager(Manager):
             'workspaceGroups', json=dict(
                 name=name, regionID=region,
                 adminPassword=admin_password,
+                backupBucketKMSKeyID=backup_bucket_kms_key_id,
+                dataBucketKMSKeyID=data_bucket_kms_key_id,
                 firewallRanges=firewall_ranges or [],
                 expiresAt=expires_at,
+                smartDR=smart_dr,
                 allowAllTraffic=allow_all_traffic,
-                updateWindow=update_window,
+                updateWindow=snake_to_camel_dict(update_window),
             ),
         )
         return self.get_workspace_group(res.json()['workspaceGroupID'])
 
     def create_workspace(
-        self, name: str, workspace_group: Union[str, WorkspaceGroup],
-        size: Optional[str] = None, wait_on_active: bool = False,
-        wait_interval: int = 10, wait_timeout: int = 600,
+        self,
+        name: str,
+        workspace_group: Union[str, WorkspaceGroup],
+        size: Optional[str] = None,
+        auto_suspend: Optional[Dict[str, Any]] = None,
+        cache_config: Optional[int] = None,
+        enable_kai: Optional[bool] = None,
+        wait_on_active: bool = False,
+        wait_interval: int = 10,
+        wait_timeout: int = 600,
     ) -> Workspace:
         """
         Create a new workspace.
@@ -1593,6 +1752,15 @@ class WorkspaceManager(Manager):
             The workspace ID of the workspace
         size : str, optional
             Workspace size in workspace size notation (S-00, S-1, etc.)
+        auto_suspend : Dict[str, Any], optional
+            Auto suspend settings for the workspace. If this field is not
+            provided, no settings will be enabled.
+        cache_config : int, optional
+            Specifies the multiplier for the persistent cache associated
+            with the workspace. If specified, it enables the cache configuration
+            multiplier. It can have one of the following values: 1, 2, or 4.
+        enable_kai : bool, optional
+            Whether to create a SingleStore Kai-enabled workspace
         wait_on_active : bool, optional
             Wait for the workspace to be active before returning
         wait_timeout : int, optional
@@ -1610,14 +1778,20 @@ class WorkspaceManager(Manager):
             workspace_group = workspace_group.id
         res = self._post(
             'workspaces', json=dict(
-                name=name, workspaceGroupID=workspace_group,
+                name=name,
+                workspaceGroupID=workspace_group,
                 size=size,
+                autoSuspend=snake_to_camel_dict(auto_suspend),
+                cacheConfig=cache_config,
+                enableKai=enable_kai,
             ),
         )
         out = self.get_workspace(res.json()['workspaceID'])
         if wait_on_active:
             out = self._wait_on_state(
-                out, 'Active', interval=wait_interval,
+                out,
+                'Active',
+                interval=wait_interval,
                 timeout=wait_timeout,
             )
         return out

singlestoredb/tests/test_ext_func.py

@@ -65,11 +65,13 @@ def start_http_server(database, data_format='rowdat_1'):
         time.sleep(3)
         retries -= 1
 
-    app = create_app(ext_funcs)
+    app = create_app(
+        ext_funcs,
+        url=f'http://{HTTP_HOST}:{port}/invoke',
+        data_format=data_format,
+    )
     app.register_functions(
-        base_url=f'http://{HTTP_HOST}:{port}',
         database=database,
-        data_format=data_format,
     )
 
     with s2.connect(database=database) as conn:

singlestoredb/tests/test_udf.py

@@ -412,17 +412,6 @@ class TestUDF(unittest.TestCase):
         assert to_sql(foo) == '`hello``_``world`(`x` BIGINT NOT NULL) ' \
                               'RETURNS BIGINT NOT NULL'
 
-        # Add database name
-        @udf(database='mydb')
-        def foo(x: int) -> int: ...
-        assert to_sql(foo) == '`mydb`.`foo`(`x` BIGINT NOT NULL) ' \
-                              'RETURNS BIGINT NOT NULL'
-
-        @udf(database='my`db')
-        def foo(x: int) -> int: ...
-        assert to_sql(foo) == '`my``db`.`foo`(`x` BIGINT NOT NULL) ' \
-                              'RETURNS BIGINT NOT NULL'
-
     def test_dtypes(self):
         assert dt.BOOL() == 'BOOL NULL'
         assert dt.BOOL(nullable=False) == 'BOOL NOT NULL'

{singlestoredb-1.0.2.dist-info → singlestoredb-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 1.0.2
+Version: 1.0.4
 Summary: Interface to the SingleStoreDB database and workspace management APIs
 Home-page: https://github.com/singlestore-labs/singlestoredb-python
 Author: SingleStore