emudb-api-py 0.1.0__py3-none-any.whl

emudb_api_py/__init__.py

@@ -0,0 +1,3 @@
+from emudb_api_py.core import EmuAPIConnector
+
+__all__ = ["EmuAPIConnector"]

emudb_api_py/core.py

@@ -0,0 +1,69 @@
+import json
+from contextlib import contextmanager
+from datetime import datetime, timedelta
+
+import requests
+
+from emudb_api_py.sessions.core import (
+    BaseSession,
+    EmuAPICore,
+    EmuApiError,
+    EmuAPIUrl,
+    EmuToken,
+)
+
+
+class EmuAPIConnector(EmuAPICore):
+    def __init__(
+        self,
+        host: str,
+        user: str,
+        pwd: str,
+        tenant: str,
+    ) -> None:
+        self._tenant = tenant
+        self._url = EmuAPIUrl(f"{host}/{self._tenant}")
+        self._user = user
+        self._pwd = pwd
+
+    @property
+    def _creds(self) -> str:
+        return json.dumps(
+            {
+                "username": self._user,
+                "password": self._pwd,
+                "timeout": 30,
+                # We handle token renewal ourselves so we don't have to update the
+                # cached token after every request
+                "renew": False,
+            }
+        )
+
+    @contextmanager
+    def session(self):
+        token = self._signin()
+        yield BaseSession(self._url, token)
+        self._signout(token)
+
+    @staticmethod
+    def _parse_create_token_resp(resp: requests.Response) -> EmuToken:
+        if resp.status_code == 201:
+            # Bearer token comes back in the headers:
+            token = resp.headers["Authorization"]
+            data = json.loads(resp.content)["data"]
+            # Subtract 30 seconds from the token expiration so that it doesn't
+            # expire during request processing if a request is submitted to the API
+            # very close to expiration:
+            exp = datetime.fromtimestamp(data["exp"]) - timedelta(seconds=30)
+            return EmuToken(value=token, exp=exp)
+        else:
+            raise EmuApiError(resp.status_code, resp.content)
+
+    def _signin(self) -> EmuToken:
+        resp = requests.post(
+            self._url.tokens, data=self._creds, headers=self._gen_headers()
+        )
+        return self._parse_create_token_resp(resp)
+
+    def _signout(self, token: EmuToken) -> None:
+        requests.delete(self._url.tokens, headers=self._gen_headers(token))

emudb_api_py/schemas/core.py

