feat: Table multi-delete + refactoring core libs (#34)

Author: mure

nisystemlink/clients/core/_api_error.py

@@ -2,181 +2,31 @@
 
 """Implementation of ApiError."""
 
-import typing
-from typing import Any, Dict, Iterable, List, Optional
+from typing import List, Optional
 
-from typing_extensions import final
+from ._uplink._json_model import JsonModel
 
 
-@final
-class ApiError:
+class ApiError(JsonModel):
     """Represents the standard error structure for SystemLink API responses."""
 
-    def __init_subclass__(cls) -> None:
-        raise TypeError("type 'ApiError' is not an acceptable base type")
+    name: Optional[str] = None
+    """String error code."""
 
-    def __init__(self) -> None:
-        self._name = None  # type: Optional[str]
-        self._code = None  # type: Optional[int]
-        self._message = None  # type: Optional[str]
-        self._args = []  # type: List[str]
-        self._resource_type = None  # type: Optional[str]
-        self._resource_id = None  # type: Optional[str]
-        self._inner_errors = []  # type: List[ApiError]
+    code: Optional[int] = None
+    """Numeric error code."""
 
-    @property
-    def name(self) -> Optional[str]:  # noqa: D401
-        """The name of the error."""
-        return self._name
+    message: Optional[str] = None
+    """Complete error message."""
 
-    @name.setter
-    def name(self, value: Optional[str]) -> None:
-        self._name = value
+    args: List[str] = []
+    """Positional arguments for the error code."""
 
-    @property
-    def code(self) -> Optional[int]:  # noqa: D401
-        """The numeric code associated with the error."""
-        return self._code
+    resource_type: Optional[str] = None
+    """Type of resource associated with the error."""
 
-    @code.setter
-    def code(self, value: Optional[int]) -> None:
-        self._code = value
+    resource_id: Optional[str] = None
+    """Identifier of the resource associated with the error."""
 
-    @property
-    def message(self) -> Optional[str]:  # noqa: D401
-        """The error message."""
-        return self._message
-
-    @message.setter
-    def message(self, value: Optional[str]) -> None:
-        self._message = value
-
-    @property
-    def args(self) -> List[str]:  # noqa: D401
-        """The list of positional arguments formatted into the error."""
-        return self._args
-
-    @args.setter
-    def args(self, value: Iterable[str]) -> None:
-        self._args = list(value)
-
-    @property
-    def resource_type(self) -> Optional[str]:  # noqa: D401
-        """The type of resource associated with the error, if any.
-
-        Set this when setting :attr:`resource_id`.
-        """
-        return self._resource_type
-
-    @resource_type.setter
-    def resource_type(self, value: Optional[str]) -> None:
-        self._resource_type = value
-
-    @property
-    def resource_id(self) -> Optional[str]:  # noqa: D401
-        """The ID of the resource associated with the error, if any.
-
-        Set :attr:`resource_type` when setting this property.
-        """
-        return self._resource_id
-
-    @resource_id.setter
-    def resource_id(self, value: Optional[str]) -> None:
-        self._resource_id = value
-
-    @property
-    def inner_errors(self) -> List["ApiError"]:  # noqa: D401
-        """The list of inner errors."""
-        return self._inner_errors
-
-    @inner_errors.setter
-    def inner_errors(self, value: Iterable["ApiError"]) -> None:
-        self._inner_errors = list(value)
-
-    def copy(self) -> "ApiError":
-        """Get a copy of this object."""
-        new = ApiError()
-        new.name = self.name
-        new.code = self.code
-        new.message = self.message
-        new.args = self.args
-        new.resource_type = self.resource_type
-        new.resource_id = self.resource_id
-        new.inner_errors = self.inner_errors
-        return new
-
-    def __str__(self) -> str:
-        txt = ""
-        if self._name:
-            txt += "Name: {}\n".format(self._name)
-        if self._code:
-            txt += "Code: {}\n".format(self._code)
-        if self._message:
-            txt += "Message: {}\n".format(self._message)
-        if self._args:
-            args = "\n  ".join(self._args)
-            txt += "Args:\n  {}\n".format(args)
-        if self._resource_type:
-            txt += "Resource Type: {}\n".format(self._resource_type)
-        if self._resource_id:
-            txt += "Resource Id: {}\n".format(self._resource_id)
-        if self._inner_errors:
-            inner_errors = "\n  ".join(str(e) for e in self._inner_errors)
-            txt += "Inner Errors:\n  {}\n".format(
-                str(inner_errors).replace("\n", "\n  ")
-            )
-        return txt[:-1]
-
-    def __repr__(self) -> str:
-        return (
-            "ApiError(name={!r}, code={!r}, message={!r}, args={!r}, "
-            "resource_type={!r}, resource_id={!r}, inner_errors={!r})".format(
-                self.name,
-                self.code,
-                self.message,
-                self.args,
-                self.resource_type,
-                self.resource_id,
-                self.inner_errors,
-            )
-        )
-
-    def __eq__(self, other: object) -> bool:
-        other_ = typing.cast(ApiError, other)
-        return all(
-            (
-                isinstance(other, ApiError),
-                self.name == other_.name,
-                self.code == other_.code,
-                self.message == other_.message,
-                self.args == other_.args,
-                self.resource_type == other_.resource_type,
-                self.resource_id == other_.resource_id,
-                self.inner_errors == other_.inner_errors,
-            )
-        )
-
-    def __hash__(self) -> int:
-        return hash(
-            (
-                self.name,
-                self.code,
-                self.message,
-                tuple(self.args),
-                self.resource_type,
-                self.resource_id,
-                tuple(self.inner_errors),
-            )
-        )
-
-    @classmethod
-    def from_json_dict(cls, data: Dict[str, Any]) -> "ApiError":
-        err = cls()
-        err.name = data.get("name")
-        err.code = data.get("code")
-        err.message = data.get("message")
-        err.args = data.get("args", [])
-        err.resource_type = data.get("resourceType")
-        err.resource_id = data.get("resourceId")
-        err.inner_errors = [cls.from_json_dict(e) for e in data.get("innerErrors", [])]
-        return err
+    inner_errors: List["ApiError"] = []
+    """Inner errors when the top-level error represents more than one error."""

nisystemlink/clients/core/_internal/_http_client.py

@@ -286,7 +286,7 @@ def _handle_response(response: HttpResponse, method: str, uri: str) -> Any:
 
         if data:
             err_dict = typing.cast(Dict[str, Any], data).get("error", {})
-            err_obj = core.ApiError.from_json_dict(err_dict) if err_dict else None
+            err_obj = core.ApiError.parse_obj(err_dict) if err_dict else None
         else:
             err_obj = None
 

nisystemlink/clients/core/_uplink/_base_client.py

@@ -1,11 +1,12 @@
 # mypy: disable-error-code = misc
 
-import json
-from typing import Dict, Optional, Type
+from json import loads
+from typing import Any, Callable, Dict, get_origin, Optional, Type, Union
 
 from nisystemlink.clients import core
+from pydantic import parse_obj_as
 from requests import JSONDecodeError, Response
-from uplink import Consumer, dumps, response_handler
+from uplink import commands, Consumer, converters, response_handler, utils
 
 from ._json_model import JsonModel
 
@@ -26,7 +27,7 @@ def _handle_http_status(response: Response) -> Optional[Response]:
     try:
         content = response.json()
         if content and "error" in content:
-            err_obj = core.ApiError.from_json_dict(content["error"])
+            err_obj = core.ApiError.parse_obj(content["error"])
         else:
             err_obj = None
 
@@ -39,10 +40,33 @@ def _handle_http_status(response: Response) -> Optional[Response]:
         raise core.ApiException(msg, http_status_code=response.status_code)
 
 
-@dumps.to_json(JsonModel)
-def _deserialize_model(model_cls: Type[JsonModel], model_instance: JsonModel) -> Dict:
-    """Turns a :class:`.JsonModel` instance into a dictionary for serialization."""
-    return json.loads(model_instance.json(by_alias=True, exclude_unset=True))
+class _JsonModelConverter(converters.Factory):
+    def create_request_body_converter(
+        self, _class: Type, _: commands.RequestDefinition
+    ) -> Optional[Callable[[JsonModel], Dict]]:
+        def encoder(model: JsonModel) -> Dict:
+            return loads(model.json(by_alias=True, exclude_unset=True))
+
+        if utils.is_subclass(_class, JsonModel):
+            return encoder
+        else:
+            return None
+
+    def create_response_body_converter(
+        self, _class: Type, _: commands.RequestDefinition
+    ) -> Optional[Callable[[Response], Any]]:
+        def decoder(response: Response) -> Any:
+            try:
+                data = response.json()
+            except AttributeError:
+                data = response
+
+            return parse_obj_as(_class, data)
+
+        if get_origin(_class) is Union or utils.is_subclass(_class, JsonModel):
+            return decoder
+        else:
+            return None
 
 
 class BaseClient(Consumer):
@@ -56,7 +80,7 @@ def __init__(self, configuration: core.HttpConfiguration):
         """
         super().__init__(
             base_url=configuration.server_uri,
-            converter=_deserialize_model,
+            converter=_JsonModelConverter(),
             hooks=[_handle_http_status],
         )
         if configuration.api_keys:

nisystemlink/clients/core/_uplink/_methods.py

@@ -0,0 +1,52 @@
+"""Wrappers around uplink HTTP decorators with proper type annotations."""
+
+from typing import Any, Callable, Optional, Sequence, Tuple, TypeVar, Union
+
+from uplink import Body, commands, json, returns
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def get(path: str, args: Optional[Sequence[Any]] = None) -> Callable[[F], F]:
+    """Annotation for a GET request."""
+
+    def decorator(func: F) -> F:
+        return commands.get(path, args=args)(func)  # type: ignore
+
+    return decorator
+
+
+def post(
+    path: str,
+    args: Optional[Sequence[Any]] = None,
+    return_key: Optional[Union[str, Tuple[str, ...]]] = None,
+) -> Callable[[F], F]:
+    """Annotation for a POST request with a JSON request body. If args is not
+    specified, defaults to a single argument that represents the request body.
+    """
+
+    def decorator(func: F) -> F:
+        result = json(commands.post(path, args=args or (Body,))(func))
+        if return_key:
+            result = returns.json(key=return_key)(result)
+        return result  # type: ignore
+
+    return decorator
+
+
+def patch(path: str, args: Optional[Sequence[Any]] = None) -> Callable[[F], F]:
+    """Annotation for a PATCH request with a JSON request body."""
+
+    def decorator(func: F) -> F:
+        return json(commands.patch(path, args=args)(func))  # type: ignore
+
+    return decorator
+
+
+def delete(path: str, args: Optional[Sequence[Any]] = None) -> Callable[[F], F]:
+    """Annotation for a DELETE request."""
+
+    def decorator(func: F) -> F:
+        return commands.delete(path, args=args)(func)  # type: ignore
+
+    return decorator

nisystemlink/clients/dataframe/_data_frame_client.py

@@ -1,13 +1,11 @@
-# TODO: Wrap Uplink decorators to add typing information
-# mypy: disable-error-code = misc
-
 """Implementation of DataFrameClient."""
 
 from typing import List, Optional
 
 from nisystemlink.clients import core
 from nisystemlink.clients.core._uplink._base_client import BaseClient
-from uplink import Body, delete, get, json, patch, Path, post, Query, returns
+from nisystemlink.clients.core._uplink._methods import delete, get, patch, post
+from uplink import Body, Field, Path, Query
 
 from . import models
 
@@ -68,9 +66,7 @@ def list_tables(
         """
         ...
 
-    @json
-    @returns.json(key="id")
-    @post(_BASE_PATH + "/tables", args=(Body,))
+    @post(_BASE_PATH + "/tables", return_key="id")
     def create_table(self, table: models.CreateTableRequest) -> str:
         """Create a new table with the provided metadata and column definitions.
 
@@ -82,8 +78,7 @@ def create_table(self, table: models.CreateTableRequest) -> str:
         """
         ...
 
-    @json
-    @post(_BASE_PATH + "/query-tables", args=(Body,))
+    @post(_BASE_PATH + "/query-tables")
     def query_tables(self, query: models.QueryTablesRequest) -> models.PagedTables:
         """Queries available tables on the SystemLink DataFrame service and returns their metadata.
 
@@ -107,8 +102,7 @@ def get_table_metadata(self, id: str) -> models.TableMetadata:
         """
         ...
 
-    @json
-    @patch(_BASE_PATH + "/tables/{id}", args=(Path, Body))
+    @patch(_BASE_PATH + "/tables/{id}", args=[Path, Body])
     def modify_table(self, id: str, update: models.ModifyTableRequest) -> None:
         """Modify properties of a table or its columns.
 
@@ -126,3 +120,14 @@ def delete_table(self, id: str) -> None:
             id (str): Unique ID of a DataFrame table.
         """
         ...
+
+    @post(_BASE_PATH + "/delete-tables", args=[Field("ids")])
+    def delete_tables(
+        self, ids: List[str]
+    ) -> Optional[models.DeleteTablesPartialSuccess]:
+        """Deletes multiple tables.
+
+        Args:
+            ids (List[str]): List of unique IDs of DataFrame tables.
+        """
+        ...