singlestoredb 1.16.1__py3-none-any.whl

singlestoredb/magics/__init__.py

@@ -0,0 +1,34 @@
+from IPython.core.interactiveshell import InteractiveShell
+
+from .run_personal import RunPersonalMagic
+from .run_shared import RunSharedMagic
+
+# In order to actually use these magics, we must register them with a
+# running IPython.
+
+
+def load_ipython_extension(ip: InteractiveShell) -> None:
+    """
+    Any module file that define a function named `load_ipython_extension`
+    can be loaded via `%load_ext module.path` or be configured to be
+    autoloaded by IPython at startup time.
+    """
+
+    # Load jupysql extension
+    # This is necessary for jupysql to initialize internal state
+    # required to render messages
+    assert ip.extension_manager is not None
+    result = ip.extension_manager.load_extension('sql')
+    if result == 'no load function':
+        raise RuntimeError('Could not load sql extension. Is jupysql installed?')
+
+    # Check if %run magic command is defined
+    if ip.find_line_magic('run') is None:
+        raise RuntimeError(
+            '%run magic command is not defined. '
+            'Is it available in your IPython environment?',
+        )
+
+    # Register run_personal and run_shared
+    ip.register_magics(RunPersonalMagic(ip))
+    ip.register_magics(RunSharedMagic(ip))

singlestoredb/magics/run_personal.py

@@ -0,0 +1,137 @@
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+from warnings import warn
+
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.magic import line_magic
+from IPython.core.magic import Magics
+from IPython.core.magic import magics_class
+from IPython.core.magic import needs_local_scope
+from IPython.core.magic import no_var_expand
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.syspathcontext import prepended_to_syspath
+from jinja2 import Template
+
+
+@magics_class
+class RunPersonalMagic(Magics):
+    def __init__(self, shell: InteractiveShell):
+        Magics.__init__(self, shell=shell)
+
+    @no_var_expand
+    @needs_local_scope
+    @line_magic('run_personal')
+    def run_personal(self, line: str, local_ns: Any = None) -> Any:
+        """
+        Downloads a personal file using the %sql magic and then runs it using %run.
+
+        Examples::
+
+          # Line usage
+
+          %run_personal personal_file.ipynb
+
+          %run_personal {{ sample_notebook_name }}
+
+        """
+
+        template = Template(line.strip())
+        personal_file = template.render(local_ns)
+        if not personal_file:
+            raise ValueError('No personal file specified.')
+        if (personal_file.startswith("'") and personal_file.endswith("'")) or \
+           (personal_file.startswith('"') and personal_file.endswith('"')):
+            personal_file = personal_file[1:-1]
+            if not personal_file:
+                raise ValueError('No personal file specified.')
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_file_path = os.path.join(temp_dir, personal_file)
+            sql_command = (
+                f"DOWNLOAD PERSONAL FILE '{personal_file}' "
+                f"TO '{temp_file_path}'"
+            )
+
+            # Execute the SQL command
+            self.shell.run_line_magic('sql', sql_command)
+            # Run the downloaded file
+            with preserve_keys(self.shell.user_ns, '__file__'):
+                self.shell.user_ns['__file__'] = temp_file_path
+                self.safe_execfile_ipy(temp_file_path, raise_exceptions=True)
+
+    def safe_execfile_ipy(
+        self,
+        fname: str,
+        shell_futures: bool = False,
+        raise_exceptions: bool = False,
+    ) -> None:
+        """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
+
+        Parameters
+        ----------
+        fname : str
+            The name of the file to execute.  The filename must have a
+            .ipy or .ipynb extension.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
+        raise_exceptions : bool (False)
+            If True raise exceptions everywhere.  Meant for testing.
+        """
+        fpath = Path(fname).expanduser().resolve()
+
+        # Make sure we can open the file
+        try:
+            with fpath.open('rb'):
+                pass
+        except Exception:
+            warn('Could not open file <%s> for safe execution.' % fpath)
+            return
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = str(fpath.parent)
+
+        def get_cells() -> Any:
+            """generator for sequence of code blocks to run"""
+            if fpath.suffix == '.ipynb':
+                from nbformat import read
+                nb = read(fpath, as_version=4)
+                if not nb.cells:
+                    return
+                for cell in nb.cells:
+                    if cell.cell_type == 'code':
+                        if not cell.source.strip():
+                            continue
+                        if getattr(cell, 'metadata', {}).get('language', '') == 'sql':
+                            output_redirect = getattr(
+                                cell, 'metadata', {},
+                            ).get('output_variable', '') or ''
+                            if output_redirect:
+                                output_redirect = f' {output_redirect} <<'
+                            yield f'%%sql{output_redirect}\n{cell.source}'
+                        else:
+                            yield cell.source
+            else:
+                yield fpath.read_text(encoding='utf-8')
+
+        with prepended_to_syspath(dname):
+            try:
+                for cell in get_cells():
+                    result = self.shell.run_cell(
+                        cell, silent=True, shell_futures=shell_futures,
+                    )
+                    if raise_exceptions:
+                        result.raise_error()
+                    elif not result.success:
+                        break
+            except Exception:
+                if raise_exceptions:
+                    raise
+                self.shell.showtraceback()
+                warn('Unknown failure executing file: <%s>' % fpath)

