singlestoredb 1.7.2__cp38-abi3-win_amd64.whl → 1.8.0__cp38-abi3-win_amd64.whl

singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '1.7.2'
+__version__ = '1.8.0'
 
 from typing import Any
 

singlestoredb/fusion/handler.py

@@ -11,6 +11,7 @@ from typing import Dict
 from typing import Iterable
 from typing import List
 from typing import Optional
+from typing import Set
 from typing import Tuple
 
 from parsimonious import Grammar
@@ -23,9 +24,9 @@ from ..connection import Connection
 
 CORE_GRAMMAR = r'''
     ws = ~r"(\s+|(\s*/\*.*\*/\s*)+)"
-    qs = ~r"\"([^\"]*)\"|'([^\']*)'|`([^\`]*)`|([A-Za-z0-9_\-\.]+)"
-    number = ~r"[-+]?(\d*\.)?\d+(e[-+]?\d+)?"i
-    integer = ~r"-?\d+"
+    qs = ~r"\"([^\"]*)\"|'([^\']*)'|([A-Za-z0-9_\-\.]+)|`([^\`]+)`" ws*
+    number = ~r"[-+]?(\d*\.)?\d+(e[-+]?\d+)?"i ws*
+    integer = ~r"-?\d+" ws*
     comma = ws* "," ws*
     eq = ws* "=" ws*
     open_paren = ws* "(" ws*
@@ -33,6 +34,10 @@ CORE_GRAMMAR = r'''
     open_repeats = ws* ~r"[\(\[\{]" ws*
     close_repeats = ws* ~r"[\)\]\}]" ws*
     select = ~r"SELECT"i ws+ ~r".+" ws*
+    table = ~r"(?:([A-Za-z0-9_\-]+)|`([^\`]+)`)(?:\.(?:([A-Za-z0-9_\-]+)|`([^\`]+)`))?" ws*
+    column = ~r"(?:([A-Za-z0-9_\-]+)|`([^\`]+)`)(?:\.(?:([A-Za-z0-9_\-]+)|`([^\`]+)`))?" ws*
+    link_name = ~r"(?:([A-Za-z0-9_\-]+)|`([^\`]+)`)(?:\.(?:([A-Za-z0-9_\-]+)|`([^\`]+)`))?" ws*
+    catalog_name = ~r"(?:([A-Za-z0-9_\-]+)|`([^\`]+)`)(?:\.(?:([A-Za-z0-9_\-]+)|`([^\`]+)`))?" ws*
 
     json = ws* json_object ws*
     json_object = ~r"{\s*" json_members? ~r"\s*}"
