clarity-api-sdk-python 0.4.1__tar.gz → 0.4.3__tar.gz

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarity-api-sdk-python
-Version: 0.4.1
+Version: 0.4.3
 Summary: A Python SDK to connect to the CTI Clarity API server.
 Author-email: "Chesapeake Technology Inc." <support@chesapeaketech.com>
 Project-URL: Homepage, https://github.com/chesapeake-tech/clarity-api-sdk-python
@@ -15,6 +15,7 @@ Requires-Dist: h2
 Requires-Dist: httpx_auth>=0.23.1
 Requires-Dist: httpx-retries>=0.4.5
 Requires-Dist: pydantic==2.12.3
+Requires-Dist: pyproj==3.7.2
 Requires-Dist: structlog==25.4.0
 Requires-Dist: typer>=0.15
 Provides-Extra: dev

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clarity-api-sdk-python"
-version = "0.4.1"
+version = "0.4.3"
 authors = [
   { name="Chesapeake Technology Inc.", email="support@chesapeaketech.com" },
 ]
@@ -24,6 +24,7 @@ dependencies = [
     "httpx_auth>=0.23.1",
     "httpx-retries>=0.4.5",
     "pydantic==2.12.3",
+    "pyproj==3.7.2",
     "structlog==25.4.0",
     "typer>=0.15",
 ]

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/src/clarity_api_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarity-api-sdk-python
-Version: 0.4.1
+Version: 0.4.3
 Summary: A Python SDK to connect to the CTI Clarity API server.
 Author-email: "Chesapeake Technology Inc." <support@chesapeaketech.com>
 Project-URL: Homepage, https://github.com/chesapeake-tech/clarity-api-sdk-python
@@ -15,6 +15,7 @@ Requires-Dist: h2
 Requires-Dist: httpx_auth>=0.23.1
 Requires-Dist: httpx-retries>=0.4.5
 Requires-Dist: pydantic==2.12.3
+Requires-Dist: pyproj==3.7.2
 Requires-Dist: structlog==25.4.0
 Requires-Dist: typer>=0.15
 Provides-Extra: dev

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/src/clarity_api_sdk_python.egg-info/SOURCES.txt

@@ -52,7 +52,10 @@ src/cti/model/survey.py
 src/cti/model/target.py
 src/cti/model/tow_system.py
 src/cti/model/user_layer.py
+src/cti/positioning/__init__.py
+src/cti/positioning/target_geometry.py
 tests/test_cli.py
 tests/test_raw_file_device_mapping_model.py
 tests/test_sdk_async_methods.py
-tests/test_sdk_methods.py
+tests/test_sdk_methods.py
+tests/test_target_geometry.py

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/src/clarity_api_sdk_python.egg-info/requires.txt

@@ -4,6 +4,7 @@ h2
 httpx_auth>=0.23.1
 httpx-retries>=0.4.5
 pydantic==2.12.3
+pyproj==3.7.2
 structlog==25.4.0
 typer>=0.15
 

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/src/cti/api/sonar_wiz_api.py

@@ -1709,33 +1709,56 @@ class SonarWizApi:
         response.raise_for_status()
         return Target.model_validate(response.json())
 
-    def list_targets(self) -> list[Target]:
-        """List all targets.
+    def list_targets(self, sidescan_ping_source_id: UUID | str) -> list[Target]:
+        """List all targets for one sidescan ping source.
+
+        The cross-source ``GET /api/v1/targets`` endpoint is deprecated;
+        the spec scopes target reads to a single SidescanPingSource.
+
+        Args:
+            sidescan_ping_source_id: SidescanPingSource UUID or string identifier.
 
         Returns:
-            List of target instances.
+            List of target instances, each with the ``derived`` block
+            populated when the parent line's nav state is available.
         """
-        response = self._client.get("/api/v1/targets")
+        response = self._client.get(
+            f"/api/v1/sidescan-ping-sources/{sidescan_ping_source_id}/targets"
+        )
         response.raise_for_status()
         return [Target.model_validate(item) for item in response.json()]
 
     def update_target(self, target_id: UUID | str, target: TargetUpdate) -> Target:
-        """Update a target.
+        """Partially update a target.
+
+        Targets MVP is the first endpoint in the API to use PATCH (older
+        update endpoints use PUT for legacy reasons but already behave as
+        PATCH server-side via ``exclude_unset=True``). Body fields are
+        optional; only the supplied fields are mutated.
 
         Args:
             target_id: Target UUID or string identifier.
-            target: Target update data.
+            target: Partial target update data.
 
         Returns:
             Updated target instance.
         """