singlestoredb/magics/run_shared.py

@@ -0,0 +1,134 @@
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+from warnings import warn
+
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.magic import line_magic
+from IPython.core.magic import Magics
+from IPython.core.magic import magics_class
+from IPython.core.magic import needs_local_scope
+from IPython.core.magic import no_var_expand
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.syspathcontext import prepended_to_syspath
+from jinja2 import Template
+
+
+@magics_class
+class RunSharedMagic(Magics):
+    def __init__(self, shell: InteractiveShell):
+        Magics.__init__(self, shell=shell)
+
+    @no_var_expand
+    @needs_local_scope
+    @line_magic('run_shared')
+    def run_shared(self, line: str, local_ns: Any = None) -> Any:
+        """
+        Downloads a shared file using the %sql magic and then runs it using %run.
+
+        Examples::
+
+          # Line usage
+
+          %run_shared shared_file.ipynb
+
+          %run_shared {{ sample_notebook_name }}
+
+        """
+
+        template = Template(line.strip())
+        shared_file = template.render(local_ns)
+        if not shared_file:
+            raise ValueError('No shared file specified.')
+        if (shared_file.startswith("'") and shared_file.endswith("'")) or \
+           (shared_file.startswith('"') and shared_file.endswith('"')):
+            shared_file = shared_file[1:-1]
+            if not shared_file:
+                raise ValueError('No personal file specified.')
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_file_path = os.path.join(temp_dir, shared_file)
+            sql_command = f"DOWNLOAD SHARED FILE '{shared_file}' TO '{temp_file_path}'"
+
+            # Execute the SQL command
+            self.shell.run_line_magic('sql', sql_command)
+            # Run the downloaded file
+            with preserve_keys(self.shell.user_ns, '__file__'):
+                self.shell.user_ns['__file__'] = temp_file_path
+                self.safe_execfile_ipy(temp_file_path, raise_exceptions=True)
+
+    def safe_execfile_ipy(
+        self,
+        fname: str,
+        shell_futures: bool = False,
+        raise_exceptions: bool = False,
+    ) -> None:
+        """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
+
+        Parameters
+        ----------
+        fname : str
+            The name of the file to execute.  The filename must have a
+            .ipy or .ipynb extension.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
+        raise_exceptions : bool (False)
+            If True raise exceptions everywhere.  Meant for testing.
+        """
+        fpath = Path(fname).expanduser().resolve()
+
+        # Make sure we can open the file
+        try:
+            with fpath.open('rb'):
+                pass
+        except Exception:
+            warn('Could not open file <%s> for safe execution.' % fpath)
+            return
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = str(fpath.parent)
+
+        def get_cells() -> Any:
+            """generator for sequence of code blocks to run"""
+            if fpath.suffix == '.ipynb':
+                from nbformat import read
+                nb = read(fpath, as_version=4)
+                if not nb.cells:
+                    return
+                for cell in nb.cells:
+                    if cell.cell_type == 'code':
+                        if not cell.source.strip():
+                            continue
+                        if getattr(cell, 'metadata', {}).get('language', '') == 'sql':
+                            output_redirect = getattr(
+                                cell, 'metadata', {},
+                            ).get('output_variable', '') or ''
+                            if output_redirect:
+                                output_redirect = f' {output_redirect} <<'
+                            yield f'%%sql{output_redirect}\n{cell.source}'
+                        else:
+                            yield cell.source
+            else:
+                yield fpath.read_text(encoding='utf-8')
+
+        with prepended_to_syspath(dname):
+            try:
+                for cell in get_cells():
+                    result = self.shell.run_cell(
+                        cell, silent=True, shell_futures=shell_futures,
+                    )
+                    if raise_exceptions:
+                        result.raise_error()
+                    elif not result.success:
+                        break
+            except Exception:
+                if raise_exceptions:
+                    raise
+                self.shell.showtraceback()
+                warn('Unknown failure executing file: <%s>' % fpath)

