singlestoredb 1.15.3__tar.gz → 1.15.5__tar.gz

{singlestoredb-1.15.3/singlestoredb.egg-info → singlestoredb-1.15.5}/PKG-INFO

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

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = singlestoredb
-version = 1.15.3
+version = 1.15.5
 description = Interface to the SingleStoreDB database and workspace management APIs
 long_description = file: README.md
 long_description_content_type = text/markdown

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '1.15.3'
+__version__ = '1.15.5'
 
 from typing import Any
 

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/functions/ext/asgi.py

@@ -708,8 +708,22 @@ class Application(object):
     # Error response start
     error_response_dict: Dict[str, Any] = dict(
         type='http.response.start',
-        status=401,
-        headers=[(b'content-type', b'text/plain')],
+        status=500,
+        headers=[(b'content-type', b'application/json')],
+    )
+
+    # Timeout response start
+    timeout_response_dict: Dict[str, Any] = dict(
+        type='http.response.start',
+        status=504,
+        headers=[(b'content-type', b'application/json')],
+    )
+
+    # Cancel response start
+    cancel_response_dict: Dict[str, Any] = dict(
+        type='http.response.start',
+        status=503,
+        headers=[(b'content-type', b'application/json')],
     )
 
     # JSON response start
@@ -1233,12 +1247,14 @@ class Application(object):
                         'timeout': func_info['timeout'],
                     },
                 )
-                body = (
-                    '[TimeoutError] Function call timed out after ' +
-                    str(func_info['timeout']) +
-                    ' seconds'
+                body = json.dumps(
+                    dict(
+                        error='[TimeoutError] Function call timed out after ' +
+                        str(func_info['timeout']) +
+                        ' seconds',
+                    ),
                 ).encode('utf-8')
-                await send(self.error_response_dict)
+                await send(self.timeout_response_dict)
 
             except asyncio.CancelledError:
                 self.logger.exception(
@@ -1249,8 +1265,12 @@ class Application(object):
                         'function_name': func_name.decode('utf-8'),
                     },
                 )
-                body = b'[CancelledError] Function call was cancelled'
-                await send(self.error_response_dict)
+                body = json.dumps(
+                    dict(
+                        error='[CancelledError] Function call was cancelled',
+                    ),
+                ).encode('utf-8')
+                await send(self.cancel_response_dict)
 
             except Exception as e:
                 self.logger.exception(
@@ -1262,7 +1282,11 @@ class Application(object):
                         'exception_type': type(e).__name__,
                     },
                 )
-                body = f'[{type(e).__name__}] {str(e).strip()}'.encode('utf-8')
+                body = json.dumps(
+                    dict(
+                        error=f'[{type(e).__name__}] {str(e).strip()}',
+                    ),
+                ).encode('utf-8')
                 await send(self.error_response_dict)
 
             finally:

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/fusion/handlers/workspace.py

@@ -15,7 +15,7 @@ from .utils import get_workspace_manager
 
 class UseWorkspaceHandler(SQLHandler):
     """
-    USE WORKSPACE workspace [ with_database ];
+    USE WORKSPACE workspace [ in_group ] [ with_database ];
 
     # Workspace
     workspace = { workspace_id | workspace_name | current_workspace }
@@ -29,6 +29,15 @@ class UseWorkspaceHandler(SQLHandler):
     # Current workspace
     current_workspace = @@CURRENT
 
+    # Workspace group specification
+    in_group = IN GROUP { group_id | group_name }
+
+    # ID of workspace group
+    group_id = ID '<group-id>'
+
+    # Name of workspace group
+    group_name = '<group-name>'
+
     # Name of database
     with_database = WITH DATABASE 'database-name'
 
@@ -38,13 +47,18 @@ class UseWorkspaceHandler(SQLHandler):
 
     Arguments
     ---------
-    * ``<workspace-id>``: The ID of the workspace to delete.
-    * ``<workspace-name>``: The name of the workspace to delete.
+    * ``<workspace-id>``: The ID of the workspace to use.
+    * ``<workspace-name>``: The name of the workspace to use.
+    * ``<group-id>``: The ID of the workspace group to search in.
+    * ``<group-name>``: The name of the workspace group to search in.
 
     Remarks
     -------
     * If you want to specify a database in the current workspace,
       the workspace name can be specified as ``@@CURRENT``.
+    * Use the ``IN GROUP`` clause to specify the ID or name of the workspace
+      group where the workspace should be found. If not specified, the current
+      workspace group will be used.
     * Specify the ``WITH DATABASE`` clause to select a default
       database for the session.
     * This command only works in a notebook session in the
@@ -57,23 +71,69 @@ class UseWorkspaceHandler(SQLHandler):
 
         USE WORKSPACE 'examplews' WITH DATABASE 'dbname';
 
+    The following command sets the workspace to ``examplews`` from a specific
+    workspace group::
+
+        USE WORKSPACE 'examplews' IN GROUP 'my-workspace-group';
+
     """
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         from singlestoredb.notebook import portal
+
+        # Handle current workspace case
         if params['workspace'].get('current_workspace'):
             if params.get('with_database'):
                 portal.default_database = params['with_database']