-        response = self._client.put(
+        response = self._client.patch(
             f"/api/v1/targets/{target_id}",
             json=target.model_dump(mode="json", exclude_unset=True),
         )
         response.raise_for_status()
         return Target.model_validate(response.json())
 
+    def delete_target(self, target_id: UUID | str) -> None:
+        """Hard-delete a target.
+
+        Args:
+            target_id: Target UUID or string identifier.
+        """
+        response = self._client.delete(f"/api/v1/targets/{target_id}")
+        response.raise_for_status()
+
     def create_tow_system(self, tow_system: TowSystemCreate) -> TowSystem:
         """Create a new tow system.
 

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/src/cti/api/sonar_wiz_async_api.py

@@ -1753,35 +1753,58 @@ class SonarWizAsyncApi:
         response.raise_for_status()
         return Target.model_validate(response.json())
 
-    async def list_targets(self) -> list[Target]:
-        """List all targets.
+    async def list_targets(self, sidescan_ping_source_id: UUID | str) -> list[Target]:
+        """List all targets for one sidescan ping source.
+
+        The cross-source ``GET /api/v1/targets`` endpoint is deprecated;
+        the spec scopes target reads to a single SidescanPingSource.
+
+        Args:
+            sidescan_ping_source_id: SidescanPingSource UUID or string identifier.
 
         Returns:
-            List of target instances.
+            List of target instances, each with the ``derived`` block
+            populated when the parent line's nav state is available.
         """
-        response = await self._client.get("/api/v1/targets")
+        response = await self._client.get(
+            f"/api/v1/sidescan-ping-sources/{sidescan_ping_source_id}/targets"
+        )
         response.raise_for_status()
         return [Target.model_validate(item) for item in response.json()]
 
     async def update_target(
         self, target_id: UUID | str, target: TargetUpdate
     ) -> Target:
-        """Update a target.
+        """Partially update a target.
+
+        Targets MVP is the first endpoint in the API to use PATCH (older
+        update endpoints use PUT for legacy reasons but already behave as
+        PATCH server-side via ``exclude_unset=True``). Body fields are
+        optional; only the supplied fields are mutated.
 
         Args:
             target_id: Target UUID or string identifier.
-            target: Target update data.
+            target: Partial target update data.
 
         Returns:
             Updated target instance.
         """
-        response = await self._client.put(
+        response = await self._client.patch(
             f"/api/v1/targets/{target_id}",
             json=target.model_dump(mode="json", exclude_unset=True),
         )
         response.raise_for_status()
         return Target.model_validate(response.json())
 
+    async def delete_target(self, target_id: UUID | str) -> None:
+        """Hard-delete a target.
+
+        Args:
+            target_id: Target UUID or string identifier.
+        """
+        response = await self._client.delete(f"/api/v1/targets/{target_id}")
+        response.raise_for_status()
+
     async def create_tow_system(self, tow_system: TowSystemCreate) -> TowSystem:
         """Create a new tow system.
 

clarity_api_sdk_python-0.4.3/src/cti/model/target.py

@@ -0,0 +1,132 @@
+"""Pydantic models for target data.
+
+Mirrors the sample-address shape introduced by clarity-server #119
+(see ``clarity-server/src/model/target.py``). The ``derived`` block
+required by the Targets MVP spec on every read response is computed by
+``cti.positioning.target_geometry.derive`` and surfaced as
+``Target.derived``; populating it server-side is clarity-server #120's
+job.
+"""
+
+from datetime import datetime
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict
+
+
+_DEFAULT_NAME = "[unreviewed] [Unknown Object]"
+
+
+class TargetBase(BaseModel):
+    """Sample-address fields shared across create/update/read models.
+
+    Attributes:
+        channel: Sonar channel index (port/starboard/…).
+        ping: Ping address (along-track).
+        sample: Sample address within the ping (across-track, non-negative).
+        name: Operator-supplied name.
+        description: Optional free-form notes.
+        width_samples: Optional bounding-box width in sample addresses.
+        height_pings: Optional bounding-box height in ping addresses.
+        shadow_samples: Optional acoustic-shadow length in sample addresses.
+    """
+
+    channel: int
+    ping: int
+    sample: int
+    name: str = _DEFAULT_NAME
+    description: str = ""
+    width_samples: int | None = None
+    height_pings: int | None = None
+    shadow_samples: int | None = None
+
+
+class TargetCreate(TargetBase):
+    """POST body shape — sample-address fields plus the parent FK.
+
+    Attributes:
+        sidescan_ping_source_id: FK reference to SidescanPingSource.
+    """
+
+    sidescan_ping_source_id: UUID
+
+
+class TargetUpdate(BaseModel):
+    """Partial update body — every field optional.
+
+    Attributes:
+        channel: Sonar channel index.
+        ping: Ping address.
+        sample: Sample address.
+        name: Operator-supplied name.
+        description: Free-form notes.
+        width_samples: Bounding-box width in sample addresses.
+        height_pings: Bounding-box height in ping addresses.
+        shadow_samples: Acoustic-shadow length in sample addresses.
+    """
+
+    channel: int | None = None
+    ping: int | None = None
+    sample: int | None = None
+    name: str | None = None
+    description: str | None = None
+    width_samples: int | None = None
+    height_pings: int | None = None
+    shadow_samples: int | None = None
+
+
+class TargetDerived(BaseModel):
+    """Read-only derived block — lat/lon, projected XY, SRID-unit dimensions.
+
+    Computed by :func:`cti.positioning.target_geometry.derive` from a
+    target's sample-address fields plus the parent line's current nav,
+    bottom track, and sample/ping spacing. Always populated on read
+    responses (no opt-in flag) per the Targets MVP spec.
+
+    Attributes:
+        longitude: Geodetic longitude (EPSG:4326), decimal degrees.
+        latitude: Geodetic latitude (EPSG:4326), decimal degrees.
+        projected_x: Easting in the project SRID's linear unit.
+        projected_y: Northing in the project SRID's linear unit.
+        srid: Project SRID (e.g. ``"EPSG:32618"``).
+        width: Bounding-box width in SRID linear units, if width_samples set.
+        height: Bounding-box height in SRID linear units, if height_pings set.
+        shadow: Acoustic-shadow length in SRID linear units, if shadow_samples set.
+        linear_unit: SRID's linear unit name (typically ``"meter"``).
+    """
+
+    longitude: float
+    latitude: float
+    projected_x: float
+    projected_y: float
+    srid: str
+    width: float | None = None
+    height: float | None = None
+    shadow: float | None = None
+    linear_unit: str
+
+
+class Target(TargetBase):
+    """Full read shape with database-managed fields and derived block.
+
+    Attributes:
+        target_id: Unique identifier for the target.
+        sidescan_ping_source_id: FK reference to SidescanPingSource.
+        derived: Derived geographic position and SRID-unit dimensions
+            (populated server-side; ``None`` only when the line lacks the
+            nav/bottom-track state required to compute it).
+        created_by_user_id: Authoring user (nullable until auth wiring lands).
+        last_modified_by_user_id: Last-editing user (nullable until auth wiring lands).
+        created_at: Row creation timestamp (UTC).
+        updated_at: Row last-modification timestamp (UTC).
+    """
+
+    target_id: UUID
+    sidescan_ping_source_id: UUID
+    derived: TargetDerived | None = None
+    created_by_user_id: UUID | None = None
+    last_modified_by_user_id: UUID | None = None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)

