kelvin-python-api-client 0.0.1__py3-none-any.whl

kelvin/api/client/retry.py

@@ -0,0 +1,88 @@
+"""
+Custom Retrier.
+"""
+
+from __future__ import annotations
+
+from random import random
+from typing import Any, Tuple, Union
+
+import requests
+from requests.adapters import Retry
+
+
+class APIRetry(Retry):
+    """API retrier."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialise retry."""
+
+        # overrides
+        if "status_forcelist" not in kwargs:
+            kwargs["status_forcelist"] = [
+                requests.codes.bad_gateway,
+                requests.codes.service_unavailable,
+                requests.codes.gateway_timeout,
+            ]
+        if "backoff_factor" not in kwargs:
+            kwargs["backoff_factor"] = BackoffFactor((0.5, 1.0))
+
+        super().__init__(*args, **kwargs)
+
+
+class BackoffFactor:
+    """Random backoff coefficient."""
+
+    def __init__(self, factor: Union[float, Tuple[float, float]] = (0.0, 1.0)) -> None:
+        """Initialise backof coefficient."""
+
+        if isinstance(factor, (tuple, list)):
+            if len(factor) != 2:
+                raise ValueError("Factor range must be a pair")
+            min, max = factor
+            if not isinstance(min, (int, float)) or min < 0:
+                raise TypeError("Factor range minimum must be a non-negative real number")
+            if not isinstance(max, (int, float)) or max < 0:
+                raise TypeError("Factor range maximum must be a non-negative real number")
+            if min > max:
+                raise ValueError("Factor range minimum must not be greater than maximum")
+        else:
+            if not isinstance(factor, (int, float)) or factor < 0:
+                raise TypeError("Factor must be a non-negative real number")
+            min = max = factor
+
+        self.min, self.range = min, max - min
+
+    @property
+    def _value(self) -> float:
+        return self.min + random() * self.range  # nosec
+
+    def __mul__(self, x: float) -> float:
+        return self._value.__mul__(x)
+
+    def __rmul__(self, x: float) -> float:
+        return self._value.__rmul__(x)
+
+    def __truediv__(self, x: float) -> float:
+        return self._value.__truediv__(x)
+
+    def __rtruediv__(self, x: float) -> float:
+        return self._value.__rtruediv__(x)
+
+    def __add__(self, x: float) -> float:
+        return self._value.__add__(x)
+
+    def __radd__(self, x: float) -> float:
+        return self._value.__radd__(x)
+
+    def __sub__(self, x: float) -> float:
+        return self._value.__sub__(x)
+
+    def __rsub__(self, x: float) -> float:
+        return self._value.__rsub__(x)
+
+    def __int__(self) -> int:
+        return self._value.__int__()
+
+    def __float__(self) -> float:
+        return self._value.__float__()

kelvin/api/client/serialize.py

