fairagro-middleware-api-client 8.6.4.dev7__tar.gz → 8.7.1.dev8__tar.gz

{fairagro_middleware_api_client-8.6.4.dev7 → fairagro_middleware_api_client-8.7.1.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fairagro-middleware-api-client
-Version: 8.6.4.dev7
+Version: 8.7.1.dev8
 Summary: The FAIRagro advanced middleware API client
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.28.1

{fairagro_middleware_api_client-8.6.4.dev7 → fairagro_middleware_api_client-8.7.1.dev8}/src/middleware/api_client/api_client.py

@@ -13,9 +13,11 @@ from typing import TYPE_CHECKING, Any, cast
 import httpx
 from pydantic import BaseModel, ValidationError
 
+from middleware.shared.api_models.common.models import HarvestStatus as SharedHarvestStatus
 from middleware.shared.api_models.v3.models import (
     CreateArcRequest,
     CreateHarvestRequest,
+    PatchHarvestRequest,
     SubmitHarvestArcRequest,
 )
 
@@ -226,12 +228,12 @@ class ApiClient:
             or status_code >= HTTPStatus.INTERNAL_SERVER_ERROR
         )
 
-    async def _cancel_harvest_safely(self, rdi: str, harvest_id: str) -> None:
-        """Try cancelling a harvest and suppress cancellation failures."""
+    async def _fail_harvest_safely(self, rdi: str, harvest_id: str) -> None:
+        """Try marking a harvest as failed and suppress any secondary failures."""
         try:
-            await self.cancel_harvest(harvest_id)
+            await self.fail_harvest(harvest_id)
         except ApiClientError:
-            logger.warning("[%s] Failed to cancel harvest %s", rdi, harvest_id)
+            logger.warning("[%s] Failed to mark harvest %s as failed", rdi, harvest_id)
 
     @classmethod
     async def _cancel_pending_arc_tasks(cls, pending_tasks: set[asyncio.Task[None]]) -> None:
@@ -267,12 +269,26 @@ class ApiClient:
         """Submit all ARCs in bounded parallelism and return number of skipped ARC submissions."""
         pending_tasks: set[asyncio.Task[None]] = set()
         failed_submissions = 0
+        seen_identifiers: set[str] = set()
 
-        async def submit_one(arc_item: "ARC | dict[str, Any] | str") -> None:
-            await self.submit_arc_in_harvest(harvest_id, arc_item)
+        async def submit_one(arc_item: dict[str, Any]) -> None:
+            request = SubmitHarvestArcRequest(arc=arc_item)
+            await self._post(f"v3/harvests/{harvest_id}/arcs", request)
 
         async for arc in arcs:
-            task = asyncio.create_task(submit_one(arc))
+            serialized = self._serialize_arc(arc)
+            identifier = self._extract_identifier_from_rocrate(serialized)
+            if identifier is not None:
+                if identifier in seen_identifiers:
+                    await self._cancel_pending_arc_tasks(pending_tasks)
+                    raise ApiClientError(
+                        f"Duplicate ARC identifier '{identifier}' submitted more than once "
+                        f"in harvest {harvest_id}. This is likely a client-side data error "
+                        "(two different ARCs sharing the same identifier)."
+                    )
+                seen_identifiers.add(identifier)
+
+            task = asyncio.create_task(submit_one(serialized))
             pending_tasks.add(task)
 
             if len(pending_tasks) >= self._config.max_concurrency:
@@ -441,10 +457,38 @@ class ApiClient:
         """DELETE request, ignoring a 204 No Content response."""
         await self._request_with_retries("DELETE", path)
 
+    async def _patch(self, path: str, body: BaseModel) -> Any:
+        """PATCH with a Pydantic request body."""
+        return await self._request_with_retries(
+            "PATCH",
+            path,
+            content=body.model_dump_json(),
+            headers={"content-type": "application/json"},
+        )
+
     # ------------------------------------------------------------------
     # Helper
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _extract_identifier_from_rocrate(arc_content: dict[str, Any]) -> str | None:
+        """Extract the RO-Crate identifier from a serialized ARC dict.
+
+        Looks for the Root Data Entity (``@id == "./"``), then returns its
+        ``identifier`` field.  Returns ``None`` when the field is absent or
+        the dict does not follow the RO-Crate structure — validation is left
+        to the server.
+        """
+        graph = arc_content.get("@graph")
+        if isinstance(graph, list):
+            for item in graph:
+                if item.get("@id") == "./":
+                    identifier = item.get("identifier")
+                    if isinstance(identifier, list):
+                        identifier = identifier[0] if identifier else None
+                    return str(identifier) if identifier else None
+        return None
+
     @classmethod
     def _serialize_arc(cls, arc: "ARC | dict[str, Any] | str") -> dict[str, Any]:
         """Serialize an ARC object, dict, or JSON string to a plain RO-Crate JSON dict."""
@@ -452,7 +496,10 @@ class ApiClient:
             return arc
         if isinstance(arc, str):
             try:
-                return cast(dict[str, Any], json.loads(arc))
+                data = json.loads(arc)
+                if not isinstance(data, dict):
+                    raise ApiClientError(f"JSON string must represent a dictionary, got {type(data).__name__}")
+                return cast(dict[str, Any], data)
             except json.JSONDecodeError as e:
                 raise ApiClientError(f"Invalid JSON string provided for ARC: {e}") from e
         return cast(dict[str, Any], json.loads(arc.ToROCrateJsonString()))
@@ -571,15 +618,39 @@ class ApiClient:
         data = await self._post_empty(f"v3/harvests/{harvest_id}/complete")
         return self._parse_harvest_response(data)
 
-    async def cancel_harvest(self, harvest_id: str) -> None:
-        """Cancel (delete) a harvest run.
+    async def cancel_harvest(self, harvest_id: str) -> HarvestResult:
+        """Mark a harvest run as cancelled.
+
+        Uses ``PATCH /v3/harvests/{harvest_id}`` with ``status=CANCELLED``.
+
+        Args:
+            harvest_id: Harvest identifier.
+
+        Returns:
+            Updated :class:`HarvestResult`.
+        """
+        data = await self._patch(
+            f"v3/harvests/{harvest_id}",
+            PatchHarvestRequest(status=SharedHarvestStatus.CANCELLED),
+        )
+        return self._parse_harvest_response(data)
+
+    async def fail_harvest(self, harvest_id: str) -> HarvestResult:
+        """Mark a harvest run as failed.
 
-        Uses ``DELETE /v3/harvests/{harvest_id}``.
+        Uses ``PATCH /v3/harvests/{harvest_id}`` with ``status=FAILED``.
 
         Args:
             harvest_id: Harvest identifier.