-        elif params.get('with_database'):
-            if params['workspace'].get('workspace_name'):
-                portal.connection = params['workspace']['workspace_name'], \
-                                    params['with_database']
+            return None
+
+        # Get workspace name or ID
+        workspace_name = params['workspace'].get('workspace_name')
+        workspace_id = params['workspace'].get('workspace_id')
+
+        # If IN GROUP is specified, look up workspace in that group
+        if params.get('in_group'):
+            workspace_group = get_workspace_group(params)
+
+            if workspace_name:
+                workspace = workspace_group.workspaces[workspace_name]
+            elif workspace_id:
+                # Find workspace by ID in the specified group
+                workspace = next(
+                    (w for w in workspace_group.workspaces if w.id == workspace_id),
+                    None,
+                )
+                if workspace is None:
+                    raise KeyError(f'no workspace found with ID: {workspace_id}')
+
+            workspace_id = workspace.id
+
+        # Set workspace and database
+        if params.get('with_database'):
+            if params.get('in_group'):
+                # Use 3-element tuple: (workspace_group_id, workspace_name_or_id,
+                # database)
+                portal.connection = (  # type: ignore[assignment]
+                    workspace_group.id,
+                    workspace_name or workspace_id,
+                    params['with_database'],
+                )
             else:
-                portal.connection = params['workspace']['workspace_id'], \
-                                    params['with_database']
-        elif params['workspace'].get('workspace_name'):
-            portal.workspace = params['workspace']['workspace_name']
+                # Use 2-element tuple: (workspace_name_or_id, database)
+                portal.connection = (
+                    workspace_name or workspace_id,
+                    params['with_database'],
+                )
         else:
-            portal.workspace = params['workspace']['workspace_id']
+            if params.get('in_group'):
+                # Use 2-element tuple: (workspace_group_id, workspace_name_or_id)
+                portal.workspace = (  # type: ignore[assignment]
+                    workspace_group.id,
+                    workspace_name or workspace_id,
+                )
+            else:
+                # Use string: workspace_name_or_id
+                portal.workspace = workspace_name or workspace_id
+
         return None
 
 

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/http/connection.py

@@ -647,23 +647,24 @@ class Cursor(connection.Cursor):
                         type_code = types.ColumnType.get_code(data_type)
                         prec, scale = get_precision_scale(col['dataType'])
                         converter = http_converters.get(type_code, None)
+
                         if 'UNSIGNED' in data_type:
                             flags = 32
+
                         if data_type.endswith('BLOB') or data_type.endswith('BINARY'):
                             converter = functools.partial(
                                 b64decode_converter, converter,  # type: ignore
                             )
                             charset = 63  # BINARY
+
                         if type_code == 0:  # DECIMAL
                             type_code = types.ColumnType.get_code('NEWDECIMAL')
                         elif type_code == 15:  # VARCHAR / VARBINARY
                             type_code = types.ColumnType.get_code('VARSTRING')
-                        if type_code == 246 and prec is not None:  # NEWDECIMAL
-                            prec += 1  # for sign
-                            if scale is not None and scale > 0:
-                                prec += 1  # for decimal
+
                         if converter is not None:
                             convs.append((i, None, converter))
+
                         description.append(
                             Description(
                                 str(col['name']), type_code,
@@ -673,6 +674,7 @@ class Cursor(connection.Cursor):
                             ),
                         )
                         pymy_res.append(PyMyField(col['name'], flags, charset))
+
                     self._descriptions.append(description)
                     self._schemas.append(get_schema(self._results_type, description))
 
@@ -936,7 +938,7 @@ class Cursor(connection.Cursor):
 
     def __iter__(self) -> Iterable[Tuple[Any, ...]]:
         """Return result iterator."""
-        return iter(self._rows)
+        return iter(self._rows[self._row_idx:])
 
     def __enter__(self) -> 'Cursor':
         """Enter a context."""

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/management/workspace.py

