build: adapt to openapi client update

geoengine/layers.py

@@ -10,7 +10,6 @@
 from enum import auto
 from io import StringIO
 from typing import Any, Generic, Literal, TypeVar, cast
-from uuid import UUID
 
 import geoengine_openapi_client
 from strenum import LowercaseStrEnum
@@ -183,7 +182,7 @@ def parse_listing(response: geoengine_openapi_client.CollectionItem) -> Listing:
                 layer_id_response = cast(geoengine_openapi_client.ProviderLayerId, inner.id)
                 return LayerListing(
                     listing_id=LayerId(layer_id_response.layer_id),
-                    provider_id=LayerProviderId(UUID(layer_id_response.provider_id)),
+                    provider_id=LayerProviderId(layer_id_response.provider_id),
                     name=inner.name,
                     description=inner.description,
                 )
@@ -192,7 +191,7 @@ def parse_listing(response: geoengine_openapi_client.CollectionItem) -> Listing:
                 collection_id_response = cast(geoengine_openapi_client.ProviderLayerCollectionId, inner.id)
                 return LayerCollectionListing(
                     listing_id=LayerCollectionId(collection_id_response.collection_id),
-                    provider_id=LayerProviderId(UUID(collection_id_response.provider_id)),
+                    provider_id=LayerProviderId(collection_id_response.provider_id),
                     name=inner.name,
                     description=inner.description,
                 )
@@ -210,7 +209,7 @@ def parse_listing(response: geoengine_openapi_client.CollectionItem) -> Listing:
             name=response.name,
             description=response.description,
             collection_id=LayerCollectionId(response.id.collection_id),
-            provider_id=LayerProviderId(UUID(response.id.provider_id)),
+            provider_id=LayerProviderId(response.id.provider_id),
             items=items,
         )
 
@@ -291,7 +290,8 @@ def add_layer(
         self,
         name: str,
         description: str,
-        workflow: dict[str, Any] | WorkflowBuilderOperator,  # TODO: improve type
+        # TODO: improve type
+        workflow: dict[str, Any] | WorkflowBuilderOperator,
         symbology: Symbology | None,
         timeout: int = 60,
     ) -> LayerId:
@@ -318,7 +318,8 @@ def add_layer_with_permissions(
         self,
         name: str,
         description: str,
-        workflow: dict[str, Any] | WorkflowBuilderOperator,  # TODO: improve type
+        # TODO: improve type
+        workflow: dict[str, Any] | WorkflowBuilderOperator,
         symbology: Symbology | None,
         permission_tuples: list[tuple[RoleId, Permission]] | None = None,
         timeout: int = 60,
@@ -397,7 +398,8 @@ def add_existing_collection(
             collection_id = existing_collection.listing_id
         elif isinstance(existing_collection, LayerCollection):
             collection_id = existing_collection.collection_id
-        elif isinstance(existing_collection, str):  # TODO: check for LayerId in Python 3.11+
+        # TODO: check for LayerId in Python 3.11+
+        elif isinstance(existing_collection, str):
             collection_id = existing_collection
         else:
             raise InputException("Invalid collection type")
@@ -446,7 +448,7 @@ def search(
         with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
             layers_api = geoengine_openapi_client.LayersApi(api_client)
             layer_collection_response = layers_api.search_handler(
-                provider=str(self.provider_id),
+                provider=self.provider_id,
                 collection=str(self.collection_id),
                 search_string=search_string,
                 search_type=geoengine_openapi_client.SearchType(search_type),
@@ -464,7 +466,7 @@ def search(
                 listings.append(
                     LayerCollectionListing(
                         listing_id=LayerCollectionId(inner.id.collection_id),
-                        provider_id=LayerProviderId(UUID(inner.id.provider_id)),
+                        provider_id=LayerProviderId(inner.id.provider_id),
                         name=inner.name,
                         description=inner.description,
                     )
@@ -473,7 +475,7 @@ def search(
                 listings.append(
                     LayerListing(
                         listing_id=LayerId(inner.id.layer_id),
-                        provider_id=LayerProviderId(UUID(inner.id.provider_id)),
+                        provider_id=LayerProviderId(inner.id.provider_id),
                         name=inner.name,
                         description=inner.description,
                     )
@@ -529,7 +531,8 @@ def get_or_create_unique_collection(
         if isinstance(res, Layer):
             raise TypeError(f"Found a Layer not a Layer collection for {collection_name}")
 
-        return cast(LayerCollection, existing_collections[0].load())  # we know that it is a collection since check that
+        # we know that it is a collection since check that
+        return cast(LayerCollection, existing_collections[0].load())
 
     def __eq__(self, other):
         """Tests if two layer listings are identical"""
@@ -594,7 +597,7 @@ def from_response(cls, response: geoengine_openapi_client.Layer) -> Layer:
             name=response.name,
             description=response.description,
             layer_id=LayerId(response.id.layer_id),
-            provider_id=LayerProviderId(UUID(response.id.provider_id)),
+            provider_id=LayerProviderId(response.id.provider_id),
             workflow=response.workflow.to_dict(),
             symbology=symbology,
             properties=cast(list[Any], response.properties),
@@ -656,7 +659,7 @@ def save_as_dataset(self, timeout: int = 60) -> Task:
 
         with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
             layers_api = geoengine_openapi_client.LayersApi(api_client)
-            response = layers_api.layer_to_dataset(str(self.provider_id), str(self.layer_id), _request_timeout=timeout)
+            response = layers_api.layer_to_dataset(self.provider_id, str(self.layer_id), _request_timeout=timeout)
 
         return Task(TaskId.from_response(response))
 
@@ -684,7 +687,7 @@ def as_workflow_id(self, timeout: int = 60) -> WorkflowId:
         with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
             layers_api = geoengine_openapi_client.LayersApi(api_client)
             response = layers_api.layer_to_workflow_id_handler(
-                str(self.provider_id), self.layer_id, _request_timeout=timeout
+                self.provider_id, self.layer_id, _request_timeout=timeout
             )
 
         return WorkflowId.from_response(response)
@@ -721,11 +724,12 @@ def layer_collection(
                 page = layers_api.list_root_collections_handler(offset, page_limit, _request_timeout=timeout)
             else:
                 page = layers_api.list_collection_handler(
-                    str(layer_provider_id), layer_collection_id, offset, page_limit, _request_timeout=timeout
+                    layer_provider_id, layer_collection_id, offset, page_limit, _request_timeout=timeout
                 )
 
         if len(page.items) < page_limit:
-            if len(pages) == 0 or len(page.items) > 0:  # we need at least one page before breaking
+            # we need at least one page before breaking
+            if len(pages) == 0 or len(page.items) > 0:
                 pages.append(page)
             break
 
@@ -744,7 +748,7 @@ def layer(layer_id: LayerId, layer_provider_id: LayerProviderId = LAYER_DB_PROVI
 
     with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
         layers_api = geoengine_openapi_client.LayersApi(api_client)
-        response = layers_api.layer_handler(str(layer_provider_id), str(layer_id), _request_timeout=timeout)
+        response = layers_api.layer_handler(layer_provider_id, str(layer_id), _request_timeout=timeout)
 
     return Layer.from_response(response)
 
@@ -799,7 +803,7 @@ def _add_layer_collection_to_collection(
             _request_timeout=timeout,
         )
 
-    return LayerCollectionId(response.id)
+    return LayerCollectionId(str(response.id))
 
 
 def _add_existing_layer_collection_to_collection(
@@ -843,7 +847,7 @@ def _add_layer_to_collection(
             _request_timeout=timeout,
         )
 
-    return LayerId(response.id)
+    return LayerId(str(response.id))
 
 
 def _add_existing_layer_to_collection(layer_id: LayerId, collection_id: LayerCollectionId, timeout: int = 60) -> None:

geoengine/permissions.py

@@ -50,6 +50,9 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         return repr(self.__role_id)
 
+    def to_dict(self) -> UUID:
+        return self.__role_id
+
 
 class Role:
     """A wrapper for a role"""
@@ -124,6 +127,9 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         return repr(self.__user_id)
 
+    def to_dict(self) -> UUID:
+        return self.__user_id
+
 
 class PermissionListing:
     """
@@ -230,7 +236,11 @@ def list_permissions(resource: Resource, timeout: int = 60, offset=0, limit=20)
     with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
         permission_api = geoengine_openapi_client.PermissionsApi(api_client)
         res = permission_api.get_resource_permissions_handler(
-            resource_id=resource.id, resource_type=resource.type, offset=offset, limit=limit, _request_timeout=timeout
+            resource_id=str(resource.id),
+            resource_type=resource.type,
+            offset=offset,
+            limit=limit,
+            _request_timeout=timeout,
         )
 
         return [PermissionListing.from_response(r) for r in res]
@@ -259,7 +269,7 @@ def remove_role(role: RoleId, timeout: int = 60):
 
     with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
         user_api = geoengine_openapi_client.UserApi(api_client)
-        user_api.remove_role_handler(str(role), _request_timeout=timeout)
+        user_api.remove_role_handler(role.to_dict(), _request_timeout=timeout)
 
 
 def assign_role(role: RoleId, user: UserId, timeout: int = 60):
@@ -269,7 +279,7 @@ def assign_role(role: RoleId, user: UserId, timeout: int = 60):
 
     with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
         user_api = geoengine_openapi_client.UserApi(api_client)
-        user_api.assign_role_handler(str(user), str(role), _request_timeout=timeout)
+        user_api.assign_role_handler(user.to_dict(), role.to_dict(), _request_timeout=timeout)
 
 
 def revoke_role(role: RoleId, user: UserId, timeout: int = 60):
@@ -279,4 +289,4 @@ def revoke_role(role: RoleId, user: UserId, timeout: int = 60):
 
     with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
         user_api = geoengine_openapi_client.UserApi(api_client)
-        user_api.revoke_role_handler(str(user), str(role), _request_timeout=timeout)
+        user_api.revoke_role_handler(user.to_dict(), role.to_dict(), _request_timeout=timeout)

geoengine/resource_identifier.py

@@ -86,7 +86,7 @@ def __init__(self, upload_id: UUID) -> None:
     @classmethod
     def from_response(cls, response: geoengine_openapi_client.IdResponse) -> UploadId:
         """Parse a http response to an `UploadId`"""
-        return UploadId(UUID(response.id))
+        return UploadId(response.id)
 
     def __str__(self) -> str:
         return str(self.__upload_id)
@@ -109,11 +109,13 @@ def to_api_dict(self) -> geoengine_openapi_client.IdResponse:
 class Resource:
     """A wrapper for a resource id"""
 
-    id: str
+    id: str | UUID
     type: Literal["dataset", "layer", "layerCollection", "mlModel", "project"]
 
     def __init__(
-        self, resource_type: Literal["dataset", "layer", "layerCollection", "mlModel", "project"], resource_id: str
+        self,
+        resource_type: Literal["dataset", "layer", "layerCollection", "mlModel", "project"],
+        resource_id: str | UUID,
     ) -> None:
         """Create a resource id"""
         self.type = resource_type

geoengine/tasks.py

@@ -28,7 +28,7 @@ def __init__(self, task_id: UUID) -> None:
     def from_response(cls, response: geoengine_openapi_client.TaskResponse) -> TaskId:
         """Parse a http response to an `TaskId`"""
 
-        return TaskId(UUID(response.task_id))
+        return TaskId(response.task_id)
 
     def __eq__(self, other) -> bool:
         """Checks if two dataset ids are equal"""
@@ -43,6 +43,9 @@ def __str__(self) -> str:
     def __repr__(self) -> str:
         return repr(self.__task_id)
 
+    def to_dict(self) -> UUID:
+        return self.__task_id
+
 
 class TaskStatus(Enum):
     """An enum of task status types"""
@@ -260,12 +263,12 @@ def get_status(self, timeout: int = 3600) -> TaskStatusInfo:
         """
         session = get_session()
 
-        task_id_str = str(self.__task_id)
+        task_id = self.__task_id.to_dict()
 
         with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
             tasks_api = geoengine_openapi_client.TasksApi(api_client)
-            print(task_id_str)
-            response = tasks_api.status_handler(task_id_str, _request_timeout=timeout)
+            print(task_id)
+            response = tasks_api.status_handler(task_id, _request_timeout=timeout)
 
         return TaskStatusInfo.from_response(response)
 
@@ -275,11 +278,11 @@ def abort(self, force: bool = False, timeout: int = 3600) -> None:
         """
         session = get_session()
 
-        task_id_str = str(self.__task_id)
+        task_id = self.__task_id.to_dict()
 
         with geoengine_openapi_client.ApiClient(session.configuration) as api_client:
             tasks_api = geoengine_openapi_client.TasksApi(api_client)
-            tasks_api.abort_handler(task_id_str, None if force is False else True, _request_timeout=timeout)
+            tasks_api.abort_handler(task_id, None if force is False else True, _request_timeout=timeout)
 
     def wait_for_finish(
         self, check_interval_seconds: float = 5, request_timeout: int = 3600, print_status: bool = True
@@ -311,8 +314,8 @@ async def as_future(self, request_interval: int = 5, print_status=False) -> Task
         Returns a future that will be resolved when the task is finished in the backend.
         """
 
-        def get_status_inner(tasks_api: geoengine_openapi_client.TasksApi, task_id_str: str, timeout: int = 3600):
-            return tasks_api.status_handler(task_id_str, _request_timeout=timeout)
+        def get_status_inner(tasks_api: geoengine_openapi_client.TasksApi, task_id: UUID, timeout: int = 3600):
+            return tasks_api.status_handler(task_id, _request_timeout=timeout)
 
         session = get_session()
         task_id_str = str(self.__task_id)
@@ -346,6 +349,6 @@ def get_task_list(timeout: int = 3600) -> list[tuple[Task, TaskStatusInfo]]:
 
     result = []
     for item in response:
-        result.append((Task(TaskId(UUID(item.task_id))), TaskStatusInfo.from_response(item)))
+        result.append((Task(TaskId(item.task_id)), TaskStatusInfo.from_response(item)))
 
     return result

geoengine/types.py

@@ -1171,7 +1171,7 @@ def __init__(self, dataset_id: UUID):
     @classmethod
     def from_response_internal(cls, response: geoengine_openapi_client.InternalDataId) -> InternalDataId:
         """Parse an http response to a `InternalDataId` object"""
-        return InternalDataId(UUID(response.dataset_id))
+        return InternalDataId(response.dataset_id)
 
     def to_api_dict(self) -> geoengine_openapi_client.DataId:
         return geoengine_openapi_client.DataId(
@@ -1207,7 +1207,7 @@ def __init__(self, provider_id: UUID, layer_id: str):
     def from_response_external(cls, response: geoengine_openapi_client.ExternalDataId) -> ExternalDataId:
         """Parse an http response to a `ExternalDataId` object"""
 
-        return ExternalDataId(UUID(response.provider_id), response.layer_id)
+        return ExternalDataId(response.provider_id, response.layer_id)
 
     def to_api_dict(self) -> geoengine_openapi_client.DataId:
         return geoengine_openapi_client.DataId(