@@ -0,0 +1,222 @@
+"""
+Data serialisation.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import date, datetime, timedelta, timezone
+from enum import Enum
+from math import isfinite
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, Mapping, Tuple, Type, cast
+
+import yaml
+
+from kelvin.api.client.base_model import BaseModelRoot
+
+from .utils import chdir
+
+
+def load_include(filename: str, loader: Callable[[Any], Any]) -> Any:
+    """Load include data."""
+
+    index: Any
+
+    if ":" in filename:
+        filename, index = filename.rsplit(":", 1)
+    else:
+        index = None
+
+    try:
+        filename = filename.format_map(os.environ)
+    except KeyError as e:
+        raise ValueError(f"Unknown path variable {e!s} in filename {filename!r}")
+
+    path = Path(filename).expanduser().resolve()
+
+    with path.open("rt") as file, chdir(path.parent):
+        result = loader(file) if path.suffix in (".yaml", ".yml", ".json") else file.read()
+
+    if index is None:
+        return result
+
+    for level in index.split("."):
+        if level[level[0] in "+-" :].isnumeric():
+            level = int(level)
+        try:
+            result = result[level]
+        except (IndexError, KeyError):
+            raise ValueError(f"Unknown level {level!r} in filename {str(filename)!r}")
+
+    return result
+
+
+tokens = {"null", "true", "false", "NaN"}
+delimiters = {("{", "}"), ("[", "]"), ('"', '"')}
+number_re = re.compile(r"-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$")
+
+
+def is_json(x: str) -> bool:
+    """Check if value is probably a JSON string."""
+
+    if not x:
+        return False
+    if x in tokens:
+        return True
+    if x.isnumeric():
+        return True
+    if x[0].isalpha():
+        return False
+    if len(x) == 1:
+        return False
+    if (x[0], x[-1]) in delimiters:
+        return True
+    if number_re.match(x):
+        return True
+
+    return False
+
+
+def lower(x: Any, skip: bool = True) -> Any:
+    """Lower data to a json-ready representation."""
+
+    if x is None:
+        return x
+    if isinstance(x, str):
+        return str(x)
+    if isinstance(x, bool):
+        return bool(x)
+    if isinstance(x, int):
+        return int(x)
+    if isinstance(x, float):
+        return x if isfinite(x) else None
+    if isinstance(x, Mapping):
+        if not skip:
+            return {lower(k, skip): lower(v, skip) for k, v in x.items()}
+        return {
+            k: v
+            for k, v in (
+                (lower(k, skip), lower(v, skip))
+                for k, v in x.items()
+                if not isinstance(k, str) or not k.startswith("__")
+            )
+            if v is not ...
+        }
+    if isinstance(x, datetime):
+        suffix = "Z" if x.microsecond else ".000000Z"
+        return x.astimezone(timezone.utc).replace(tzinfo=None).isoformat() + suffix
+    if isinstance(x, date):
+        return x.isoformat()
+    if isinstance(x, timedelta):
+        return x.total_seconds()
+    if isinstance(x, BaseModelRoot):
+        return {k: lower(v, skip) for k, v in x.dict().items()}
+    if isinstance(x, Iterable):
+        if not skip:
+            return [lower(v, skip) for v in x]
+        return [v for v in (lower(v, skip) for v in x) if v is not ...]
+    if isinstance(x, Enum):
+        return x.name
+
+    if skip:
+        return ...
+
+    raise ValueError(f"Un-lowerable type: {type(x).__name__}")
+
+
+class JSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder."""
+
+    def default(self, x: Any) -> Any:
+        """Return a JSON-serialisable object."""
+
+        try:
+            return lower(x, skip=False)
+        except ValueError:
+            return super().default(x)
+
+
+def jsonify(x: Any, sort_keys: bool = True, cls: Type[json.JSONEncoder] = JSONEncoder, **kwargs: Any) -> str:
+    """Convert object to JSON."""
+
+    return json.dumps(x, sort_keys=sort_keys, cls=cls, **kwargs)
+
+
+class LoaderMeta(type):
+    """Metaclass to add include constructor."""
+
+    def __new__(metacls: Type[LoaderMeta], name: str, bases: Tuple[Type, ...], __dict__: Dict[str, Any]) -> LoaderMeta:
+        """Add include constructer to class."""
+
+        result = cast(LoaderMeta, super().__new__(metacls, name, bases, __dict__))
+
+        # register the include constructor on the class
+        result.add_constructor("!include", result.construct_include)  # type: ignore
+
+        return result
+
+
+class Loader(yaml.SafeLoader, metaclass=LoaderMeta):
+    """YAML Loader with `!include` constructor."""
+
+    def construct_include(self, node: yaml.ScalarNode) -> Any:
+        """Include file referenced at node."""
+
+        x = self.construct_scalar(node), lambda x: yaml.load(x, Loader=Loader)  # nosec
+        if not isinstance(x, str):
+            raise ValueError(f"Invalid filename type {type(x)!r}")
+
+        return load_include(*x)
+
+
+class Dumper(yaml.Dumper):
+    """Custom YAML encoder."""
+
+    def represent_data(self, x: Any) -> Any:
+        """Return a YAML-serialisable representation."""
+
+        if x is None:
+            return super().represent_none(None)
+        if isinstance(x, str):
+            if "\n" in x:
+                # use indented style for strings with newlines
+                # strip trailing spaces, leading and trailing newlines
+                x = re.sub(r"[ \t]+\n", "\n", x).lstrip("\n").rstrip()
+                return self.represent_scalar("tag:yaml.org,2002:str", str(x), style="|")
+            return self.represent_str(str(x))
+        if isinstance(x, bool):
+            return self.represent_bool(bool(x))
+        if isinstance(x, int):
+            return self.represent_int(int(x))
+        if isinstance(x, float):
+            return self.represent_float(float(x))
+        if isinstance(x, Mapping):
+            return self.represent_dict({**x})
+        if isinstance(x, datetime):
+            return self.represent_str(x.astimezone(timezone.utc).replace(tzinfo=None).isoformat() + "Z")
+        if isinstance(x, date):
+            return self.represent_str(x.isoformat())
+        if isinstance(x, Iterable):
+            return self.represent_list([*x])
+        if isinstance(x, Enum):
+            return self.represent_str(x.name)
+
+        return super().represent_data(x)
+
+
+YAML_SEPARATOR = "\n...\n"
+
+
+def yamlify(x: Any, sort_keys: bool = False, Dumper: Type[Dumper] = Dumper, **kwargs: Any) -> str:
+    """Convert object to YAML."""
+
+    result = cast(str, yaml.dump(x, sort_keys=sort_keys, Dumper=Dumper, **kwargs))
+
+    return (
+        result[: -len(YAML_SEPARATOR)]
+        if result.endswith(YAML_SEPARATOR)
+        else result[:-1] if result.endswith("\n") else result
+    )

