singlestoredb 0.9.0__cp36-abi3-win32.whl → 0.9.2__cp36-abi3-win32.whl

singlestoredb/management/cluster.py

@@ -12,6 +12,7 @@ from .. import connection
 from ..exceptions import ManagementError
 from .manager import Manager
 from .region import Region
+from .utils import NamedList
 from .utils import to_datetime
 from .utils import vars_to_str
 
@@ -337,16 +338,16 @@ class ClusterManager(Manager):
     obj_type = 'cluster'
 
     @property
-    def clusters(self) -> List[Cluster]:
+    def clusters(self) -> NamedList[Cluster]:
         """Return a list of available clusters."""
         res = self._get('clusters')
-        return [Cluster.from_dict(item, self) for item in res.json()]
+        return NamedList([Cluster.from_dict(item, self) for item in res.json()])
 
     @property
-    def regions(self) -> List[Region]:
+    def regions(self) -> NamedList[Region]:
         """Return a list of available regions."""
         res = self._get('regions')
-        return [Region.from_dict(item, self) for item in res.json()]
+        return NamedList([Region.from_dict(item, self) for item in res.json()])
 
     def create_cluster(
         self, name: str, region: Union[str, Region], admin_password: str,

singlestoredb/management/utils.py

@@ -8,6 +8,8 @@ from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
+from typing import SupportsIndex
+from typing import TypeVar
 from typing import Union
 
 from .. import converters
@@ -15,6 +17,7 @@ from .. import converters
 JSON = Union[str, List[str], Dict[str, 'JSON']]
 JSONObj = Dict[str, JSON]
 JSONList = List[JSON]
+T = TypeVar('T')
 
 if sys.version_info < (3, 10):
     PathLike = Union[str, os.PathLike]
@@ -24,6 +27,49 @@ else:
     PathLikeABC = os.PathLike[str]
 
 
+class NamedList(List[T]):
+    """List class which also allows selection by ``name`` and ``id`` attribute."""
+
+    def _find_item(self, key: str) -> T:
+        for item in self:
+            if getattr(item, 'name', '') == key:
+                return item
+            if getattr(item, 'id', '') == key:
+                return item
+        raise KeyError(key)
+
+    def __getitem__(self, key: Union[SupportsIndex, slice, str]) -> Any:
+        if isinstance(key, str):
+            return self._find_item(key)
+        return super().__getitem__(key)
+
+    def __contains__(self, key: Any) -> bool:
+        if isinstance(key, str):
+            try:
+                self._find_item(key)
+                return True
+            except KeyError:
+                return False
+        return super().__contains__(key)
+
+    def names(self) -> List[str]:
+        """Return ``name`` attribute of each item."""
+        return [y for y in [getattr(x, 'name', None) for x in self] if y is not None]
+
+    def ids(self) -> List[str]:
+        """Return ``id`` attribute of each item."""
+        return [y for y in [getattr(x, 'id', None) for x in self] if y is not None]
+
+    def get(self, name_or_id: str, *default: Any) -> Any:
+        """Return object with name / ID if it exists, or return default value."""
+        try:
+            return self._find_item(name_or_id)
+        except KeyError:
+            if default:
+                return default[0]
+            raise
+
+
 def enable_http_tracing() -> None:
     """Enable tracing of HTTP requests."""
     import logging

singlestoredb/management/workspace.py

@@ -23,6 +23,7 @@ from .manager import Manager
 from .organization import Organization
 from .region import Region
 from .utils import from_datetime
+from .utils import NamedList
 from .utils import PathLike
 from .utils import snake_to_camel
 from .utils import to_datetime
@@ -126,6 +127,47 @@ class StagesObject(object):
         """Return string representation."""
         return str(self)
 
+    def open(
+        self,
+        mode: str = 'r',
+        encoding: Optional[str] = None,
+    ) -> Union[io.StringIO, io.BytesIO]:
+        """
+        Open a Stage path for reading or writing.
+
+        Parameters
+        ----------
+        mode : str, optional
+            The read / write mode. The following modes are supported:
+                * 'r' open for reading (default)
+                * 'w' open for writing, truncating the file first
+                * 'x' create a new file and open it for writing
+            The data type can be specified by adding one of the following:
+                * 'b' binary mode
+                * 't' text mode (default)
+        encoding : str, optional
+            The string encoding to use for text
+
+        Returns
+        -------
+        StagesObjectBytesReader - 'rb' or 'b' mode
+        StagesObjectBytesWriter - 'wb' or 'xb' mode
+        StagesObjectTextReader - 'r' or 'rt' mode
+        StagesObjectTextWriter - 'w', 'x', 'wt' or 'xt' mode
+
+        """
+        if self._stages is None:
+            raise ManagementError(
+                msg='No Stages object is associated with this object.',
+            )
+
+        if self.is_dir():
+            raise IsADirectoryError(
+                f'directories can not be read or written: {self.path}',
+            )
+
+        return self._stages.open(self.path, mode=mode, encoding=encoding)
+
     def download(
         self,
         local_path: Optional[PathLike] = None,
@@ -256,7 +298,6 @@ class StagesObjectTextWriter(io.StringIO):
 
     def close(self) -> None:
         """Write the content to the stage path."""
-        print('CLOSING')
         self._stages._upload(self.getvalue(), self._stage_path)
         super().close()
 
@@ -653,13 +694,18 @@ class Stages(object):
             return out
         return [x['path'] for x in res['content'] or []]
 
-    def listdir(self, stage_path: PathLike, *, recursive: bool = False) -> List[str]:
+    def listdir(
+        self,
+        stage_path: PathLike = '/',
+        *,
+        recursive: bool = False,
+    ) -> List[str]:
         """
         List the files / folders at the given path.
 
         Parameters
         ----------
-        stage_path : Path or str
+        stage_path : Path or str, optional
             Path to the stage location
 
         Returns
@@ -1163,14 +1209,16 @@ class WorkspaceGroup(object):
         )
 
     @property
-    def workspaces(self) -> List[Workspace]:
+    def workspaces(self) -> NamedList[Workspace]:
         """Return a list of available workspaces."""
         if self._manager is None:
             raise ManagementError(
                 msg='No workspace manager is associated with this object.',
             )
         res = self._manager._get('workspaces', params=dict(workspaceGroupID=self.id))
-        return [Workspace.from_dict(item, self._manager) for item in res.json()]
+        return NamedList(
+            [Workspace.from_dict(item, self._manager) for item in res.json()],
+        )
 
 
 class Billing(object):
@@ -1275,10 +1323,10 @@ class WorkspaceManager(Manager):
     obj_type = 'workspace'
 
     @ property
-    def workspace_groups(self) -> List[WorkspaceGroup]:
+    def workspace_groups(self) -> NamedList[WorkspaceGroup]:
         """Return a list of available workspace groups."""
         res = self._get('workspaceGroups')
-        return [WorkspaceGroup.from_dict(item, self) for item in res.json()]
+        return NamedList([WorkspaceGroup.from_dict(item, self) for item in res.json()])
 
     @ property
     def organizations(self) -> Organizations:
@@ -1291,10 +1339,10 @@ class WorkspaceManager(Manager):
         return Billing(self)
 
     @ property
-    def regions(self) -> List[Region]:
+    def regions(self) -> NamedList[Region]:
         """Return a list of available regions."""
         res = self._get('regions')
-        return [Region.from_dict(item, self) for item in res.json()]
+        return NamedList([Region.from_dict(item, self) for item in res.json()])
 
     def create_workspace_group(
         self, name: str, region: Union[str, Region],
@@ -1341,7 +1389,7 @@ class WorkspaceManager(Manager):
             'workspaceGroups', json=dict(
                 name=name, regionID=region,
                 adminPassword=admin_password,
-                firewallRanges=firewall_ranges,
+                firewallRanges=firewall_ranges or [],
                 expiresAt=expires_at,
                 allowAllTraffic=allow_all_traffic,
                 updateWindow=update_window,

singlestoredb/mysql/connection.py

@@ -47,6 +47,7 @@ from .protocol import (
 )
 from . import err
 from ..config import get_option
+from .. import fusion
 from ..connection import Connection as BaseConnection
 
 try:
@@ -758,10 +759,15 @@ class Connection(BaseConnection):
         """
         # if DEBUG:
         #     print("DEBUG: sending query:", sql)
-        if isinstance(sql, str):
-            sql = sql.encode(self.encoding, 'surrogateescape')
-        self._execute_command(COMMAND.COM_QUERY, sql)
-        self._affected_rows = self._read_query_result(unbuffered=unbuffered)
+        handler = fusion.get_handler(sql)
+        if handler is not None:
+            self._result = fusion.execute(self, sql, handler=handler)
+            self._affected_rows = self._result.affected_rows
+        else:
+            if isinstance(sql, str):
+                sql = sql.encode(self.encoding, 'surrogateescape')
+            self._execute_command(COMMAND.COM_QUERY, sql)
+            self._affected_rows = self._read_query_result(unbuffered=unbuffered)
         return self._affected_rows
 
     def next_result(self, unbuffered=False):

singlestoredb/mysql/constants/FIELD_TYPE.py

@@ -29,3 +29,4 @@ GEOMETRY = 255
 
 CHAR = TINY
 INTERVAL = ENUM
+BOOL = TINY

singlestoredb/tests/test_management.py

@@ -69,10 +69,22 @@ class TestCluster(unittest.TestCase):
     def test_regions(self):
         out = self.manager.regions
         providers = {x.provider for x in out}
+        names = [x.name for x in out]
+        ids = [x.id for x in out]
         assert 'Azure' in providers, providers
         assert 'GCP' in providers, providers
         assert 'AWS' in providers, providers
 
+        objs = {}
+        for item in out:
+            objs[item.id] = item
+            objs[item.name] = item
+
+        name = random.choice(names)
+        assert out[name] == objs[name]
+        id = random.choice(ids)
+        assert out[id] == objs[id]
+
     def test_clusters(self):
         clusters = self.manager.clusters
         ids = [x.id for x in clusters]
@@ -232,19 +244,61 @@ class TestWorkspace(unittest.TestCase):
     def test_regions(self):
         out = self.manager.regions
         providers = {x.provider for x in out}
+        names = [x.name for x in out]
+        ids = [x.id for x in out]
         assert 'Azure' in providers, providers
         assert 'GCP' in providers, providers
         assert 'AWS' in providers, providers
 
+        objs = {}
+        for item in out:
+            objs[item.id] = item
+            objs[item.name] = item
+
+        name = random.choice(names)
+        assert out[name] == objs[name]
+        id = random.choice(ids)
+        assert out[id] == objs[id]
+
     def test_workspace_groups(self):
         workspace_groups = self.manager.workspace_groups
         ids = [x.id for x in workspace_groups]
-        assert self.workspace_group.id in ids, ids
+        names = [x.name for x in workspace_groups]
+        assert self.workspace_group.id in ids
+        assert self.workspace_group.name in names
+
+        assert workspace_groups.ids() == ids
+        assert workspace_groups.names() == names
+
+        objs = {}
+        for item in workspace_groups:
+            objs[item.id] = item
+            objs[item.name] = item
+
+        name = random.choice(names)
+        assert workspace_groups[name] == objs[name]
+        id = random.choice(ids)
+        assert workspace_groups[id] == objs[id]
 
     def test_workspaces(self):
         spaces = self.workspace_group.workspaces
         ids = [x.id for x in spaces]
-        assert self.workspace.id in ids, ids
+        names = [x.name for x in spaces]
+        assert self.workspace.id in ids
+        assert self.workspace.name in names
+
+        assert spaces.ids() == ids
+        assert spaces.names() == names
+
+        objs = {}
+        for item in spaces:
+            objs[item.id] = item
+            objs[item.name] = item
+
+        name = random.choice(names)
+        assert spaces[name] == objs[name]
+        id = random.choice(ids)
+        assert spaces[id] == objs[id]
 
     def test_get_workspace_group(self):
         group = self.manager.get_workspace_group(self.workspace_group.id)
@@ -439,6 +493,46 @@ class TestStages(unittest.TestCase):
 
         assert txt == open(TEST_DIR / 'test.sql').read()
 
+    def test_obj_open(self):
+        st = self.wg.stages
+
+        # Load test file
+        f = st.upload_file(TEST_DIR / 'test.sql', 'obj_open_test.sql')
+
+        # Read file using `open`
+        with f.open() as rfile:
+            assert rfile.read() == open(TEST_DIR / 'test.sql').read()
+
+        # Make sure directories error out
+        d = st.mkdir('obj_open_dir')
+        with self.assertRaises(IsADirectoryError):
+            d.open()
+
+        # Write file using `open`
+        with f.open('w', encoding='utf-8') as wfile:
+            wfile.write(open(TEST_DIR / 'test2.sql').read())
+
+        assert f.download(encoding='utf-8') == open(TEST_DIR / 'test2.sql').read()
+
+        # Test writer without context manager
+        wfile = f.open('w')
+        for line in open(TEST_DIR / 'test.sql'):
+            wfile.write(line)
+        wfile.close()
+
+        txt = st.download(f.path, encoding='utf-8')
+
+        assert txt == open(TEST_DIR / 'test.sql').read()
+
+        # Test reader without context manager
+        rfile = f.open('r')
+        txt = ''
+        for line in rfile:
+            txt += line
+        rfile.close()
+
+        assert txt == open(TEST_DIR / 'test.sql').read()
+
     def test_os_directories(self):
         st = self.wg.stages
 

singlestoredb/tests/test_results.py

@@ -51,7 +51,7 @@ class TestResults(unittest.TestCase):
                 with conn.cursor() as cur:
                     cur.execute('select * from data')
                     out = cur.fetchone()
-                    assert type(out) == tuple, type(out)
+                    assert type(out) is tuple, type(out)
                     assert len(out) == 3, len(out)
                     cur.fetchall()
 
@@ -59,7 +59,7 @@ class TestResults(unittest.TestCase):
                     out = cur.fetchall()
                     assert len(out) == 5, len(out)
                     assert len(out[0]) == 3, len(out[0])
-                    assert type(out[0]) == tuple, type(out[0])
+                    assert type(out[0]) is tuple, type(out[0])
                     assert sorted(out) == sorted([
                         ('a', 'antelopes', 2),
                         ('b', 'bears', 2),
@@ -111,13 +111,13 @@ class TestResults(unittest.TestCase):
                 with conn.cursor() as cur:
                     cur.execute('select * from data')
                     out = cur.fetchone()
-                    assert type(out) == dict, type(out)
+                    assert type(out) is dict, type(out)
                     assert len(out) == 3, len(out)
                     cur.fetchall()
 
                     cur.execute('select * from data')
                     out = cur.fetchall()
-                    assert type(out[0]) == dict, type(out[0])
+                    assert type(out[0]) is dict, type(out[0])
                     assert len(out) == 5, len(out)
                     assert len(out[0]) == 3, len(out[0])
                     assert sorted(out, key=lambda x: x['id']) == sorted(
@@ -139,13 +139,13 @@ class TestResults(unittest.TestCase):
                 with conn.cursor() as cur:
                     cur.execute('select * from data')
                     out = cur.fetchone()
-                    assert type(out) == pd.DataFrame, type(out)
+                    assert type(out) is pd.DataFrame, type(out)
                     assert len(out) == 1, len(out)
                     cur.fetchall()
 
                     cur.execute('select * from data')
                     out = cur.fetchall()
-                    assert type(out) == pd.DataFrame, type(out)
+                    assert type(out) is pd.DataFrame, type(out)
                     assert len(out) == 5, len(out)
                     out = out.sort_values('id').reset_index(drop=True)
                     exp = pd.DataFrame(

singlestoredb/utils/mogrify.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+from typing import Any
+from typing import Dict
+from typing import Optional
+from typing import Sequence
+from typing import Union
+
+from ..mysql import converters
+from ..mysql.constants import SERVER_STATUS
+
+
+Encoders = converters.Encoders
+
+
+def escape(
+    obj: Any,
+    charset: str = 'utf8',
+    mapping: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    """
+    Escape whatever value is passed.
+
+    Non-standard, for internal use; do not use this in your applications.
+
+    """
+    dtype = type(obj)
+    if dtype is str or isinstance(obj, str):
+        return "'{}'".format(escape_string(obj, server_status=server_status))
+    if dtype is bytes or dtype is bytearray or isinstance(obj, (bytes, bytearray)):
+        return _quote_bytes(
+            obj,
+            server_status=server_status,
+            binary_prefix=binary_prefix,
+        )
+    if mapping is None:
+        mapping = converters.encoders
+    return converters.escape_item(obj, charset, mapping=mapping)
+
+
+def literal(
+    obj: Any,
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    """
+    Alias for escape().
+
+    Non-standard, for internal use; do not use this in your applications.
+
+    """
+    return escape(
+        obj, charset=charset, mapping=encoders,
+        server_status=server_status, binary_prefix=binary_prefix,
+    )
+
+
+def escape_string(
+    s: str,
+    server_status: int = 0,
+) -> str:
+    """Escape a string value."""
+    if server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
+        return s.replace("'", "''")
+    return converters.escape_string(s)
+
+
+def _quote_bytes(
+    s: bytes,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    if server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
+        if binary_prefix:
+            return "_binary X'{}'".format(s.hex())
+        return "X'{}'".format(s.hex())
+    return converters.escape_bytes(s)
+
+
+def _escape_args(
+    args: Union[Sequence[Any], Dict[str, Any], None],
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> Any:
+    if encoders is None:
+        encoders = converters.encoders
+
+    if isinstance(args, (tuple, list)):
+        return tuple(
+            literal(
+                arg, charset=charset, encoders=encoders,
+                server_status=server_status,
+                binary_prefix=binary_prefix,
+            ) for arg in args
+        )
+
+    elif isinstance(args, dict):
+        return {
+            key: literal(
+                val, charset=charset, encoders=encoders,
+                server_status=server_status,
+                binary_prefix=binary_prefix,
+            ) for (key, val) in args.items()
+        }
+
+    # If it's not a dictionary let's try escaping it anyways.
+    # Worst case it will throw a Value error
+    return escape(
+        args, charset=charset, mapping=encoders,
+        server_status=server_status, binary_prefix=binary_prefix,
+    )
+
+
+def mogrify(
+    query: Union[str, bytes],
+    args: Union[Sequence[Any], Dict[str, Any], None] = None,
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> Union[str, bytes]:
+    """
+    Returns the exact string sent to the database by calling the execute() method.
+
+    This method follows the extension to the DB API 2.0 followed by Psycopg.
+
+    Parameters
+    ----------
+    query : str
+        Query to mogrify.
+    args : Sequence[Any] or Dict[str, Any] or Any, optional
+        Parameters used with query. (optional)
+
+    Returns
+    -------
+    str : The query with argument binding applied.
+
+    """
+    if args:
+        query = query % _escape_args(
+            args, charset=charset,
+            encoders=encoders,
+            server_status=server_status,
+            binary_prefix=binary_prefix,
+        )
+    return query

{singlestoredb-0.9.0.dist-info → singlestoredb-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 0.9.0
+Version: 0.9.2
 Summary: Interface to the SingleStoreDB database and workspace management APIs
 Home-page: https://github.com/singlestore-labs/singlestoredb-python
 Author: SingleStore
@@ -16,6 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyJWT
 Requires-Dist: build
+Requires-Dist: parsimonious
 Requires-Dist: requests
 Requires-Dist: sqlparams
 Requires-Dist: wheel