singlestoredb/management/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+from .cluster import manage_cluster
+from .files import manage_files
+from .manager import get_token
+from .region import manage_regions
+from .workspace import get_organization
+from .workspace import get_secret
+from .workspace import get_stage
+from .workspace import manage_workspaces

singlestoredb/management/billing_usage.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+"""SingleStoreDB Cloud Billing Usage."""
+import datetime
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from .manager import Manager
+from .utils import camel_to_snake
+from .utils import vars_to_str
+
+
+class UsageItem(object):
+    """Usage statistics."""
+
+    def __init__(
+        self,
+        start_time: datetime.datetime,
+        end_time: datetime.datetime,
+        owner_id: str,
+        resource_id: str,
+        resource_name: str,
+        resource_type: str,
+        value: str,
+    ):
+        #: Starting time for the usage duration
+        self.start_time = start_time
+
+        #: Ending time for the usage duration
+        self.end_time = end_time
+
+        #: Owner ID
+        self.owner_id = owner_id
+
+        #: Resource ID
+        self.resource_id = resource_id
+
+        #: Resource name
+        self.resource_name = resource_name
+
+        #: Resource type
+        self.resource_type = resource_type
+
+        #: Usage statistic value
+        self.value = value
+
+        self._manager: Optional[Manager] = None
+
+    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_dict(
+        cls,
+        obj: Dict[str, Any],
+        manager: Manager,
+    ) -> 'UsageItem':
+        """
+        Convert dictionary to a ``UsageItem`` object.
+
+        Parameters
+        ----------
+        obj : dict
+            Key-value pairs to retrieve billling usage information from
+        manager : WorkspaceManager, optional
+            The WorkspaceManager the UsageItem belongs to
+
+        Returns
+        -------
+        :class:`UsageItem`
+
+        """
+        out = cls(
+            end_time=datetime.datetime.fromisoformat(obj['endTime']),
+            start_time=datetime.datetime.fromisoformat(obj['startTime']),
+            owner_id=obj['ownerId'],
+            resource_id=obj['resourceId'],
+            resource_name=obj['resourceName'],
+            resource_type=obj['resource_type'],
+            value=obj['value'],
+        )
+        out._manager = manager
+        return out
+
+
+class BillingUsageItem(object):
+    """Billing usage item."""
+
+    def __init__(
+        self,
+        description: str,
+        metric: str,
+        usage: List[UsageItem],
+    ):
+        """Use :attr:`WorkspaceManager.billing.usage` instead."""
+        #: Description of the usage metric
+        self.description = description
+
+        #: Name of the usage metric
+        self.metric = metric
+
+        #: Usage statistics
+        self.usage = list(usage)
+
+        self._manager: Optional[Manager] = None
+
+    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_dict(
+        cls,
+        obj: Dict[str, Any],
+        manager: Manager,
+    ) -> 'BillingUsageItem':
+        """
+        Convert dictionary to a ``BillingUsageItem`` object.
+
+        Parameters
+        ----------
+        obj : dict
+            Key-value pairs to retrieve billling usage information from
+        manager : WorkspaceManager, optional
+            The WorkspaceManager the BillingUsageItem belongs to
+
+        Returns
+        -------
+        :class:`BillingUsageItem`
+
+        """
+        out = cls(
+            description=obj['description'],
+            metric=str(camel_to_snake(obj['metric'])),
+            usage=[UsageItem.from_dict(x, manager) for x in obj['Usage']],
+        )
+        out._manager = manager
+        return out