kelvin/api/client/utils.py

@@ -0,0 +1,316 @@
+"""
+Utilities.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import re
+from datetime import timedelta
+from functools import wraps
+from io import IOBase
+from itertools import islice, zip_longest
+from mimetypes import guess_type
+from operator import itemgetter
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+T = TypeVar("T")
+FileTuple = Tuple[Optional[str], Union[IOBase, bytes], Optional[str]]
+
+MICROSECOND = int(1e6)
+SCALE = {
+    "h": 60 * 60 * MICROSECOND,
+    "m": 60 * MICROSECOND,
+    "s": 1 * MICROSECOND,
+    "ms": MICROSECOND // 1000,
+    "us": 1,
+}
+
+
+def duration(x: timedelta) -> str:
+    """Convert to Go Duration."""
+
+    microseconds = int(x.total_seconds() * MICROSECOND)
+    if not microseconds:
+        return "0s"
+
+    result: List[str] = []
+    if microseconds < 0:
+        microseconds *= -1
+        result += ["-"]
+
+    for unit, scale in SCALE.items():
+        value, microseconds = divmod(microseconds, scale)
+        if value:
+            result += [f"{value}{unit}"]
+        if not microseconds:
+            break
+
+    return "".join(result)
+
+
+def snake_name(name: str) -> str:
+    """Create underscore-separated name from camel-case."""
+
+    return re.sub(r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "_", name).lower()
+
+
+@contextlib.contextmanager
+def chdir(path: Optional[Path]) -> Iterator[None]:
+    """Changes working directory and returns to previous on exit."""
+
+    if path is None:
+        yield
+    else:
+        prev_cwd = Path.cwd()
+        try:
+            os.chdir(path if path.is_dir() else path.parent)
+            yield
+        finally:
+            os.chdir(prev_cwd)
+
+
+def relative_to_home(path: Path) -> Path:
+    """Make path relative to HOME."""
+
+    try:
+        return Path("~").joinpath(path.relative_to(Path.home()))
+    except ValueError:
+        return path
+
+
+class instance_classproperty(Generic[T]):
+    """Property that works on instances and classes."""
+
+    def __init__(self, fget: Callable[..., T]) -> None:
+        """Initialise instance-classproperty."""
+
+        self.fget = fget
+
+    def __get__(self, owner_self: Any, owner_cls: Any) -> T:
+        """Get descriptor."""
+
+        return self.fget(owner_self if owner_self is not None else owner_cls)
+
+
+class instance_classmethod(classmethod, Generic[T]):
+    """Method that works on instances and classes."""
+
+    def __init__(self, f: Callable[..., T]) -> None:
+        """Initialise instance-classmethod."""
+
+        self.f = f
+
+    def __get__(self, owner_self: Any, owner_cls: Any) -> Callable[..., T]:  # type: ignore
+        """Get descriptor."""
+
+        x = owner_self if owner_self is not None else owner_cls
+
+        @wraps(self.f)
+        def wrapper(*args: Any, **kwargs: Any) -> T:
+            return self.f(x, *args, **kwargs)
+
+        return wrapper
+
+
+def update(data: MutableMapping[str, Any], *more: Mapping[str, Any]) -> MutableMapping[str, Any]:
+    """Merge mappings into data."""
+
+    if data is None:
+        data = {}
+
+    for x in more:
+        for k, v in x.items():
+            if isinstance(v, Mapping):
+                update(data.setdefault(k, {}), v)
+            else:
+                data[k] = v
+
+    return data
+
+
+def merge(*args: Mapping[str, Any], **kwargs: Any) -> Dict[str, Any]:
+    """Merge dictionaries."""
+
+    result: Dict[str, Any] = {}
+
+    if kwargs:
+        args += (kwargs,)
+
+    for arg in args:
+        if arg is None:
+            continue
+        for k, v in arg.items():
+            result[k] = merge(result.get(k) or {}, v) if isinstance(v, Mapping) else v
+
+    return result
+
+
+def _make_key(k: str, q: str, sep: str = ".") -> str:
+    """Make flattened key."""
+
+    if not q:
+        return k
+
+    if not q.startswith("["):
+        k += sep
+
+    return f"{k}{q}"
+
+
+def flatten(x: Any, sep: str = ".", sequence: bool = True) -> List[Tuple[str, Any]]:
+    """Flatten nested mappings and sequences."""
+
+    # basic conversions
+    if isinstance(x, Mapping):
+        x = x.items()
+    elif sequence and isinstance(x, Sequence) and not isinstance(x, str):
+        x = ((f"[{i}]", v) for i, v in enumerate(x))
+    else:
+        return [("", x)]
+
+    return [(_make_key(k, q, sep), w) for k, v in x for q, w in flatten(v, sep, sequence)]
+
+
+def inflate(x: Iterable[Tuple[str, Any]], separator: str = ".") -> Dict[str, Any]:
+    """Re-inflate flattened keys into nested object."""
+
+    result: Dict[str, Any] = {}
+    inputs: List[Tuple[Sequence[Union[int, str]], Any]] = []
+
+    delims = re.compile("|".join(re.escape(x) for x in [separator, "[", "]"]))
+
+    for key_, value_ in x:
+        split_key: List[Union[int, str]] = [
+            int(k) if k.isnumeric() else k for k in delims.split(key_) if k and not delims.match(k)
+        ]
+        inputs += [(split_key, value_)]
+
+    root: Any
+
+    for key, value in sorted(inputs, key=itemgetter(0)):
+        root = result
+        for k, l in zip_longest(key, key[1:]):
+            if isinstance(k, str):
+                if not isinstance(root, Dict):
+                    raise ValueError("Invalid structure")
+
+                if k not in root:
+                    if isinstance(l, str):
+                        root[k] = {}
+                    elif isinstance(l, int):
+                        root[k] = []
+            else:
+                if not isinstance(root, List):
+                    raise ValueError("Invalid structure")
+
+                n = len(root)
+                if k > n:
+                    if isinstance(l, str):
+                        root += [{} for _ in range(k - n + 1)]
+                    elif isinstance(l, int):
+                        root += [[] for _ in range(k - n + 1)]
+                    else:
+                        root += [None] * (k - n + 1)
+
+            if l is None:
+                root[k] = value
+            else:
+                root = root[k]
+
+    return result
+
+
+def chunks(x: Sequence[T], n: int) -> Iterator[Sequence[T]]:
+    """Yield successive n-sized chunks from l."""
+
+    for i in range(0, len(x), n):
+        yield x[i : (i + n)]
+
+
+def map_chunks(chunk_size: int, f: Callable[..., Any], x: Iterable[T], **kwargs: Any) -> Iterator[Any]:
+    """Map function to chunks or iterable."""
+
+    while True:
+        result = f(islice(x, chunk_size), **kwargs)
+        if result is None:
+            break
+        yield result
+
+
+def deep_itemgetter(path: str) -> Callable[[str], Any]:
+    """Deep itemgetter, halting on first ``None``"""
+
+    if "." not in path:
+        return itemgetter(path)
+
+    def getter(x: Any) -> Any:
+        if x is None:
+            return None
+        for key in path.split("."):
+            x = x[key]
+            if x is None:
+                break
+        return x
+
+    return getter
+
+
+def file_tuple(x: Union[str, IOBase, bytes, Tuple]) -> FileTuple:
+    """Create file tuple for multipart request."""
+
+    if isinstance(x, tuple):
+        name, data, *tail = x
+        if not tail:
+            mime_type = None
+        elif len(tail) == 1:
+            mime_type = tail[0]
+        else:
+            raise ValueError("Too many values")
+    else:
+        if isinstance(x, str):
+            name = x
+            data = open(x, "rb")
+        elif isinstance(x, IOBase):
+            name = getattr(x, "name", None)
+            data = x
+        else:
+            name = None
+            data = x
+
+        mime_type = None
+
+    if mime_type is None and name is not None:
+        mime_type = guess_type(name)
+
+    return (name, data, mime_type)
+
+
+def metadata_tuple(x: Dict[str, Any]) -> Tuple[None, str]:
+    """Convert metadata string to tuple.
+
+    Args:
+        x (Dict[str, Any]): Metadata string to be converted to tuple
+
+    Returns:
+        Tuple[None, str]: Tuple with None and metadata string
+    """
+    return (None, json.dumps(x))

kelvin/api/client/version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)