+
+        Returns:
+            Updated :class:`HarvestResult`.
         """
-        await self._delete(f"v3/harvests/{harvest_id}")
+        data = await self._patch(
+            f"v3/harvests/{harvest_id}",
+            PatchHarvestRequest(status=SharedHarvestStatus.FAILED),
+        )
+        return self._parse_harvest_response(data)
 
     async def submit_arc_in_harvest(
         self,
@@ -632,7 +703,7 @@ class ApiClient:
 
         Raises:
             ApiClientError: On catastrophic HTTP or serialization errors. The
-                harvest is cancelled before the exception propagates.
+                harvest is marked as failed before the exception propagates.
 
         Example::
 
@@ -650,8 +721,10 @@ class ApiClient:
         try:
             failed_submissions = await self._submit_arcs_parallel(harvest_id, arcs)
         except Exception:
-            logger.warning("[%s] Catastrophic error during ARC submission, cancelling harvest %s", rdi, harvest_id)
-            await self._cancel_harvest_safely(rdi, harvest_id)
+            logger.warning(
+                "[%s] Catastrophic error during ARC submission, marking harvest %s as failed", rdi, harvest_id
+            )
+            await self._fail_harvest_safely(rdi, harvest_id)
             raise
 
         if failed_submissions > 0:

{fairagro_middleware_api_client-8.6.4.dev7 → fairagro_middleware_api_client-8.7.1.dev8}/tests/unit/test_client.py

@@ -482,14 +482,31 @@ async def test_complete_harvest(client_config: Config) -> None:
 @pytest.mark.asyncio
 @respx.mock
 async def test_cancel_harvest(client_config: Config) -> None:
-    """Test cancelling a harvest run."""
-    route = respx.delete(f"{client_config.api_url}v3/harvests/harvest-456").mock(
-        return_value=httpx.Response(http.HTTPStatus.NO_CONTENT)
+    """Test cancelling a harvest run via PATCH."""
+    cancelled_response = {**_HARVEST_RESPONSE, "status": "CANCELLED"}
+    route = respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=cancelled_response)
     )
     async with ApiClient(client_config) as client:
-        await client.cancel_harvest("harvest-456")
+        result = await client.cancel_harvest("harvest-456")
     assert route.called
+    assert isinstance(result, HarvestResult)
+    assert result.status == "CANCELLED"
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_fail_harvest(client_config: Config) -> None:
+    """Test marking a harvest run as failed via PATCH."""
+    failed_response = {**_HARVEST_RESPONSE, "status": "FAILED"}
+    route = respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=failed_response)
+    )
+    async with ApiClient(client_config) as client:
+        result = await client.fail_harvest("harvest-456")
     assert route.called
+    assert isinstance(result, HarvestResult)
+    assert result.status == "FAILED"
 
 
 @pytest.mark.asyncio
@@ -676,22 +693,57 @@ async def test_harvest_arcs_continues_on_item_error(client_config: Config) -> No
 @pytest.mark.asyncio
 @respx.mock
 async def test_harvest_arcs_cancels_on_catastrophic_error(client_config: Config) -> None:
-    """harvest_arcs cancels the harvest on catastrophic submission errors."""
+    """harvest_arcs marks the harvest as failed on catastrophic submission errors."""
+    failed_response = {**_HARVEST_RESPONSE, "status": "FAILED"}
     respx.post(f"{client_config.api_url}v3/harvests").mock(
         return_value=httpx.Response(http.HTTPStatus.OK, json=_HARVEST_RESPONSE)
     )
     respx.post(f"{client_config.api_url}v3/harvests/harvest-456/arcs").mock(
         return_value=httpx.Response(http.HTTPStatus.INTERNAL_SERVER_ERROR, text="server unavailable")
     )
-    cancel_route = respx.delete(f"{client_config.api_url}v3/harvests/harvest-456").mock(
-        return_value=httpx.Response(http.HTTPStatus.NO_CONTENT)
+    fail_route = respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=failed_response)
     )
 
     async with ApiClient(client_config) as client:
         with pytest.raises(ApiClientError):
             await client.harvest_arcs("test-rdi", _arc_gen({"id": "arc-1"}))
 
-    assert cancel_route.called
+    assert fail_route.called
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_harvest_arcs_fails_on_duplicate_identifier(client_config: Config) -> None:
+    """harvest_arcs marks harvest as failed when the same ARC identifier appears twice."""
+    # Two ARC dicts that share the same RO-Crate identifier — simulates a
+    # client-side data error where two distinct ARCs were accidentally given
+    # the same identifier field.
+    arc_a = {
+        "@context": "https://w3id.org/ro/crate/1.1/context",
+        "@graph": [{"@id": "./", "@type": "Dataset", "identifier": "duplicate-arc", "name": "ARC A"}],
+    }
+    arc_b = {
+        "@context": "https://w3id.org/ro/crate/1.1/context",
+        "@graph": [{"@id": "./", "@type": "Dataset", "identifier": "duplicate-arc", "name": "ARC B"}],
+    }
+    failed_response = {**_HARVEST_RESPONSE, "status": "FAILED"}
+    respx.post(f"{client_config.api_url}v3/harvests").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=_HARVEST_RESPONSE)
+    )
+    # The first ARC is submitted successfully before the duplicate is detected.
+    respx.post(f"{client_config.api_url}v3/harvests/harvest-456/arcs").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=_ARC_RESPONSE)
+    )
+    fail_route = respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=failed_response)
+    )
+
+    async with ApiClient(client_config) as client:
+        with pytest.raises(ApiClientError, match="Duplicate ARC identifier 'duplicate-arc'"):
+            await client.harvest_arcs("test-rdi", _arc_gen(arc_a, arc_b))
+
+    assert fail_route.called
 
 
 @pytest.mark.asyncio
@@ -725,13 +777,12 @@ async def test_harvest_arcs_with_json_string(client_config: Config) -> None:
 @respx.mock
 async def test_harvest_arcs_with_invalid_json_string(client_config: Config) -> None:
     """harvest_arcs raises ApiClientError when JSON string is invalid."""
-    # Mock the harvest creation endpoint to prevent actual HTTP requests
+    failed_response = {**_HARVEST_RESPONSE, "status": "FAILED"}
     respx.post(f"{client_config.api_url}v3/harvests").mock(
         return_value=httpx.Response(http.HTTPStatus.OK, json=_HARVEST_RESPONSE)
     )
-    # Mock the harvest cancellation endpoint
-    respx.delete(f"{client_config.api_url}v3/harvests/harvest-456").mock(
-        return_value=httpx.Response(http.HTTPStatus.NO_CONTENT)
+    respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.OK, json=failed_response)
     )
 
     async with ApiClient(client_config) as client:
@@ -743,16 +794,16 @@ async def test_harvest_arcs_with_invalid_json_string(client_config: Config) -> N
 @pytest.mark.asyncio
 @respx.mock
 async def test_harvest_arcs_cancel_failure_does_not_mask_original_error(client_config: Config) -> None:
-    """If cancel itself raises, the original submission error is still propagated."""
+    """If fail_harvest itself raises, the original submission error is still propagated."""
     respx.post(f"{client_config.api_url}v3/harvests").mock(
         return_value=httpx.Response(http.HTTPStatus.OK, json=_HARVEST_RESPONSE)
     )
     respx.post(f"{client_config.api_url}v3/harvests/harvest-456/arcs").mock(
         return_value=httpx.Response(http.HTTPStatus.INTERNAL_SERVER_ERROR, text="arc error")
     )
-    # Also make the cancel fail
-    respx.delete(f"{client_config.api_url}v3/harvests/harvest-456").mock(
-        return_value=httpx.Response(http.HTTPStatus.INTERNAL_SERVER_ERROR, text="cancel error")
+    # Also make the fail call fail
+    respx.patch(f"{client_config.api_url}v3/harvests/harvest-456").mock(
+        return_value=httpx.Response(http.HTTPStatus.INTERNAL_SERVER_ERROR, text="fail error")
     )
 
     async with ApiClient(client_config) as client: