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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarity-api-sdk-python
-Version: 0.4.1
+Version: 0.4.2
 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.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clarity-api-sdk-python"
-version = "0.4.1"
+version = "0.4.2"
 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.2}/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.2
 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.2}/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.2}/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.2/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.2/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.2/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.2/tests/test_target_geometry.py

@@ -0,0 +1,253 @@
+"""Unit tests for cti.positioning.target_geometry.derive.
+
+Covers the math contract that clarity-server #120 will rely on:
+slant-to-ground range correction, port/starboard side convention,
+heading-rotated displacement, sample-domain dimension conversion,
+and lat/lon roundtripping through the project SRID.
+
+Also pins the Pydantic shape for ``TargetDerived`` and the
+``Target.derived`` field so a regression that drops the derived block
+fails loudly here.
+"""
+
+from __future__ import annotations
+
+import math
+from datetime import datetime, timezone
+from uuid import uuid4
+
+import pyproj
+import pytest
+
+from cti.model.target import Target, TargetDerived
+from cti.positioning.target_geometry import LineState, derive
+
+
+_NOW = datetime(2026, 5, 5, tzinfo=timezone.utc)
+_SRID = "EPSG:32618"  # UTM zone 18N — covers Chesapeake Bay area
+# Approximate UTM 18N projection of (-76.40, 38.95) — round numbers used so the
+# math in assertions is easy to follow; tests don't depend on exact projection.
+_VESSEL_X = 378_700.0
+_VESSEL_Y = 4_312_160.0
+
+
+def _make_target(
+    *,
+    channel: int = 1,
+    sample: int = 0,
+    width_samples: int | None = None,
+    height_pings: int | None = None,
+    shadow_samples: int | None = None,
+) -> Target:
+    """Build a Target with sane defaults for tests that vary one field."""
+    return Target(
+        target_id=uuid4(),
+        sidescan_ping_source_id=uuid4(),
+        channel=channel,
+        ping=1000,
+        sample=sample,
+        width_samples=width_samples,
+        height_pings=height_pings,
+        shadow_samples=shadow_samples,
+        created_at=_NOW,
+        updated_at=_NOW,
+    )
+
+
+def _make_line_state(
+    *,
+    projected_x: float = _VESSEL_X,
+    projected_y: float = _VESSEL_Y,
+    heading_deg: float = 0.0,
+    sample_spacing_units: float = 0.075,
+    ping_spacing_units: float = 0.30,
+    altitude_units: float | None = None,
+) -> LineState:
+    """Build a LineState with sane defaults for tests that vary one field."""
+    return LineState(
+        projected_x=projected_x,
+        projected_y=projected_y,
+        heading_deg=heading_deg,
+        sample_spacing_units=sample_spacing_units,
+        ping_spacing_units=ping_spacing_units,
+        altitude_units=altitude_units,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Position math
+
+
+def test_zero_sample_yields_vessel_position() -> None:
+    """A target at sample=0 sits at the vessel's projected position exactly."""
+    ls = _make_line_state()
+    derived = derive(_make_target(sample=0), ls, _SRID)
+
+    assert derived.projected_x == pytest.approx(ls.projected_x, abs=1e-9)
+    assert derived.projected_y == pytest.approx(ls.projected_y, abs=1e-9)
+
+
+def test_port_and_starboard_are_mirror_images() -> None:
+    """channel=0 and channel=1 at the same sample land equidistant from vessel,
+    on opposite sides."""
+    ls = _make_line_state()
+    port = derive(_make_target(channel=0, sample=200), ls, _SRID)
+    starboard = derive(_make_target(channel=1, sample=200), ls, _SRID)
+    vessel_x = (port.projected_x + starboard.projected_x) / 2.0
+    vessel_y = (port.projected_y + starboard.projected_y) / 2.0
+
+    # Vessel sits exactly between port and starboard targets
+    nadir = derive(_make_target(sample=0), ls, _SRID)
+    assert vessel_x == pytest.approx(nadir.projected_x, abs=1e-6)
+    assert vessel_y == pytest.approx(nadir.projected_y, abs=1e-6)
+
+    # Port is the negative side of the perpendicular axis
+    assert port.projected_x < starboard.projected_x
+
+
+def test_no_altitude_uses_slant_range_directly() -> None:
+    """Without altitude_units, ground_range == slant_range = sample × sample_spacing."""
+    ls = _make_line_state(heading_deg=0.0, altitude_units=None)
+    derived = derive(_make_target(channel=1, sample=200), ls, _SRID)
+    nadir = derive(_make_target(sample=0), ls, _SRID)
+
+    # Heading = 0 (north) → starboard is east → +x displacement
+    expected_dx = 200 * 0.075  # 15.0 m
+    assert derived.projected_x - nadir.projected_x == pytest.approx(
+        expected_dx, abs=1e-6
+    )
+    assert derived.projected_y == pytest.approx(nadir.projected_y, abs=1e-6)
+
+
+def test_slant_range_corrected_when_altitude_set() -> None:
+    """ground_range = sqrt(slant² - altitude²) when altitude < slant."""
+    ls = _make_line_state(heading_deg=0.0, altitude_units=10.0)
+    derived = derive(_make_target(channel=1, sample=200), ls, _SRID)
+    nadir = derive(_make_target(sample=0), ls, _SRID)
+
+    slant = 200 * 0.075  # 15 m
+    expected_ground = math.sqrt(slant**2 - 10.0**2)  # √125 ≈ 11.180
+    assert derived.projected_x - nadir.projected_x == pytest.approx(
+        expected_ground, abs=1e-6
+    )
+
+
+def test_slant_range_used_when_altitude_exceeds_slant() -> None:
+    """If altitude > slant range, the math would go imaginary — fall back to slant."""
+    ls = _make_line_state(heading_deg=0.0, altitude_units=50.0)
+    derived = derive(_make_target(channel=1, sample=200), ls, _SRID)
+    nadir = derive(_make_target(sample=0), ls, _SRID)
+
+    expected_dx = 200 * 0.075  # uncorrected
+    assert derived.projected_x - nadir.projected_x == pytest.approx(
+        expected_dx, abs=1e-6
+    )
+
+
+def test_heading_east_displaces_starboard_target_southward() -> None:
+    """Heading 90° (east) → starboard is south → negative y displacement."""
+    ls = _make_line_state(heading_deg=90.0)
+    derived = derive(_make_target(channel=1, sample=200), ls, _SRID)
+    nadir = derive(_make_target(sample=0), ls, _SRID)
+
+    expected_dy = -200 * 0.075  # 15 m south
+    assert derived.projected_y - nadir.projected_y == pytest.approx(
+        expected_dy, abs=1e-6
+    )
+    assert derived.projected_x == pytest.approx(nadir.projected_x, abs=1e-6)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sample-domain → linear-unit dimension conversion
+
+
+def test_width_height_shadow_convert_using_their_respective_spacings() -> None:
+    """width_samples × sample_spacing_units, height_pings × ping_spacing_units,
+    shadow_samples × sample_spacing_units."""
+    ls = _make_line_state(sample_spacing_units=0.075, ping_spacing_units=0.30)
+    target = _make_target(width_samples=10, height_pings=8, shadow_samples=15)
+    derived = derive(target, ls, _SRID)
+
+    assert derived.width == pytest.approx(10 * 0.075)
+    assert derived.height == pytest.approx(8 * 0.30)
+    assert derived.shadow == pytest.approx(15 * 0.075)
+
+
+def test_unset_dimensions_pass_through_as_none() -> None:
+    """If width_samples / height_pings / shadow_samples are None, derived
+    width / height / shadow are None — not zero."""
+    derived = derive(_make_target(), _make_line_state(), _SRID)
+
+    assert derived.width is None
+    assert derived.height is None
+    assert derived.shadow is None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# SRID handling
+
+
+def test_linear_unit_comes_from_srid_metadata() -> None:
+    """EPSG:32618 reports its linear unit as 'metre' (UK English per EPSG)."""
+    derived = derive(_make_target(), _make_line_state(), "EPSG:32618")
+    assert derived.linear_unit == "metre"
+
+
+def test_srid_string_round_trips_into_derived_block() -> None:
+    """The SRID the caller passed is the SRID the derived block reports."""
+    derived = derive(_make_target(), _make_line_state(), "EPSG:32619")
+    assert derived.srid == "EPSG:32619"
+
+
+def test_projected_to_geodetic_inverse_is_consistent() -> None:
+    """Projecting vessel position back to geodetic and forward again
+    recovers the same projected XY to centimeter precision."""
+    ls = _make_line_state()
+    derived = derive(_make_target(sample=0), ls, _SRID)
+
+    forward = pyproj.Transformer.from_crs("EPSG:4326", _SRID, always_xy=True)
+    rx, ry = forward.transform(derived.longitude, derived.latitude)
+    assert rx == pytest.approx(ls.projected_x, abs=1e-2)
+    assert ry == pytest.approx(ls.projected_y, abs=1e-2)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Pydantic shape pinning
+
+
+def test_target_derived_round_trips_through_json() -> None:
+    """TargetDerived serializes and deserializes losslessly."""
+    derived = TargetDerived(
+        longitude=-76.123,
+        latitude=38.456,
+        projected_x=412345.67,
+        projected_y=4256789.01,
+        srid="EPSG:32618",
+        width=4.8,
+        height=6.0,
+        shadow=3.6,
+        linear_unit="metre",
+    )
+    parsed = TargetDerived.model_validate_json(derived.model_dump_json())
+    assert parsed == derived
+
+
+def test_target_carries_optional_derived_block() -> None:
+    """Target.derived is a TargetDerived | None field, defaulting to None."""
+    target = _make_target()
+    assert target.derived is None
+
+    target_with_derived = target.model_copy(
+        update={
+            "derived": TargetDerived(
+                longitude=0.0,
+                latitude=0.0,
+                projected_x=0.0,
+                projected_y=0.0,
+                srid="EPSG:4326",
+                linear_unit="degree",
+            )
+        }
+    )
+    assert target_with_derived.derived is not None
+    assert target_with_derived.derived.srid == "EPSG:4326"

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

@@ -1,63 +0,0 @@
-"""Pydantic models for target data."""
-
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict
-
-
-class TargetBase(BaseModel):
-    """Base model for target data.
-
-    Attributes:
-        name: Target name.
-        description: Target description.
-        target_x: X coordinate of the target.
-        target_y: Y coordinate of the target.
-        width: Target width.
-        height: Target height.
-        shadow: Target shadow.
-    """
-
-    name: str
-    description: str
-    target_x: float
-    target_y: float
-    width: float | None = None
-    height: float | None = None
-    shadow: float | None = None
-
-
-class TargetCreate(TargetBase):
-    """Model for creating target data.
-
-    Attributes:
-        sidescan_ping_source_id: FK reference to SidescanPingSource.
-        channel: Channel index (0=port, 1=starboard).
-        row: Ping row index.
-    """
-
-    sidescan_ping_source_id: UUID
-    channel: int
-    row: int
-
-
-class TargetUpdate(TargetBase):
-    """Model for updating target data."""
-
-
-class Target(TargetBase):
-    """Model for target data with database fields.
-
-    Attributes:
-        target_id: Unique identifier for the target.
-        sidescan_ping_source_id: FK reference to SidescanPingSource.
-        channel: Channel index (0=port, 1=starboard).
-        row: Ping row index.
-    """
-
-    target_id: UUID
-    sidescan_ping_source_id: UUID
-    channel: int
-    row: int
-
-    model_config = ConfigDict(from_attributes=True)