@@ -460,7 +460,7 @@ class Stage(FileLocation):
 
         """
         res = self._manager._get(
-            f'stage/{self._deployment_id}/fs/{stage_path}',
+            re.sub(r'/+$', r'/', f'stage/{self._deployment_id}/fs/{stage_path}'),
         ).json()
         if recursive:
             out = []

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/mysql/protocol.py

@@ -324,13 +324,26 @@ class FieldDescriptorPacket(MysqlPacket):
                 raise TypeError(f'unrecognized extended data type: {ext_type_code}')
 
     def description(self):
-        """Provides a 7-item tuple compatible with the Python PEP249 DB Spec."""
+        """
+        Provides a 9-item tuple.
+
+        Standard descriptions only have 7 fields according to the Python
+        PEP249 DB Spec, but we need to surface information about unsigned
+        types and charsetnr for proper type handling.
+
+        """
+        precision = self.get_column_length()
+        if self.type_code in (FIELD_TYPE.DECIMAL, FIELD_TYPE.NEWDECIMAL):
+            if precision:
+                precision -= 1  # for the sign
+                if self.scale > 0:
+                    precision -= 1  # for the decimal point
         return Description(
             self.name,
             self.type_code,
             None,  # TODO: display_length; should this be self.length?
             self.get_column_length(),  # 'internal_size'
-            self.get_column_length(),  # 'precision'  # TODO: why!?!?
+            precision,  # 'precision'
             self.scale,
             self.flags % 2 == 0,
             self.flags,

{singlestoredb-1.15.3 → singlestoredb-1.15.5}/singlestoredb/notebook/_portal.py

@@ -10,6 +10,7 @@ from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Tuple
+from typing import Union
 
 from . import _objects as obj
 from ..management import workspace as mgr
@@ -167,15 +168,32 @@ class Portal(object):
         return obj.workspace
 
     @workspace.setter
-    def workspace(self, name_or_id: str) -> None:
+    def workspace(self, workspace_spec: Union[str, Tuple[str, str]]) -> None:
         """Set workspace."""
-        if re.match(
-            r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}',
-            name_or_id, flags=re.I,
-        ):
-            w = mgr.get_workspace(name_or_id)
+        if isinstance(workspace_spec, tuple):
+            # 2-element tuple: (workspace_group_id, workspace_name_or_id)
+            workspace_group_id, name_or_id = workspace_spec
+            uuid_pattern = (
+                r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}'
+            )
+            if re.match(uuid_pattern, name_or_id, flags=re.I):
+                w = mgr.get_workspace(name_or_id)
+            else:
+                w = mgr.get_workspace_group(workspace_group_id).workspaces[
+                    name_or_id
+                ]
         else:
-            w = mgr.get_workspace_group(self.workspace_group_id).workspaces[name_or_id]
+            # String: workspace_name_or_id (existing behavior)
+            name_or_id = workspace_spec
+            uuid_pattern = (
+                r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}'
+            )
+            if re.match(uuid_pattern, name_or_id, flags=re.I):
+                w = mgr.get_workspace(name_or_id)
+            else:
+                w = mgr.get_workspace_group(
+                    self.workspace_group_id,
+                ).workspaces[name_or_id]
 
         if w.state and w.state.lower() not in ['active', 'resumed']:
             raise RuntimeError('workspace is not active')
@@ -196,16 +214,37 @@ class Portal(object):
         return self.workspace, self.default_database
 
     @connection.setter
-    def connection(self, workspace_and_default_database: Tuple[str, str]) -> None:
+    def connection(
+        self,
+        connection_spec: Union[Tuple[str, str], Tuple[str, str, str]],
+    ) -> None:
         """Set workspace and default database name."""
-        name_or_id, default_database = workspace_and_default_database
-        if re.match(
-            r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}',
-            name_or_id, flags=re.I,
-        ):
-            w = mgr.get_workspace(name_or_id)
+        if len(connection_spec) == 3:
+            # 3-element tuple: (workspace_group_id, workspace_name_or_id,
+            # default_database)
+            workspace_group_id, name_or_id, default_database = connection_spec
+            uuid_pattern = (
+                r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}'
+            )
+            if re.match(uuid_pattern, name_or_id, flags=re.I):
+                w = mgr.get_workspace(name_or_id)
+            else:
+                w = mgr.get_workspace_group(workspace_group_id).workspaces[
+                    name_or_id
+                ]
         else:
-            w = mgr.get_workspace_group(self.workspace_group_id).workspaces[name_or_id]
+            # 2-element tuple: (workspace_name_or_id, default_database)
+            # existing behavior
+            name_or_id, default_database = connection_spec
+            uuid_pattern = (
+                r'[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}'
+            )
+            if re.match(uuid_pattern, name_or_id, flags=re.I):
+                w = mgr.get_workspace(name_or_id)
+            else:
+                w = mgr.get_workspace_group(
+                    self.workspace_group_id,
+                ).workspaces[name_or_id]
 
         if w.state and w.state.lower() not in ['active', 'resumed']:
             raise RuntimeError('workspace is not active')