singlestoredb 0.8.9__cp36-abi3-win_amd64.whl → 0.9.0__cp36-abi3-win_amd64.whl

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

singlestoredb/management/manager.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 """SingleStoreDB Base Manager."""
+import os
+import sys
 import time
 from typing import Any
 from typing import Dict
@@ -48,6 +50,7 @@ class Manager(object):
             base_url or type(self).default_base_url,
             version or type(self).default_version,
         ) + '/'
+        self._params: Dict[str, str] = {}
 
     def _check(
         self, res: requests.Response, url: str, params: Dict[str, Any],
@@ -65,6 +68,8 @@ class Manager(object):
         requests.Response
 
         """
+        if config.get_option('debug.queries'):
+            print(os.path.join(self._base_url, url), params, file=sys.stderr)
         if res.status_code >= 400:
             txt = res.text.strip()
             msg = f'{txt}: /{url}'
@@ -75,7 +80,7 @@ class Manager(object):
                         if 'password' in k.lower() and v:
                             new_params['json'][k] = '*' * len(v)
                 msg += ': {}'.format(str(new_params))
-            raise ManagementError(errno=res.status_code, msg=msg)
+            raise ManagementError(errno=res.status_code, msg=msg, response=txt)
         return res
 
     def _get(self, path: str, *args: Any, **kwargs: Any) -> requests.Response:
@@ -96,6 +101,8 @@ class Manager(object):
         requests.Response
 
         """
+        if self._params:
+            kwargs['params'] = self._params
         return self._check(
             self._sess.get(
                 urljoin(self._base_url, path),
@@ -122,6 +129,8 @@ class Manager(object):
         requests.Response
 
         """
+        if self._params:
+            kwargs['params'] = self._params
         return self._check(
             self._sess.post(
                 urljoin(self._base_url, path),
@@ -130,6 +139,34 @@ class Manager(object):
             path, kwargs,
         )
 
+    def _put(self, path: str, *args: Any, **kwargs: Any) -> requests.Response:
+        """
+        Invoke a PUT request.
+
+        Parameters
+        ----------
+        path : str
+            Path of the resource
+        *args : positional arguments, optional
+            Arguments to add to the POST request
+        **kwargs : keyword arguments, optional
+            Keyword arguments to add to the POST request
+
+        Returns
+        -------
+        requests.Response
+
+        """
+        if self._params:
+            kwargs['params'] = self._params
+        return self._check(
+            self._sess.put(
+                urljoin(self._base_url, path),
+                *args, **kwargs,
+            ),
+            path, kwargs,
+        )
+
     def _delete(self, path: str, *args: Any, **kwargs: Any) -> requests.Response:
         """
         Invoke a DELETE request.
@@ -148,6 +185,8 @@ class Manager(object):
         requests.Response
 
         """
+        if self._params:
+            kwargs['params'] = self._params
         return self._check(
             self._sess.delete(
                 urljoin(self._base_url, path),
@@ -174,6 +213,8 @@ class Manager(object):
         requests.Response
 
         """
+        if self._params:
+            kwargs['params'] = self._params
         return self._check(
             self._sess.patch(
                 urljoin(self._base_url, path),

singlestoredb/management/organization.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""SingleStoreDB Cloud Organization."""
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+from .manager import Manager
+from .utils import vars_to_str
+
+
+def listify(x: Union[str, List[str]]) -> List[str]:
+    if isinstance(x, list):
+        return x
+    return [x]
+
+
+def stringify(x: Union[str, List[str]]) -> str:
+    if isinstance(x, list):
+        return x[0]
+    return x
+
+
+class Organization(object):
+    """
+    Organization in SingleStoreDB Cloud portal.
+
+    This object is not directly instantiated. It is used in results
+    of ``WorkspaceManager`` API calls.
+
+    See Also
+    --------
+    :attr:`WorkspaceManager.organization`
+
+    """
+
+    def __init__(self, id: str, name: str, firewall_ranges: List[str]):
+        """Use :attr:`WorkspaceManager.organization` instead."""
+        #: Unique ID of the organization
+        self.id = id
+
+        #: Name of the organization
+        self.name = name
+
+        #: Firewall ranges of the organization
+        self.firewall_ranges = list(firewall_ranges)
+
+        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, Union[str, List[str]]],
+        manager: Manager,
+    ) -> 'Organization':
+        """
+        Convert dictionary to an ``Organization`` object.
+
+        Parameters
+        ----------
+        obj : dict
+            Key-value pairs to retrieve organization information from
+        manager : WorkspaceManager, optional
+            The WorkspaceManager the Organization belongs to
+
+        Returns
+        -------
+        :class:`Organization`
+
+        """
+        out = cls(
+            id=stringify(obj['orgID']),
+            name=stringify(obj.get('name', '<unknown>')),
+            firewall_ranges=listify(obj.get('firewallRanges', [])),
+        )
+        out._manager = manager
+        return out

singlestoredb/management/utils.py

@@ -1,12 +1,40 @@
 #!/usr/bin/env python
 """SingleStoreDB Cluster Management."""
 import datetime
+import os
+import re
+import sys
 from typing import Any
+from typing import Dict
+from typing import List
 from typing import Optional
 from typing import Union
 
 from .. import converters
 
+JSON = Union[str, List[str], Dict[str, 'JSON']]
+JSONObj = Dict[str, JSON]
+JSONList = List[JSON]
+
+if sys.version_info < (3, 10):
+    PathLike = Union[str, os.PathLike]
+    PathLikeABC = os.PathLike
+else:
+    PathLike = Union[str, os.PathLike[str]]
+    PathLikeABC = os.PathLike[str]
+
+
+def enable_http_tracing() -> None:
+    """Enable tracing of HTTP requests."""
+    import logging
+    import http.client as http_client
+    http_client.HTTPConnection.debuglevel = 1
+    logging.basicConfig()
+    logging.getLogger().setLevel(logging.DEBUG)
+    requests_log = logging.getLogger('requests.packages.urllib3')
+    requests_log.setLevel(logging.DEBUG)
+    requests_log.propagate = True
+
 
 def to_datetime(
     obj: Optional[Union[str, datetime.datetime]],
@@ -16,6 +44,8 @@ def to_datetime(
         return None
     if isinstance(obj, datetime.datetime):
         return obj
+    if obj == '0001-01-01T00:00:00Z':
+        return None
     obj = obj.replace('Z', '')
     # Fix datetimes with truncated zeros
     if '.' in obj:
@@ -30,11 +60,98 @@ def to_datetime(
     return out
 
 
+def from_datetime(
+    obj: Union[str, datetime.datetime],
+) -> Optional[str]:
+    """Convert datetime to string."""
+    if not obj:
+        return None
+    if isinstance(obj, str):
+        return obj
+    out = obj.isoformat()
+    if not re.search(r'[A-Za-z]$', out):
+        out = f'{out}Z'
+    return out
+
+
 def vars_to_str(obj: Any) -> str:
     """Render a string representation of vars(obj)."""
     attrs = []
-    for name, value in sorted(vars(obj).items()):
+    obj_vars = vars(obj)
+    if 'name' in obj_vars:
+        attrs.append('name={}'.format(repr(obj_vars['name'])))
+    if 'id' in obj_vars:
+        attrs.append('id={}'.format(repr(obj_vars['id'])))
+    for name, value in sorted(obj_vars.items()):
+        if name in ('name', 'id'):
+            continue
         if not value or name.startswith('_'):
             continue
         attrs.append('{}={}'.format(name, repr(value)))
     return '{}({})'.format(type(obj).__name__, ', '.join(attrs))
+
+
+def single_item(s: Any) -> Any:
+    """Return only item if ``s`` is a list, otherwise return ``s``."""
+    if isinstance(s, list):
+        if len(s) != 1:
+            raise ValueError('list must only contain a singleitem')
+        return s[0]
+    return s
+
+
+def stringify(s: JSON) -> str:
+    """Convert list of strings to single string."""
+    if isinstance(s, (tuple, list)):
+        if len(s) > 1:
+            raise ValueError('list contains more than one item')
+        return s[0]
+    if isinstance(s, dict):
+        raise TypeError('only strings and lists are valid arguments')
+    return s
+
+
+def listify(s: JSON) -> List[str]:
+    """Convert string to list of strings."""
+    if isinstance(s, (tuple, list)):
+        return list(s)
+    if isinstance(s, dict):
+        raise TypeError('only strings and lists are valid arguments')
+    return [s]
+
+
+def listify_obj(s: JSON) -> List[JSONObj]:
+    """Convert object to list of objects."""
+    if isinstance(s, (tuple, list)):
+        for item in s:
+            if not isinstance(item, dict):
+                raise TypeError('only dicts and lists of dicts are valid parameters')
+        return list(s)  # type: ignore
+    if not isinstance(s, dict):
+        raise TypeError('only dicts and lists of dicts are valid parameters')
+    return [s]
+
+
+def _upper_match(m: Any) -> str:
+    """Upper-case the first match group."""
+    return m.group(1).upper()
+
+
+def snake_to_camel(s: Optional[str], cap_first: bool = False) -> Optional[str]:
+    """Convert snake-case to camel-case."""
+    if s is None:
+        return None
+    out = re.sub(r'_[A-Za-z]', _upper_match, s.lower())
+    if cap_first and out:
+        return out[0].upper() + out[1:]
+    return out
+
+
+def camel_to_snake(s: Optional[str]) -> Optional[str]:
+    """Convert camel-case to snake-case."""
+    if s is None:
+        return None
+    out = re.sub(r'([A-Z]+)', r'_\1', s).lower()
+    if out and out[0] == '_':
+        return out[1:]
+    return out