@@ -0,0 +1,222 @@
+from abc import ABC, abstractmethod
+import json
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Optional, TypedDict
+
+from pydantic import BaseModel
+
+
+class BaseSchema(BaseModel):
+    pass
+
+
+class _EmuSchemaField(TypedDict):
+    present: bool
+    rest_type: Optional[str]
+    new_field: Optional[str]
+
+
+class EmuAPISchemaProp(TypedDict):
+    type: str | list[str]
+    format: Optional[str]
+    pattern: Optional[str]
+    items: Optional[EmuAPISchemaProp]
+    properties: Optional[dict[str, EmuAPISchemaProp]]
+    additionalProperties: Optional[bool]
+
+
+class BaseEmuSchema(BaseSchema, ABC):
+    irn: int
+    AdmDateInserted: str
+    AdmTimeInserted: str
+    AdmTimeModified: str
+    AdmDateModified: str
+
+    @classmethod
+    @abstractmethod
+    def get_resource(cls) -> str:
+        return NotImplemented
+
+    @classmethod
+    def decode_irn(cls, irnobj: Mapping[str, Any]) -> int:
+        id = irnobj["id"]
+        return cls.decode_id_uri(id)
+
+    @staticmethod
+    def decode_id_uri(uri: str) -> int:
+        try:
+            # id uri is in the format: emu:/tenant/resource/123
+            return int(uri.split("/")[-1])
+        except ValueError:
+            raise ValueError(
+                f"emu irn object has unexpected format in 'id' field: {id}"
+            )
+
+    @classmethod
+    def gen_field_list(
+        cls, include: Iterable[str] | None = None, exclude: Iterable[str] | None = None
+    ) -> list[str]:
+        """
+        Generates a list of field names for use when querying the emu REST API.
+
+        Args:
+            include (Iterable[str] | None, optional): Optional list of fields to
+                include. Defaults to None, which will provide all available fields
+                for the schema.
+            exclude (Iterable[str] | None, optional): Optional list of fields to
+                exclude from all the available fields. Defaults to None.
+
+        Returns:
+            list[str]: The list of fields associated with this schema.
+        """
+        fields = [*include] if include is not None else [*cls.__annotations__.keys()]
+        if exclude:
+            for ex in exclude:
+                fields.remove(ex)
+        return fields
+
+    @classmethod
+    def gen_field_select(
+        cls, include: Iterable[str] | None = None, exclude: Iterable[str] | None = None
+    ) -> str:
+        # exclude = ["irn"] if exclude is None else {*exclude, "irn"}
+        fields = cls.gen_field_list(include, exclude)
+        return "id," + ",".join([f"data.{f}" for f in fields])
+
+
+_API_TYPE_MAP = {
+    "string": "str",
+    "integer": "int",
+    "number": "float",
+}
+
+
+def assemble_items_type_str(prop: EmuAPISchemaProp) -> str:
+    result = ""
+    api_type = prop["type"]
+    items = prop.get("items")
+    if items:
+        inner_result = assemble_items_type_str(items)
+        result = f"list[{inner_result}]"
+        if "null" in api_type:
+            result = f"Optional[{result}]"
+    elif api_type == "array":
+        raise ValueError(
+            f"Expected 'array' api type to have 'items' property: ({prop})"
+        )
+    else:
+        result = _API_TYPE_MAP[api_type[0]]
+        if "null" in api_type:
+            result = f"Optional[{result}]"
+    return result
+
+
+def assemble_class_str(
+    name: str,
+    props: dict[str, EmuAPISchemaProp],
+    level: int = 0,
+) -> tuple[str, bool]:
+    has_subclasses = False
+    result = f"{'\t' * level}class "
+    result += f"{name}(BaseEmuSchema)" if level == 0 else f"_{name}(BaseSchema)"
+    result += ":\n"
+    subclasses = list[str]()
+    fields = list[str]()
+    for field, prop in props.items():
+        items = prop.get("items")
+        api_type = prop["type"]
+        if items:
+            subprops = items.get("properties")
+            if subprops:
+                clsname = field.replace("_grp", "").replace("_subgrp", "")
+                has_subclasses = True
+                subclass_str, _ = assemble_class_str(clsname, subprops, level + 1)
+                subclasses.append(subclass_str)
+                _type = f"_{clsname}"
+                if isinstance(items["type"], list) and "null" in items["type"]:
+                    _type = f"Optional[{_type}]"
+                if api_type == "array":
+                    _type = f"list[{_type}]"
+            else:
+                _type = assemble_items_type_str(prop)
+        elif isinstance(api_type, str):
+            _type = _API_TYPE_MAP[api_type]
+        else:
+            raise ValueError(
+                f"Unexpected property structure from API ({field}: {prop})"
+            )
+        fields.append(f"{'\t' * (level + 1)}{field}: Optional[{_type}]\n")
+    for subclass in subclasses:
+        result += subclass
+    for field in fields:
+        result += field
+    result += "\n"
+    return result, has_subclasses
+
+
+def create_schema_module(
+    schema_dir: str | Path, resource: str, schema_class_name: str
+) -> None:
+    schema_dir = Path(schema_dir)
+    with open(schema_dir.joinpath(f"{resource}_schema.json")) as file:
+        raw: dict[str, EmuAPISchemaProp] = json.loads(file.read())
+    for key in BaseEmuSchema.__annotations__.keys():
+        if key in raw:
+            raw.pop(key)
+    class_str, has_subclasses = assemble_class_str(schema_class_name, raw)
+    result = ""
+    if "Optional" in class_str:
+        result += "from typing import Optional\n\n"
+    result += "from emudb_api_py.schemas.core import BaseEmuSchema"
+    if has_subclasses:
+        result += ", BaseSchema"
+    result += f"\n\n\n{class_str}"
+    with open(f"emudb_api_py/schemas/{resource}.py", "w") as file:
+        file.write(result)
+
+
+def compare_with_rest_schema(
+    schema_dir: str | Path, schema: type[BaseEmuSchema]
+) -> dict[str, _EmuSchemaField]:
+    schema_dir = Path(schema_dir)
+    with open(schema_dir.joinpath(f"{schema.get_resource()}_schema.json")) as file:
+        raw = json.loads(file.read())
+    flat_schema = flatten_rest_schema(raw)
+    results = {
+        field: _EmuSchemaField(present=False, rest_type=None, new_field=None)
+        for field in schema.__annotations__.keys()
+    }
+    for field, fschema in flat_schema.items():
+        f = field
+        new_field: str | None = None
+        comment: str | None = fschema.get("$comment")
+        if comment and comment in results:
+            f = comment
+            new_field = field
+        if f in results:
+            results[f] = _EmuSchemaField(
+                present=True, rest_type=fschema["type"], new_field=new_field
+            )
+    with open(
+        schema_dir.joinpath(f"{schema.get_resource()}_compare.json"), "w"
+    ) as file:
+        file.write(json.dumps(results))
+    return results
+
+
+def flatten_rest_schema(
+    props: dict[str, dict[str, Any]], parent_key: str | None = None
+) -> dict[str, dict[str, Any]]:
+    results = dict[str, dict[str, Any]]()
+    for field, fschema in props.items():
+        f = f"{parent_key}.{field}" if parent_key else field
+        if "items" in fschema:
+            items = fschema["items"]
+            if "properties" in items:
+                flat_props = flatten_rest_schema(items["properties"], f)
+                results = {**results, **flat_props}
+            else:
+                results[f] = fschema
+        else:
+            results[f] = fschema
+    return results