feat: Add modify_tables method (#35)

Author: mure

nisystemlink/clients/core/_uplink/_base_client.py

@@ -72,14 +72,15 @@ def decoder(response: Response) -> Any:
 class BaseClient(Consumer):
     """Base class for SystemLink clients, built on top of `Uplink <https://github.com/prkumar/uplink>`_."""
 
-    def __init__(self, configuration: core.HttpConfiguration):
+    def __init__(self, configuration: core.HttpConfiguration, base_path: str = ""):
         """Initialize an instance.
 
         Args:
             configuration: Defines the web server to connect to and information about how to connect.
+            base_path: The base path for all API calls.
         """
         super().__init__(
-            base_url=configuration.server_uri,
+            base_url=configuration.server_uri + base_path,
             converter=_JsonModelConverter(),
             hooks=[_handle_http_status],
         )

nisystemlink/clients/dataframe/_data_frame_client.py

@@ -11,8 +11,6 @@
 
 
 class DataFrameClient(BaseClient):
-    _BASE_PATH = "/nidataframe/v1"
-
     def __init__(self, configuration: Optional[core.HttpConfiguration] = None):
         """Initialize an instance.
 
@@ -24,15 +22,15 @@ def __init__(self, configuration: Optional[core.HttpConfiguration] = None):
         if configuration is None:
             configuration = core.JupyterHttpConfiguration()
 
-        super().__init__(configuration)
+        super().__init__(configuration, "/nidataframe/v1/")
 
-    @get(_BASE_PATH)
+    @get("")
     def api_info(self) -> models.ApiInfo:
         """Returns information about available API operations."""
         ...
 
     @get(
-        _BASE_PATH + "/tables",
+        "tables",
         args=(
             Query("take"),
             Query("id"),
@@ -66,7 +64,7 @@ def list_tables(
         """
         ...
 
-    @post(_BASE_PATH + "/tables", return_key="id")
+    @post("tables", return_key="id")
     def create_table(self, table: models.CreateTableRequest) -> str:
         """Create a new table with the provided metadata and column definitions.
 
@@ -78,7 +76,7 @@ def create_table(self, table: models.CreateTableRequest) -> str:
         """
         ...
 
-    @post(_BASE_PATH + "/query-tables")
+    @post("query-tables")
     def query_tables(self, query: models.QueryTablesRequest) -> models.PagedTables:
         """Queries available tables on the SystemLink DataFrame service and returns their metadata.
 
@@ -90,7 +88,7 @@ def query_tables(self, query: models.QueryTablesRequest) -> models.PagedTables:
         """
         ...
 
-    @get(_BASE_PATH + "/tables/{id}")
+    @get("tables/{id}")
     def get_table_metadata(self, id: str) -> models.TableMetadata:
         """Retrieves the metadata and column information for a single table identified by its ID.
 
@@ -102,7 +100,7 @@ def get_table_metadata(self, id: str) -> models.TableMetadata:
         """
         ...
 
-    @patch(_BASE_PATH + "/tables/{id}", args=[Path, Body])
+    @patch("tables/{id}", args=[Path, Body])
     def modify_table(self, id: str, update: models.ModifyTableRequest) -> None:
         """Modify properties of a table or its columns.
 
@@ -112,7 +110,7 @@ def modify_table(self, id: str, update: models.ModifyTableRequest) -> None:
         """
         ...
 
-    @delete(_BASE_PATH + "/tables/{id}")
+    @delete("tables/{id}")
     def delete_table(self, id: str) -> None:
         """Deletes a table.
 
@@ -121,13 +119,32 @@ def delete_table(self, id: str) -> None:
         """
         ...
 
-    @post(_BASE_PATH + "/delete-tables", args=[Field("ids")])
+    @post("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.
+
+        Returns:
+            A partial success if any tables failed to delete, or None if all
+            tables were deleted successfully.
+        """
+        ...
+
+    @post("modify-tables")
+    def modify_tables(
+        self, updates: models.ModifyTablesRequest
+    ) -> Optional[models.ModifyTablesPartialSuccess]:
+        """Modify the properties associated with the tables identified by their IDs.
+
+        Args:
+            updates: The table modifications to apply.
+
+        Returns:
+            A partial success if any tables failed to be modified, or None if all
+            tables were modified successfully.
         """
         ...

nisystemlink/clients/dataframe/models/__init__.py

@@ -4,7 +4,9 @@
 from ._column_type import ColumnType
 from ._data_type import DataType
 from ._delete_tables_partial_success import DeleteTablesPartialSuccess
+from ._modify_tables_partial_success import ModifyTablesPartialSuccess
 from ._modify_table_request import ColumnMetadataPatch, ModifyTableRequest
+from ._modify_tables_request import ModifyTablesRequest, TableMetdataModification
 from ._order_by import OrderBy
 from ._paged_tables import PagedTables
 from ._query_tables_request import QueryTablesRequest

nisystemlink/clients/dataframe/models/_modify_tables_partial_success.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from nisystemlink.clients.core import ApiError
+from nisystemlink.clients.core._uplink._json_model import JsonModel
+
+from ._modify_tables_request import TableMetdataModification
+
+
+class ModifyTablesPartialSuccess(JsonModel):
+    """The result of modifying multiple tables when one or more tables could not be modified."""
+
+    modified_table_ids: List[str]
+    """The IDs of the tables that were successfully modified."""
+
+    failed_modifications: List[TableMetdataModification]
+    """The requested modifications that could not be applied."""
+
+    error: ApiError
+    """The error that occurred when modifying the tables."""

nisystemlink/clients/dataframe/models/_modify_tables_request.py

@@ -0,0 +1,44 @@
+from typing import Dict, List, Optional
+
+from nisystemlink.clients.core._uplink._json_model import JsonModel
+
+
+class TableMetdataModification(JsonModel):
+    """Contains the metadata properties to modify. Values not included in the
+    request or included with a ``None`` value will remain unchanged.
+    """
+
+    id: str
+    """The ID of the table to modify."""
+
+    metadata_revision: Optional[int] = None
+    """When specified, this is an integer that must match the last known
+    revision number of the table, incremented by one. If it doesn't match the
+    current ``metadataRevision`` incremented by one at the time of execution, the
+    modify request will be rejected with a conflict error. This is used to
+    ensure that changes to this table's metadata are based on a known, previous
+    state."""
+
+    name: Optional[str] = None
+    """The new name of the table."""
+
+    workspace: Optional[str] = None
+    """The new workspace for the table. Changing the workspace requires
+    permission to delete the table in its current workspace and permission to
+    create the table in its new workspace."""
+
+    properties: Optional[Dict[str, Optional[str]]] = None
+    """The properties to modify. A map of key value properties containing the
+    metadata to be added or modified. Setting a property value to ``None`` will
+    delete the property. Existing properties not included in the map are
+    unaffected unless replace is true in the top-level request object."""
+
+
+class ModifyTablesRequest(JsonModel):
+    """Contains one or more table modifications to apply."""
+
+    tables: List[TableMetdataModification]
+    """The table modifications to apply. Each table may only appear once in the list."""
+
+    replace: Optional[bool] = None
+    """When true, existing properties are replaced instead of merged."""

tests/integration/dataframe/test_dataframe.py

@@ -1,12 +1,22 @@
 # -*- coding: utf-8 -*-
 from datetime import datetime, timezone
-from typing import List
+from typing import List, Optional
 
 import pytest  # type: ignore
 from nisystemlink.clients.core import ApiException
 from nisystemlink.clients.dataframe import DataFrameClient
 from nisystemlink.clients.dataframe import models
 
+basic_table_model = models.CreateTableRequest(
+    columns=[
+        models.Column(
+            name="index",
+            data_type=models.DataType.Int32,
+            column_type=models.ColumnType.Index,
+        )
+    ]
+)
+
 
 @pytest.fixture(scope="class")
 def client(enterprise_config):
@@ -19,8 +29,8 @@ def create_table(client: DataFrameClient):
     """Fixture to return a factory that creates tables."""
     tables = []
 
-    def _create_table(table: models.CreateTableRequest) -> str:
-        id = client.create_table(table)
+    def _create_table(table: Optional[models.CreateTableRequest] = None) -> str:
+        id = client.create_table(table or basic_table_model)
         tables.append(id)
         return id
 
@@ -85,17 +95,7 @@ def test__create_table__metadata_is_corect(
         ]
 
     def test__get_table__correct_timestamp(self, client: DataFrameClient, create_table):
-        id = create_table(
-            models.CreateTableRequest(
-                columns=[
-                    models.Column(
-                        name="index",
-                        data_type=models.DataType.Int32,
-                        column_type=models.ColumnType.Index,
-                    )
-                ]
-            )
-        )
+        id = create_table(basic_table_model)
         table = client.get_table_metadata(id)
 
         now = datetime.now().timestamp()
@@ -156,17 +156,7 @@ def test__query_tables__returns(
         assert second_page.continuation_token is None
 
     def test__modify_table__returns(self, client: DataFrameClient, create_table):
-        id = create_table(
-            models.CreateTableRequest(
-                columns=[
-                    models.Column(
-                        name="index",
-                        data_type=models.DataType.Int32,
-                        column_type=models.ColumnType.Index,
-                    )
-                ]
-            )
-        )
+        id = create_table(basic_table_model)
 
         client.modify_table(
             id,
@@ -213,59 +203,76 @@ def test__modify_table__returns(self, client: DataFrameClient, create_table):
         assert table.columns[0].properties == {}
 
     def test__delete_table__deletes(self, client: DataFrameClient):
-        id = client.create_table(  # Don't use fixture to avoid deleting the table twice
-            models.CreateTableRequest(
-                columns=[
-                    models.Column(
-                        name="index",
-                        data_type=models.DataType.Int32,
-                        column_type=models.ColumnType.Index,
-                    )
-                ]
-            )
-        )
+        id = client.create_table(
+            basic_table_model
+        )  # Don't use fixture to avoid deleting the table twice
 
         assert client.delete_table(id) is None
 
         with pytest.raises(ApiException, match="404 Not Found"):
             client.get_table_metadata(id)
 
     def test__delete_tables__deletes(self, client: DataFrameClient):
-        ids = [
-            client.create_table(
-                models.CreateTableRequest(
-                    columns=[
-                        models.Column(
-                            name="index",
-                            data_type=models.DataType.Int32,
-                            column_type=models.ColumnType.Index,
-                        )
-                    ]
-                )
-            )
-            for _ in range(3)
-        ]
+        ids = [client.create_table(basic_table_model) for _ in range(3)]
 
         assert client.delete_tables(ids) is None
 
         assert client.list_tables(id=ids).tables == []
 
     def test__delete_tables__returns_partial_success(self, client: DataFrameClient):
-        id = client.create_table(
-            models.CreateTableRequest(
-                columns=[
-                    models.Column(
-                        name="index",
-                        data_type=models.DataType.Int32,
-                        column_type=models.ColumnType.Index,
-                    )
-                ]
-            )
-        )
+        id = client.create_table(basic_table_model)
 
         response = client.delete_tables([id, "invalid_id"])
 
         assert response is not None
         assert response.deleted_table_ids == [id]
         assert response.failed_table_ids == ["invalid_id"]
         assert len(response.error.inner_errors) == 1
+
+    def test__modify_tables__modifies_tables(
+        self, client: DataFrameClient, create_table
+    ):
+        ids = [create_table(basic_table_model) for _ in range(3)]
+
+        updates = [
+            models.TableMetdataModification(
+                id=id, name="Modified table", properties={"duck": "quack"}
+            )
+            for id in ids
+        ]
+
+        assert client.modify_tables(models.ModifyTablesRequest(tables=updates)) is None
+
+        for table in client.list_tables(id=ids).tables:
+            assert table.name == "Modified table"
+            assert table.properties == {"duck": "quack"}
+
+        updates = [
+            models.TableMetdataModification(id=id, properties={"pig": "oink"})
+            for id in ids
+        ]
+
+        assert (
+            client.modify_tables(
+                models.ModifyTablesRequest(tables=updates, replace=True)
+            )
+            is None
+        )
+
+        for table in client.list_tables(id=ids).tables:
+            assert table.properties == {"pig": "oink"}
+
+    def test__modify_tables__returns_partial_success(self, client: DataFrameClient):
+        id = client.create_table(basic_table_model)
+
+        updates = [
+            models.TableMetdataModification(id=id, name="Modified table")
+            for id in [id, "invalid_id"]
+        ]
+
+        response = client.modify_tables(models.ModifyTablesRequest(tables=updates))
+
+        assert response is not None
+        assert response.modified_table_ids == [id]
+        assert response.failed_modifications == [updates[1]]
+        assert len(response.error.inner_errors) == 1