@@ -65,6 +70,10 @@ BUILTINS = {
     '<integer>': '',
     '<number>': '',
     '<json>': '',
+    '<table>': '',
+    '<column>': '',
+    '<catalog-name>': '',
+    '<link-name>': '',
 }
 
 BUILTIN_DEFAULTS = {  # type: ignore
@@ -226,9 +235,13 @@ def build_syntax(grammar: str) -> str:
     # Split on ';' on a line by itself
     cmd, end = grammar.split(';', 1)
 
-    rules = {}
+    name = ''
+    rules: Dict[str, Any] = {}
     for line in end.split('\n'):
         line = line.strip()
+        if line.startswith('&'):
+            rules[name] += '\n' + line
+            continue
         if not line:
             continue
         name, value = line.split('=', 1)
@@ -239,10 +252,16 @@ def build_syntax(grammar: str) -> str:
     while re.search(r' [a-z0-9_]+\b', cmd):
         cmd = re.sub(r' ([a-z0-9_]+)\b', functools.partial(expand_rules, rules), cmd)
 
+    def add_indent(m: Any) -> str:
+        return '    ' + (len(m.group(1)) * '    ')
+
+    # Indent line-continuations
+    cmd = re.sub(r'^(\&+)\s*', add_indent, cmd, flags=re.M)
+
     cmd = textwrap.dedent(cmd).rstrip() + ';'
-    cmd = re.sub(r'  +', ' ', cmd)
-    cmd = re.sub(r'^ ', '    ', cmd, flags=re.M)
-    cmd = re.sub(r'\s+,\.\.\.', ',...', cmd)
+    cmd = re.sub(r'(\S)  +', r'\1 ', cmd)
+    cmd = re.sub(r'<comma>', ',', cmd)
+    cmd = re.sub(r'\s+,\s*\.\.\.', ',...', cmd)
 
     return cmd
 
@@ -399,9 +418,15 @@ def process_grammar(
     help_txt = build_help(syntax_txt, full_grammar)
     grammar = build_cmd(grammar)
 
+    # Remove line-continuations
+    grammar = re.sub(r'\n\s*&+', r'', grammar)
+
     # Make sure grouping characters all have whitespace around them
     grammar = re.sub(r' *(\[|\{|\||\}|\]) *', r' \1 ', grammar)
 
+    grammar = re.sub(r'\(', r' open_paren ', grammar)
+    grammar = re.sub(r'\)', r' close_paren ', grammar)
+
     for line in grammar.split('\n'):
         if not line.strip():
             continue
@@ -418,7 +443,7 @@ def process_grammar(
         sql = re.sub(r'\]\s+\[', r' | ', sql)
 
         # Lower-case keywords and make them case-insensitive
-        sql = re.sub(r'(\b|@+)([A-Z0-9]+)\b', lower_and_regex, sql)
+        sql = re.sub(r'(\b|@+)([A-Z0-9_]+)\b', lower_and_regex, sql)
 
         # Convert literal strings to 'qs'
         sql = re.sub(r"'[^']+'", r'qs', sql)
@@ -461,12 +486,18 @@ def process_grammar(
         sql = re.sub(r'\s+ws$', r' ws*', sql)
         sql = re.sub(r'\s+ws\s+\(', r' ws* (', sql)
         sql = re.sub(r'\)\s+ws\s+', r') ws* ', sql)
-        sql = re.sub(r'\s+ws\s+', r' ws+ ', sql)
+        sql = re.sub(r'\s+ws\s+', r' ws* ', sql)
         sql = re.sub(r'\?\s+ws\+', r'? ws*', sql)
 
         # Remove extra ws around eq
         sql = re.sub(r'ws\+\s*eq\b', r'eq', sql)
 
+        # Remove optional groupings when mandatory groupings are specified
+        sql = re.sub(r'open_paren\s+ws\*\s+open_repeats\?', r'open_paren', sql)
+        sql = re.sub(r'close_repeats\?\s+ws\*\s+close_paren', r'close_paren', sql)
+        sql = re.sub(r'open_paren\s+open_repeats\?', r'open_paren', sql)
+        sql = re.sub(r'close_repeats\?\s+close_paren', r'close_paren', sql)
+
         out.append(f'{op} = {sql}')
 
     for k, v in list(rules.items()):
@@ -548,6 +579,7 @@ class SQLHandler(NodeVisitor):
 
     def __init__(self, connection: Connection):
         self.connection = connection
+        self._handled: Set[str] = set()
 
     @classmethod
     def compile(cls, grammar: str = '') -> None:
@@ -614,12 +646,16 @@ class SQLHandler(NodeVisitor):
         )
 
         type(self).compile()
+        self._handled = set()
         try:
             params = self.visit(type(self).grammar.parse(sql))
             for k, v in params.items():
                 params[k] = self.validate_rule(k, v)
 
             res = self.run(params)
+
+            self._handled = set()
+
             if res is not None:
                 res.format_results(self.connection)
                 return res
@@ -666,16 +702,20 @@ class SQLHandler(NodeVisitor):
         """Quoted strings."""
         if node is None:
             return None
-        return node.match.group(1) or node.match.group(2) or \
-            node.match.group(3) or node.match.group(4)
+        return flatten(visited_children)[0]
+
+    def visit_compound(self, node: Node, visited_children: Iterable[Any]) -> Any:
+        """Compound name."""
+        print(visited_children)
+        return flatten(visited_children)[0]
 
     def visit_number(self, node: Node, visited_children: Iterable[Any]) -> Any:
         """Numeric value."""
-        return float(node.match.group(0))
+        return float(flatten(visited_children)[0])
 
     def visit_integer(self, node: Node, visited_children: Iterable[Any]) -> Any:
         """Integer value."""
-        return int(node.match.group(0))
+        return int(flatten(visited_children)[0])
 
     def visit_ws(self, node: Node, visited_children: Iterable[Any]) -> Any:
         """Whitespace and comments."""
@@ -804,19 +844,29 @@ class SQLHandler(NodeVisitor):
             if node.expr_name.endswith('_cmd'):
                 final = merge_dicts(flatten(visited_children)[n_keywords:])
                 for k, v in type(self).rule_info.items():
-                    if k.endswith('_cmd') or k.endswith('_'):
+                    if k.endswith('_cmd') or k.endswith('_') or k.startswith('_'):
                         continue
-                    if k not in final:
+                    if k not in final and k not in self._handled:
                         final[k] = BUILTIN_DEFAULTS.get(k, v['default'])
                 return final
 
             # Filter out stray empty strings
             out = [x for x in flatten(visited_children)[n_keywords:] if x]
 
-            if repeats or len(out) > 1:
-                return {node.expr_name: out}
+            # Remove underscore prefixes from rule name
+            key_name = re.sub(r'^_+', r'', node.expr_name)
 
-            return {node.expr_name: out[0] if out else True}
+            if repeats or len(out) > 1:
+                self._handled.add(node.expr_name)
+                # If all outputs are dicts, merge them
+                if len(out) > 1 and not repeats:
+                    is_dicts = [x for x in out if isinstance(x, dict)]
+                    if len(is_dicts) == len(out):
+                        return {key_name: merge_dicts(out)}
+                return {key_name: out}
+
+            self._handled.add(node.expr_name)
+            return {key_name: out[0] if out else True}
 
         if hasattr(node, 'match'):
             if not visited_children and not node.match.groups():

singlestoredb/fusion/handlers/export.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+import json
+from typing import Any
+from typing import Dict
+from typing import Optional
+
+from .. import result
+from ...management.export import Catalog
+from ...management.export import ExportService
+from ...management.export import ExportStatus
+from ...management.export import Link
+from ..handler import SQLHandler
+from ..result import FusionSQLResult
+from .utils import get_workspace_group
+
+
+class CreateClusterIdentity(SQLHandler):
+    """
+    CREATE CLUSTER IDENTITY
+        catalog
+        storage
+    ;
+
+    # Catolog
+    catalog = CATALOG { _catalog_config | _catalog_creds }
+    _catalog_config = CONFIG '<catalog-config>'
+    _catalog_creds = CREDENTIALS '<catalog-creds>'
+
+    # Storage
+    storage = LINK { _link_config | _link_creds }
+    _link_config = S3 CONFIG '<link-config>'
+    _link_creds = CREDENTIALS '<link-creds>'
+
+    Description
+    -----------
+    Create a cluster identity for allowing the export service to access
+    external cloud resources.
+
+    Arguments
+    ---------
+    * ``<catalog-config>`` and ``<catalog-creds>``: Catalog configuration
+      and credentials in JSON format.
+    * ``<link-config>`` and ``<link-creds>``: Storage link configuration
+      and credentials in JSON format.
+
+    Remarks
+    -------
+    * ``FROM <table>`` specifies the SingleStore table to export. The same name will
+      be used for the exported table.
+    * ``CATALOG`` specifies the details of the catalog to connect to.
+    * ``LINK`` specifies the details of the data storage to connect to.
+
+    Example
+    -------
+    The following statement creates a cluster identity for the catalog
+    and link::
+
+        CREATE CLUSTER IDENTITY
+            CATALOG CONFIG '{
+                "type": "GLUE",
+                "table_format": "ICEBERG",
+                "id": "13983498723498",
+                "region": "us-east-1"
+            }'
+            LINK S3 CONFIG '{
+                "region": "us-east-1",
+                "endpoint_url": "s3://bucket-name"
+
+            }'
+        ;
+
+    """
+
+    _enabled = False
+
+    def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
+        # Catalog
+        catalog_config = json.loads(params['catalog'].get('catalog_config', '{}') or '{}')
+        catalog_creds = json.loads(params['catalog'].get('catalog_creds', '{}') or '{}')
+
+        # Storage
+        storage_config = json.loads(params['storage'].get('link_config', '{}') or '{}')
+        storage_creds = json.loads(params['storage'].get('link_creds', '{}') or '{}')
+
+        wsg = get_workspace_group({})
+
+        if wsg._manager is None:
+            raise TypeError('no workspace manager is associated with workspace group')
+
+        out = ExportService(
+            wsg,
+            'none',
+            'none',
+            Catalog.from_config_and_creds(catalog_config, catalog_creds, wsg._manager),
+            Link.from_config_and_creds('S3', storage_config, storage_creds, wsg._manager),
+            columns=None,
+        ).create_cluster_identity()
+
+        res = FusionSQLResult()
+        res.add_field('RoleARN', result.STRING)
+        res.set_rows([(out['roleARN'],)])
+
+        return res
+
+
+CreateClusterIdentity.register(overwrite=True)
+
+
+class CreateExport(SQLHandler):
+    """
+    START EXPORT
+        from_table
+        catalog
+        storage
+    ;
+
+    # From table
+    from_table = FROM <table>
+
+    # Catolog
+    catalog = CATALOG [ _catalog_config ] [ _catalog_creds ]
+    _catalog_config = CONFIG '<catalog-config>'
+    _catalog_creds = CREDENTIALS '<catalog-creds>'
+
+    # Storage
+    storage = LINK [ _link_config ] [ _link_creds ]
+    _link_config = S3 CONFIG '<link-config>'
+    _link_creds = CREDENTIALS '<link-creds>'
+
+    Description
+    -----------
+    Create an export configuration.
+
+    Arguments
+    ---------
+    * ``<catalog-config>`` and ``<catalog-creds>``: The catalog configuration.
+    * ``<link-config>`` and ``<link-creds>``: The storage link configuration.
+
+    Remarks
+    -------
+    * ``FROM <table>`` specifies the SingleStore table to export. The same name will
+      be used for the exported table.
+    * ``CATALOG`` specifies the details of the catalog to connect to.
+    * ``LINK`` specifies the details of the data storage to connect to.
+
+    Examples
+    --------
+    The following statement starts an export operation with the given
+    catalog and link configurations. The source table to export is
+    named "customer_data"::
+
+        START EXPORT FROM customer_data
+            CATALOG CONFIG '{
+                "type": "GLUE",
+                "table_format": "ICEBERG",
+                "id": "13983498723498",
+                "region": "us-east-1"
+            }'
+            LINK S3 CONFIG '{
+                "region": "us-east-1",
+                "endpoint_url": "s3://bucket-name"
+
+            }'
+        ;
+
+    """  # noqa
+
+    _enabled = False
+
+    def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
+        # From table
+        if isinstance(params['from_table'], str):
+            from_database = None
+            from_table = params['from_table']
+        else:
+            from_database, from_table = params['from_table']
+
+        # Catalog
+        catalog_config = json.loads(params['catalog'].get('catalog_config', '{}') or '{}')
+        catalog_creds = json.loads(params['catalog'].get('catalog_creds', '{}') or '{}')
+
+        # Storage
+        storage_config = json.loads(params['storage'].get('link_config', '{}') or '{}')
+        storage_creds = json.loads(params['storage'].get('link_creds', '{}') or '{}')
+
+        wsg = get_workspace_group({})
+
+        if from_database is None:
+            raise ValueError('database name must be specified for source table')
+
+        if wsg._manager is None:
+            raise TypeError('no workspace manager is associated with workspace group')
+
+        out = ExportService(
+            wsg,
+            from_database,
+            from_table,
+            Catalog.from_config_and_creds(catalog_config, catalog_creds, wsg._manager),
+            Link.from_config_and_creds('S3', storage_config, storage_creds, wsg._manager),
+            columns=None,
+        ).start()
+
+        res = FusionSQLResult()
+        res.add_field('ExportID', result.STRING)
+        res.set_rows([(out.export_id,)])
+
+        return res
+
+
+CreateExport.register(overwrite=True)
+
+
+class ShowExport(SQLHandler):
+    """
+    SHOW EXPORT export_id;
+
+    # ID of export
+    export_id = '<export-id>'
+
+    """
+
+    _enabled = False
+
+    def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
+        wsg = get_workspace_group({})
+        out = ExportStatus(params['export_id'], wsg)
+
+        status = out._info()
+
+        res = FusionSQLResult()
+        res.add_field('ExportID', result.STRING)
+        res.add_field('Status', result.STRING)
+        res.add_field('Message', result.STRING)
+        res.set_rows([
+            (
+                params['export_id'],
+                status.get('status', 'Unknown'),
+                status.get('statusMsg', ''),
+            ),
+        ])
+
+        return res
+
+
+ShowExport.register(overwrite=True)

singlestoredb/fusion/handlers/job.py

@@ -122,8 +122,6 @@ class ScheduleJobHandler(SQLHandler):
         ;
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('JobID', result.STRING)
@@ -138,8 +136,8 @@ class ScheduleJobHandler(SQLHandler):
 
         execution_interval_in_mins = None
         if params.get('execute_every'):
-            execution_interval_in_mins = params['execute_every'][0]['interval']
-            time_unit = params['execute_every'][-1]['time_unit'].upper()
+            execution_interval_in_mins = params['execute_every']['interval']
+            time_unit = params['execute_every']['time_unit'].upper()
             if time_unit == 'MINUTES':
                 pass
             elif time_unit == 'HOURS':
@@ -224,8 +222,6 @@ class RunJobHandler(SQLHandler):
 
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('JobID', result.STRING)
@@ -288,8 +284,6 @@ class WaitOnJobsHandler(SQLHandler):
 
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('Success', result.BOOL)
@@ -298,8 +292,8 @@ class WaitOnJobsHandler(SQLHandler):
 
         timeout_in_secs = None
         if params.get('with_timeout'):
-            timeout_in_secs = params['with_timeout'][0]['time']
-            time_unit = params['with_timeout'][-1]['time_unit'].upper()
+            timeout_in_secs = params['with_timeout']['time']
+            time_unit = params['with_timeout']['time_unit'].upper()
             if time_unit == 'SECONDS':
                 pass
             elif time_unit == 'MINUTES':
@@ -359,8 +353,6 @@ class ShowJobsHandler(SQLHandler):
 
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('JobID', result.STRING)
@@ -492,8 +484,6 @@ class ShowJobExecutionsHandler(SQLHandler):
           EXTENDED;
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('ExecutionID', result.STRING)
@@ -564,8 +554,6 @@ class ShowJobParametersHandler(SQLHandler):
         SHOW JOB PARAMETERS FOR 'job1';
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('Name', result.STRING)
@@ -606,8 +594,6 @@ class ShowJobRuntimesHandler(SQLHandler):
         SHOW JOB RUNTIMES;
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('Name', result.STRING)
@@ -653,8 +639,6 @@ class DropJobHandler(SQLHandler):
         DROP JOBS 'job1', 'job2';
     """
 
-    _enabled = False
-
     def run(self, params: Dict[str, Any]) -> Optional[FusionSQLResult]:
         res = FusionSQLResult()
         res.add_field('JobID', result.STRING)

singlestoredb/management/export.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+"""SingleStoreDB export service."""
+from __future__ import annotations
+
+import abc
+import re
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from .. import ManagementError
+from .utils import vars_to_str
+from .workspace import WorkspaceGroup
+from .workspace import WorkspaceManager
+
+
+class Link(object):
+    """Generic storage base class."""
+    scheme: str = 'unknown'
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return vars_to_str(self)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return str(self)
+
+    @abc.abstractmethod
+    def to_storage_location(self) -> Dict[str, Any]:
+        raise NotImplementedError
+
+    @classmethod
+    def from_config_and_creds(
+        cls,
+        scheme: str,
+        config: Dict[str, Any],
+        credentials: Dict[str, Any],
+        manager: 'WorkspaceManager',
+    ) -> 'Link':
+        out_cls = None
+        for c in cls.__subclasses__():
+            if c.scheme == scheme.upper():
+                out_cls = c
+                break
+
+        if out_cls is None:
+            raise TypeError(f'No link class found for given information: {scheme}')
+
+        return out_cls.from_config_and_creds(scheme, config, credentials, manager)
+
+
+class S3Link(Link):
+    """S3 link."""
+
+    scheme: str = 'S3'
+    region: str
+    storage_base_url: str
+
+    def __init__(self, region: str, storage_base_url: str):
+        self.region = region
+        self.storage_base_url = storage_base_url
+        self._manager: Optional[WorkspaceManager] = None
+
+    def to_storage_location(self) -> Dict[str, Any]:
+        return dict(
+            storageBaseURL=self.storage_base_url,
+            storageRegion=self.region,
+        )
+
+    @classmethod
+    def from_config_and_creds(
+        cls,
+        scheme: str,
+        config: Dict[str, Any],
+        credentials: Dict[str, Any],
+        manager: 'WorkspaceManager',
+    ) -> 'S3Link':
+        assert scheme.upper() == cls.scheme
+
+        params: Dict[str, Any] = {}
+        params.update(config)
+        params.update(credentials)
+
+        assert params.get('region'), 'region is required'
+        assert params.get('endpoint_url'), 'endpoint_url is required'
+
+        out = cls(params['region'], params['endpoint_url'])
+        out._manager = manager
+        return out
+
+
+class Catalog(object):
+    """Generic catalog base class."""
+
+    catalog_type: str = 'UNKNOWN'
+    table_format: str = 'UNKNOWN'
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return vars_to_str(self)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return str(self)
+
+    @classmethod
+    def from_config_and_creds(
+        cls,
+        config: Dict[str, Any],
+        credentials: Dict[str, Any],
+        manager: 'WorkspaceManager',
+    ) -> 'Catalog':
+        catalog_type = config['type'].upper()
+        table_format = config['table_format'].upper()
+
+        out_cls = None
+        for c in cls.__subclasses__():
+            if c.catalog_type == catalog_type and c.table_format == table_format:
+                out_cls = c
+                break
+
+        if out_cls is None:
+            raise TypeError(f'No catalog class found for given information: {config}')
+
+        return out_cls.from_config_and_creds(config, credentials, manager)
+
+    @abc.abstractmethod
+    def to_catalog_info(self) -> Dict[str, Any]:
+        """Return a catalog info dictionary."""
+        raise NotImplementedError
+
+
+class IcebergGlueCatalog(Catalog):
+    """Iceberg glue catalog."""
+
+    table_format = 'ICEBERG'
+    catalog_type = 'GLUE'
+
+    region: str
+    catalog_id: str
+
+    def __init__(self, region: str, catalog_id: str):
+        self.region = region
+        self.catalog_id = catalog_id
+        self._manager: Optional[WorkspaceManager] = None
+
+    @classmethod
+    def from_config_and_creds(
+        cls,
+        config: Dict[str, Any],
+        credentials: Dict[str, Any],
+        manager: 'WorkspaceManager',
+    ) -> 'IcebergGlueCatalog':
+        params = {}
+        params.update(config)
+        params.update(credentials)
+
+        out = cls(
+            region=params['region'],
+            catalog_id=params['id'],
+        )
+        out._manager = manager
+        return out
+
+    def to_catalog_info(self) -> Dict[str, Any]:
+        """Return a catalog info dictionary."""
+        return dict(
+            catalogSource=self.catalog_type,
+            tableFormat=self.table_format,
+            glueRegion=self.region,
+            glueCatalogID=self.catalog_id,
+        )
+
+
+class ExportService(object):
+    """Export service."""
+
+    database: str
+    table: str
+    catalog: Catalog
+    storage_link: Link
+    columns: Optional[List[str]]
+
+    def __init__(
+        self,
+        workspace_group: WorkspaceGroup,
+        database: str,
+        table: str,
+        catalog: Catalog,
+        storage_link: Link,
+        columns: Optional[List[str]],
+    ):
+        #: Workspace group
+        self.workspace_group = workspace_group
+
+        #: Name of SingleStoreDB database
+        self.database = database
+
+        #: Name of SingleStoreDB table
+        self.table = table
+
+        #: List of columns to export
+        self.columns = columns
+
+        #: Catalog
+        self.catalog = catalog
+
+        #: Storage
+        self.storage_link = storage_link
+
+        self._manager: Optional[WorkspaceManager] = workspace_group._manager
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return vars_to_str(self)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        return str(self)
+
+    def create_cluster_identity(self) -> Dict[str, Any]:
+        """Create a cluster identity."""
+        if self._manager is None:
+            raise ManagementError(
+                msg='No workspace manager is associated with this object.',
+            )
+
+        if not isinstance(self.catalog, IcebergGlueCatalog):
+            raise TypeError('Only Iceberg Glue catalog is supported at this time.')
+
+        if not isinstance(self.storage_link, S3Link):
+            raise TypeError('Only S3 links are supported at this time.')
+
+        out = self._manager._post(
+            f'workspaceGroups/{self.workspace_group.id}/'
+            'egress/createEgressClusterIdentity',
+            json=dict(
+                storageBucketName=re.split(
+                    r'/+', self.storage_link.storage_base_url,
+                )[1],
+                glueRegion=self.catalog.region,
+                glueCatalogID=self.catalog.catalog_id,
+            ),
+        )
+
+        return out.json()
+
+    def start(self, tags: Optional[List[str]] = None) -> 'ExportStatus':
+        """Start the export process."""
+        if self._manager is None:
+            raise ManagementError(
+                msg='No workspace manager is associated with this object.',
+            )
+
+        if not isinstance(self.storage_link, S3Link):
+            raise TypeError('Only S3 links are supported at this time.')
+
+        out = self._manager._post(
+            f'workspaceGroups/{self.workspace_group.id}/egress/startTableEgress',
+            json=dict(
+                databaseName=self.database,
+                tableName=self.table,
+                storageLocation=self.storage_link.to_storage_location(),
+                catalogInfo=self.catalog.to_catalog_info(),
+            ),
+        )
+
+        return ExportStatus(out.json()['egressID'], self.workspace_group)
+
+
+class ExportStatus(object):
+
+    export_id: str
+
+    def __init__(self, export_id: str, workspace_group: WorkspaceGroup):
+        self.export_id = export_id
+        self.workspace_group = workspace_group
+        self._manager: Optional[WorkspaceManager] = workspace_group._manager
+
+    def _info(self) -> Dict[str, Any]:
+        """Return export status."""
+        if self._manager is None:
+            raise ManagementError(
+                msg='No workspace manager is associated with this object.',
+            )
+
+        out = self._manager._post(
+            f'workspaceGroups/{self.workspace_group.id}/egress/tableEgressStatus',
+            json=dict(egressID=self.export_id),
+        )
+
+        return out.json()
+
+    @property
+    def status(self) -> str:
+        """Return export status."""
+        return self._info().get('status', 'Unknown')
+
+    @property
+    def message(self) -> str:
+        """Return export status message."""
+        return self._info().get('statusMsg', '')
+
+    def __str__(self) -> str:
+        return self.status
+
+    def __repr__(self) -> str:
+        return self.status

singlestoredb/tests/test_fusion.py

@@ -465,10 +465,6 @@ class TestWorkspaceFusion(unittest.TestCase):
                 pass
 
 
-@unittest.skipIf(
-    os.environ.get('SINGLESTOREDB_FUSION_ENABLE_HIDDEN', '0') == '0',
-    'Hidden Fusion commands are not enabled.',
-)
 @pytest.mark.management
 class TestJobsFusion(unittest.TestCase):
 

{singlestoredb-1.7.2.dist-info → singlestoredb-1.8.0.dist-info}/METADATA

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

{singlestoredb-1.7.2.dist-info → singlestoredb-1.8.0.dist-info}/RECORD

@@ -1,10 +1,11 @@
-_singlestoredb_accel.pyd,sha256=74y_1TpqSVFQ-rTN7XE73b1dJ16kA-s1K57dV-NmkEY,59392
-singlestoredb/__init__.py,sha256=jSf2uwMGpvrTEf60dTZMxvO63yzzmKGE12bZUuCMOQA,1697
+_singlestoredb_accel.pyd,sha256=171M2RAd2r65yxD9_Yx-5PW3HWkw6hI5bCs99qKUrWI,59392
+singlestoredb/__init__.py,sha256=YzFLtsA1I_g42ghOHzVvbTkNTFzBTqkclAYTShE_N3M,1697
 singlestoredb/auth.py,sha256=RmYiH0Wlc2RXc4pTlRMysxtBI445ggCIwojWKC_eDLE,7844
 singlestoredb/config.py,sha256=LlrwKor_23uA9u7jWBYb-IaOKs30CjWIM7o9xCXEPcc,12721
 singlestoredb/connection.py,sha256=QC5YQemwJOhdW_-ZBFpNLE15xFxwI1fB2LuvE1hNi9k,46812
 singlestoredb/converters.py,sha256=7_Of1f3Ow-JUoY1pHFlMPYxvt8llzdk-7X8qk5z2xJM,21631
 singlestoredb/exceptions.py,sha256=WCCJrNSsU-hD-621Jpd6bwmvGftQ7byXkk-XKXlaxpg,3354
+singlestoredb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 singlestoredb/pytest.py,sha256=TH364xRCN7_QaN0oRQDHixrEcDx_ZBgu3bmY0tvKrYU,9357
 singlestoredb/types.py,sha256=Lv0BEQl6aSZBiAe0OSI07FEJhcHZ9HX45iT9NU_mxHQ,10334
 singlestoredb/ai/__init__.py,sha256=nT048t90xqjaNhz7KJ10KfSVW4RcZRoujyC6po6Nmb8,61
@@ -31,11 +32,12 @@ singlestoredb/functions/ext/rowdat_1.py,sha256=KYj_y5JWm3_B2-QC47HK-CNOrzujBqGUw
 singlestoredb/functions/ext/utils.py,sha256=OPMFD-tTCx2Kk9jguQkrTr7e4AgNkt15YsvaT1YSmN8,5480
 singlestoredb/fusion/__init__.py,sha256=FHWtrg6OJFTf6Ye197V5sU6ssryr2h6FBcDIgXP7-H4,367
 singlestoredb/fusion/graphql.py,sha256=SHqsPe4xgawdsTPHEtJGQlybYGWqPrGMmyK-v20RLac,5420
-singlestoredb/fusion/handler.py,sha256=iILH6aeVWOPbqbkJ8m8CVYV61uJnw8ohYIv8U7bXklM,26231
+singlestoredb/fusion/handler.py,sha256=KqBqssL7KVXxQWPw9bG8H8zto4ac76qEeExteBr-t1c,28437
 singlestoredb/fusion/registry.py,sha256=_eT1gd38VPlFKs5f9Pu6lqQyoDQ_ixW5O56QwYLQ89Y,6361
 singlestoredb/fusion/result.py,sha256=EcFY5Qv43ySlQsfl_JB-I3ko7PzVdjuhhoKN96uHSAM,12171
 singlestoredb/fusion/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-singlestoredb/fusion/handlers/job.py,sha256=TE57c3IDsKb6C5QH4AKAZBMMeZCIaQ4NrZPzXIq0KaI,21959
+singlestoredb/fusion/handlers/export.py,sha256=UCsAXOaZaQ1cD4NkslVBQ_sgzMGeZvemi-cTHcU9pBw,7342
+singlestoredb/fusion/handlers/job.py,sha256=3enfxHwERH7T4u0FEwOPN0IL0GtepaCYgEsisiy3Df4,21753
 singlestoredb/fusion/handlers/stage.py,sha256=uPqawMvchnpyrPYLhB0joTremCURNYKOvYntFc3zTRU,14133
 singlestoredb/fusion/handlers/utils.py,sha256=7xWb_1mJzxW0po9iHVY2ZVnRvHIQgOlKZQZ1zllJBjk,5271
 singlestoredb/fusion/handlers/workspace.py,sha256=NxoEY5xd5lCQmXiim4nhAYCL0agHo1H_rGPpqa31hiw,28397
@@ -44,6 +46,7 @@ singlestoredb/http/connection.py,sha256=LFUeWx7maS7xhQLqEX3pgvIGoosqyJTovtWwJ1Dy
 singlestoredb/management/__init__.py,sha256=pQbsOffl-i6zIzR63MCxSjxPY6TNmy7Kg0BCTExt3mk,244
 singlestoredb/management/billing_usage.py,sha256=0UHFSPCrN0nyeGFFM-HXS3NP8pYmYo2BCCahDEPXvzg,3883
 singlestoredb/management/cluster.py,sha256=XfdBuTlrAG-mnW1BFKeoAr4YSE5IVgxLjbuBSpqIySo,14823
+singlestoredb/management/export.py,sha256=PPasIoAvsdsylq1iFy1Hq6JfRSpqIuD4cZZXxUYqGEU,8968
 singlestoredb/management/job.py,sha256=Npfe1JLYJlggGBrXLniPKwKUKF1i3alvSY1SFtvauSs,25498
 singlestoredb/management/manager.py,sha256=uGNrUe3zhuP-HUqdfwvy4MdEXTCmq-FZKjIwZSc3hOM,9096
 singlestoredb/management/organization.py,sha256=JBsNC4R3boUKdYvyCZyfGoVMC1mD6SPuMI1UssBVoOM,5611
@@ -106,7 +109,7 @@ singlestoredb/tests/test_dbapi.py,sha256=cNJoTEZvYG7ckcwT7xqlkJX-2TDEYGTDDU1Iguc
 singlestoredb/tests/test_exceptions.py,sha256=vscMYmdOJr0JmkTAJrNI2w0Q96Nfugjkrt5_lYnw8i0,1176
 singlestoredb/tests/test_ext_func.py,sha256=gQErR-wAN8BqLNG5U4pNbg4qkQEo6Re8Hd9_Ztqo1RM,38550
 singlestoredb/tests/test_ext_func_data.py,sha256=9kn8BWmCjkbnP6hSbFhmhcdW4OmVT-GSvBTIzFBLEys,48796
-singlestoredb/tests/test_fusion.py,sha256=Qab2TTVwUPo7NPso6nIQgDkR6hHtDLp5j1gO7X4bDsk,24685
+singlestoredb/tests/test_fusion.py,sha256=ckATjXKcDBvej68PZgTRJirdoywtUJ7WXkZmfR0la_4,24544
 singlestoredb/tests/test_http.py,sha256=7hwXe61hlUes3nji0MTTZweo94tJAlJ-vA5ct9geXFQ,8868
 singlestoredb/tests/test_management.py,sha256=B4NkK7J0luuS7T-7OR5qzu-v8gkViIiXie-58bHQIDQ,35334
 singlestoredb/tests/test_plugin.py,sha256=P1nXLnTafaHkHN-6bVbGryxTu7OWJPU9SYFZ_WQUwq8,845
@@ -125,9 +128,9 @@ singlestoredb/utils/events.py,sha256=rC9cHAetua_E1f-EiFkFM-gJzQSQIH5Uk-4sspC3KjI
 singlestoredb/utils/mogrify.py,sha256=gCcn99-vgsGVjTUV7RHJ6hH4vCNrsGB_Xo4z8kiSPDQ,4201
 singlestoredb/utils/results.py,sha256=wR70LhCqlobniZf52r67zYLBOKjWHQm68NAskdRQND8,15862
 singlestoredb/utils/xdict.py,sha256=-wi1lSPTnY99fhVMBhPKJ8cCsQhNG4GMUfkEBDKYgCw,13321
-singlestoredb-1.7.2.dist-info/LICENSE,sha256=Bojenzui8aPNjlF3w4ojguDP7sTf8vFV_9Gc2UAG1sg,11542
-singlestoredb-1.7.2.dist-info/METADATA,sha256=EcxKSeGY473TFRuGP6W42122Mz_hry8hPLXAVseir0A,5710
-singlestoredb-1.7.2.dist-info/WHEEL,sha256=UyMHzmWA0xVqVPKfTiLs2eN3OWWZUl-kQemNbpIqlKo,100
-singlestoredb-1.7.2.dist-info/entry_points.txt,sha256=bSLaTWB5zGjpVYPAaI46MkkDup0su-eb3uAhCNYuRV0,48
-singlestoredb-1.7.2.dist-info/top_level.txt,sha256=SDtemIXf-Kp-_F2f_S6x0db33cHGOILdAEsIQZe2LZc,35
-singlestoredb-1.7.2.dist-info/RECORD,,
+singlestoredb-1.8.0.dist-info/LICENSE,sha256=Bojenzui8aPNjlF3w4ojguDP7sTf8vFV_9Gc2UAG1sg,11542
+singlestoredb-1.8.0.dist-info/METADATA,sha256=Y5VQXcKumZcpjgYh4pPjA4d28O5HP5BQpjNwzYyjYI8,5710
+singlestoredb-1.8.0.dist-info/WHEEL,sha256=UyMHzmWA0xVqVPKfTiLs2eN3OWWZUl-kQemNbpIqlKo,100
+singlestoredb-1.8.0.dist-info/entry_points.txt,sha256=bSLaTWB5zGjpVYPAaI46MkkDup0su-eb3uAhCNYuRV0,48
+singlestoredb-1.8.0.dist-info/top_level.txt,sha256=SDtemIXf-Kp-_F2f_S6x0db33cHGOILdAEsIQZe2LZc,35
+singlestoredb-1.8.0.dist-info/RECORD,,