clarity_api_sdk_python-0.4.3/src/cti/positioning/__init__.py

@@ -0,0 +1,8 @@
+"""Shared positioning math used by clarity-server and clarity-engine.
+
+The Targets MVP spec requires that geographic position and SRID-unit
+dimensions for a target be derived (not stored) from the parent line's
+current nav, bottom track, and sample spacing — and that the engine and
+server share one source of truth for that math. This package is that
+source of truth.
+"""

clarity_api_sdk_python-0.4.3/src/cti/positioning/target_geometry.py

@@ -0,0 +1,159 @@
+"""Sample-address → geographic-position math for a single Target.
+
+Given a target's ``(channel, ping, sample)`` address and the parent
+line's per-ping nav state at that ping, produce the spec's ``derived``
+block: geodetic lat/lon, projected XY in the project SRID, and the
+optional SRID-unit width/height/shadow dimensions.
+
+This module is the canonical implementation. Both ``clarity-server``
+(read path: GET /targets/{id} populates ``Target.derived``) and
+``clarity-engine`` (any internal use that needs target geometry) MUST
+import :func:`derive` rather than re-implement it. See
+``clarity-docs/designs/spec-targets-mvp.md`` §"Conversion responsibility
+split".
+
+Conventions
+-----------
+- ``channel == 0`` is port (left of vessel track).
+- Any other ``channel`` is starboard (right of vessel track).
+- Headings are compass bearings: 0° = north, increasing clockwise.
+- Vessel position in :class:`LineState` is **projected** in the same
+  ``target_srid`` passed to :func:`derive`. Both consumers (server and
+  engine) hold per-ping nav in projected coordinates after the
+  navigation phase (e.g. clarity-engine writes ``inner_x``/``inner_y``
+  in the project SRID), so taking projected input here avoids a
+  redundant geodetic round-trip.
+- Slant range is corrected to ground range using the bottom-tracked
+  altitude when available; without altitude, slant range is used
+  directly (acceptable when the seafloor is shallow relative to range).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from functools import lru_cache
+
+import pyproj
+
+from cti.model.target import Target, TargetDerived
+
+
+_GEODETIC_CRS = "EPSG:4326"
+
+
+@dataclass(frozen=True)
+class LineState:
+    """Per-ping line state at a target's ping index.
+
+    Callers (typically the server's derive layer) extract these scalars
+    from the parent SidescanPingSource's nav/bottom-track Zarr arrays
+    and the sample-spacing computed from sound velocity and sample rate.
+
+    Attributes:
+        projected_x: Vessel easting at the target's ping, in the project
+            SRID's linear unit (must match ``target_srid`` passed to
+            :func:`derive`).
+        projected_y: Vessel northing at the target's ping, same SRID.
+        heading_deg: Vessel compass heading at the target's ping
+            (0 = north, increasing clockwise).
+        sample_spacing_units: Across-track distance per sample, in the
+            project SRID's linear unit. Caller is responsible for the
+            metres-to-SRID-unit conversion before constructing the
+            LineState.
+        ping_spacing_units: Local along-track distance per ping, in the
+            project SRID's linear unit (typically metres for projected
+            SRIDs but feet for some state-plane SRIDs). Caller computes
+            this from consecutive vessel positions, which are themselves
+            already in SRID-projected coordinates, so the result inherits
+            the SRID's linear unit rather than being forced to metres.
+        altitude_units: Bottom-tracked altitude at the target's ping, in
+            SRID linear units, or ``None`` if no bottom track is
+            available (slant-to-ground correction is then skipped).
+            Caller converts from metres before constructing the LineState.
+    """
+
+    projected_x: float
+    projected_y: float
+    heading_deg: float
+    sample_spacing_units: float
+    ping_spacing_units: float
+    altitude_units: float | None = None
+
+
+@lru_cache(maxsize=64)
+def _transformer_from(target_srid: str) -> pyproj.Transformer:
+    """Cached inverse transformer from ``target_srid`` to EPSG:4326."""
+    return pyproj.Transformer.from_crs(target_srid, _GEODETIC_CRS, always_xy=True)
+
+
+@lru_cache(maxsize=64)
+def _linear_unit(target_srid: str) -> str:
+    """Linear unit name for ``target_srid`` (e.g. ``"metre"`` / ``"meter"``)."""
+    crs = pyproj.CRS.from_user_input(target_srid)
+    axis = crs.axis_info[0] if crs.axis_info else None
+    return axis.unit_name if axis is not None else "meter"
+
+
+def derive(  # pylint: disable=too-many-locals
+    target: Target, line_state: LineState, target_srid: str
+) -> TargetDerived:
+    """Derive a target's geographic position and SRID-unit dimensions.
+
+    Args:
+        target: The target to position. Only ``channel``, ``sample``,
+            ``width_samples``, ``height_pings``, and ``shadow_samples``
+            are read; ``ping`` is consumed by the caller when
+            constructing ``line_state``.
+        line_state: Per-ping nav + spacing at ``target.ping``.
+        target_srid: Project SRID to project into (e.g. ``"EPSG:32618"``).
+
+    Returns:
+        The derived block: geodetic lat/lon, projected XY in
+        ``target_srid``, optional SRID-unit width/height/shadow, and the
+        SRID's linear-unit name.
+    """
+    side = -1.0 if target.channel == 0 else 1.0
+    slant_range_units = target.sample * line_state.sample_spacing_units
+    ground_range_units = (
+        math.sqrt(slant_range_units**2 - line_state.altitude_units**2)
+        if line_state.altitude_units is not None
+        and slant_range_units > line_state.altitude_units
+        else slant_range_units
+    )
+    across_track_units = side * ground_range_units
+
+    perp_rad = math.radians(line_state.heading_deg) + math.pi / 2.0
+    target_x = line_state.projected_x + across_track_units * math.sin(perp_rad)
+    target_y = line_state.projected_y + across_track_units * math.cos(perp_rad)
+
+    inverse = _transformer_from(target_srid)
+    target_lon, target_lat = inverse.transform(target_x, target_y)
+
+    width = (
+        target.width_samples * line_state.sample_spacing_units
+        if target.width_samples is not None
+        else None
+    )
+    height = (
+        target.height_pings * line_state.ping_spacing_units
+        if target.height_pings is not None
+        else None
+    )
+    shadow = (
+        target.shadow_samples * line_state.sample_spacing_units
+        if target.shadow_samples is not None
+        else None
+    )
+
+    return TargetDerived(
+        longitude=target_lon,
+        latitude=target_lat,
+        projected_x=target_x,
+        projected_y=target_y,
+        srid=target_srid,
+        width=width,
+        height=height,
+        shadow=shadow,
+        linear_unit=_linear_unit(target_srid),
+    )

{clarity_api_sdk_python-0.4.1 → clarity_api_sdk_python-0.4.3}/tests/test_sdk_async_methods.py

@@ -369,3 +369,163 @@ async def test_get_raw_file_device_mappings_accepts_string_uuids():
         "/api/v1/raw-file-device-mappings",
         params={"raw_file_id": str(RAW_FILE_ID), "device_id": str(DEVICE_ID)},
     )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Targets MVP — async client method coverage (issue #26)
+
+
+_TARGET_ID = UUID("00000000-0000-0000-0000-0000000000a1")
+_SPS_ID = UUID("00000000-0000-0000-0000-0000000000a2")
+_USER_ID = UUID("00000000-0000-0000-0000-000000000001")
+
+
+def _make_target_json(
+    *,
+    target_id: UUID = _TARGET_ID,
+    sidescan_ping_source_id: UUID = _SPS_ID,
+    name: str = "[unreviewed] [Unknown Object]",
+    derived: dict | None = None,
+) -> dict:
+    """Build a Target JSON dict matching the server's read response shape."""
+    return {
+        "target_id": str(target_id),
+        "sidescan_ping_source_id": str(sidescan_ping_source_id),
+        "channel": 0,
+        "ping": 100,
+        "sample": 250,
+        "name": name,
+        "description": "",
+        "width_samples": None,
+        "height_pings": None,
+        "shadow_samples": None,
+        "derived": derived,
+        "created_by_user_id": str(_USER_ID),
+        "last_modified_by_user_id": str(_USER_ID),
+        "created_at": "2026-05-05T12:00:00Z",
+        "updated_at": "2026-05-05T12:00:00Z",
+    }
+
+
+@pytest.mark.asyncio
+async def test_create_target_posts_json_and_parses_target():
+    """create_target POSTs sample-address JSON and returns a typed Target."""
+    from cti.model.target import TargetCreate
+
+    client = AsyncMock()
+    client.post.return_value = _mock_response(_make_target_json())
+
+    api = SonarWizAsyncApi(client)
+    payload = TargetCreate(
+        sidescan_ping_source_id=_SPS_ID,
+        channel=0,
+        ping=100,
+        sample=250,
+    )
+    result = await api.create_target(payload)
+
+    client.post.assert_awaited_once()
+    url, _ = client.post.call_args[0], client.post.call_args[1]
+    assert url[0] == "/api/v1/targets"
+    sent = client.post.call_args.kwargs["json"]
+    assert sent["sidescan_ping_source_id"] == str(_SPS_ID)
+    assert sent["channel"] == 0
+    assert sent["ping"] == 100
+    assert sent["sample"] == 250
+    assert result.target_id == _TARGET_ID
+
+
+@pytest.mark.asyncio
+async def test_get_target_returns_typed_target_with_derived_block():
+    """get_target hits /targets/{id} and surfaces the derived block."""
+    derived = {
+        "longitude": -76.123,
+        "latitude": 38.456,
+        "projected_x": 412345.67,
+        "projected_y": 4256789.01,
+        "srid": "EPSG:32618",
+        "width": None,
+        "height": None,
+        "shadow": None,
+        "linear_unit": "metre",
+    }
+    client = AsyncMock()
+    client.get.return_value = _mock_response(_make_target_json(derived=derived))
+
+    api = SonarWizAsyncApi(client)
+    result = await api.get_target(_TARGET_ID)
+
+    client.get.assert_awaited_once_with(f"/api/v1/targets/{_TARGET_ID}")
+    assert result.target_id == _TARGET_ID
+    assert result.derived is not None
+    assert result.derived.srid == "EPSG:32618"
+
+
+@pytest.mark.asyncio
+async def test_list_targets_scopes_to_sidescan_ping_source():
+    """list_targets hits the per-SPS endpoint, not the deprecated cross-source one."""
+    client = AsyncMock()
+    client.get.return_value = _mock_response(
+        [_make_target_json(target_id=UUID(int=i + 1), name=f"t{i}") for i in range(3)]
+    )
+
+    api = SonarWizAsyncApi(client)
+    results = await api.list_targets(_SPS_ID)
+
+    client.get.assert_awaited_once_with(
+        f"/api/v1/sidescan-ping-sources/{_SPS_ID}/targets"
+    )
+    assert len(results) == 3
+    assert {t.name for t in results} == {"t0", "t1", "t2"}
+
+
+@pytest.mark.asyncio
+async def test_update_target_uses_patch_with_partial_body():
+    """update_target uses PATCH and serialises only the fields the caller set."""
+    from cti.model.target import TargetUpdate
+
+    client = AsyncMock()
+    client.patch.return_value = _mock_response(_make_target_json(name="renamed"))
+
+    api = SonarWizAsyncApi(client)
+    payload = TargetUpdate(name="renamed")
+    result = await api.update_target(_TARGET_ID, payload)
+
+    client.patch.assert_awaited_once()
+    assert client.patch.call_args[0][0] == f"/api/v1/targets/{_TARGET_ID}"
+    sent = client.patch.call_args.kwargs["json"]
+    # exclude_unset → only the field the caller set ships
+    assert sent == {"name": "renamed"}
+    assert result.name == "renamed"
+
+
+@pytest.mark.asyncio
+async def test_delete_target_returns_none_and_calls_delete():
+    """delete_target returns None after a successful DELETE."""
+    client = AsyncMock()
+    delete_resp = MagicMock(spec=httpx.Response)
+    delete_resp.status_code = 204
+    delete_resp.raise_for_status.return_value = None
+    client.delete.return_value = delete_resp
+
+    api = SonarWizAsyncApi(client)
+    result = await api.delete_target(_TARGET_ID)
+
+    client.delete.assert_awaited_once_with(f"/api/v1/targets/{_TARGET_ID}")
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_target_method_errors_propagate_via_raise_for_status():
+    """Server errors bubble up as httpx.HTTPStatusError via raise_for_status."""
+    client = AsyncMock()
+    err_resp = MagicMock(spec=httpx.Response)
+    err_resp.status_code = 404
+    err_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
+        "Not found", request=MagicMock(), response=err_resp
+    )
+    client.get.return_value = err_resp
+
+    api = SonarWizAsyncApi(client)
+    with pytest.raises(httpx.HTTPStatusError):
+        await api.get_target(_TARGET_ID)