racs-python 0.0.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

racs_python/__init__.py

@@ -1,3 +1,41 @@
+from .burst import BurstJob
+from .camera import Camera
 from .client import RacsClient
+from .errors import (
+    BurstJobFailedError,
+    CameraBusyError,
+    FeatureError,
+    ImageFailedError,
+    LiveStreamError,
+    NotFoundError,
+    RacsError,
+    RacsHttpError,
+)
+from .frame import Frame
+from .live import LiveStream
+from .models import (
+    AutoPacketSize,
+    BurstFormat,
+    BurstJobCreated,
+    BurstJobInfo,
+    DeviceConnections,
+    DeviceDiscoverInfo,
+    FeatureState,
+    GenICamAccessMode,
+    GenICamEnumInfo,
+    GenICamNodeCategory,
+    GenICamNodeInfo,
+    GenICamNodeType,
+    GenICamVisibility,
+    ImageEntryFailed,
+    ImageEntryOk,
+    JobStatus,
+    LiveFormat,
+    OnFailure,
+    PacketSizeInfo,
+    PixelDepth,
+    StreamErrorInfo,
+    StreamInfo,
+)
 
-__version__ = "0.0.1"
+__version__ = "0.3.0"

racs_python/burst.py

@@ -0,0 +1,119 @@
+import time
+from typing import TYPE_CHECKING, Iterator, List, Optional, Union
+from uuid import UUID
+
+from .errors import BurstJobFailedError, NotFoundError, RacsError
+from .frame import Frame
+from .models import BurstJobInfo, ImageEntry, ImageEntryOk, JobStatus
+
+if TYPE_CHECKING:
+    from .camera import Camera
+
+
+class BurstJob:
+    """
+    A burst job on the server. The frames stay there until the job is deleted, or expire 10 min
+    after it finishes.
+
+    Used as a context manager, the job is deleted on exit::
+
+        with cam.burst(20, format="raw") as job:
+            for frame in job.frames():
+                ...
+    """
+
+    def __init__(self, camera: "Camera", job_id: Union[UUID, str]):
+        self.camera = camera
+        self.id = job_id if isinstance(job_id, UUID) else UUID(str(job_id))
+        # The first status that carried the frame geometry; it is the same for every frame.
+        self._geometry: Optional[BurstJobInfo] = None
+
+    @property
+    def _client(self):
+        return self.camera.client
+
+    def info(self) -> BurstJobInfo:
+        """The job's status and progress."""
+        info = self._client.get_grab_job(self.camera.id, self.id)
+        if info.width is not None:
+            self._geometry = info
+        return info
+
+    def images(self) -> List[ImageEntry]:
+        """Every frame attempted so far, in capture order: ImageEntryOk or ImageEntryFailed."""
+        return self._client.list_grab_job_images(self.camera.id, self.id)
+
+    def image(self, index: int) -> bytes:
+        """The encoded bytes of frame ``index``."""
+        return self._client.get_grab_job_image(self.camera.id, self.id, index)
+
+    def frame(self, index: int) -> Frame:
+        """Frame ``index`` with its geometry, ready for :meth:`Frame.to_numpy` (raw jobs)."""
+        data = self.image(index)
+        geometry = self._geometry or self.info()
+        if geometry.width is None or geometry.height is None:
+            raise RacsError(f"burst job {self.id} reports no frame geometry")
+        return Frame(
+            data=data,
+            width=geometry.width,
+            height=geometry.height,
+            format=geometry.format.value,
+            pixel_format=geometry.pixel_format or "Mono8",
+            bit_depth=geometry.bit_depth or 8,
+        )
+
+    def wait(self, timeout: Optional[float] = None, poll_interval: float = 0.1) -> BurstJobInfo:
+        """
+        Block until the job is completed or cancelled and return its final status. Raises
+        BurstJobFailedError if it failed and TimeoutError after ``timeout`` seconds.
+        """
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while True:
+            info = self.info()
+            if info.status.is_terminal:
+                if info.status == JobStatus.FAILED:
+                    raise BurstJobFailedError(info)
+                return info
+            if deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError(f"burst job {self.id} still {info.status.value} after {timeout} s")
+            time.sleep(poll_interval)
+
+    def frames(self, poll_interval: float = 0.1) -> Iterator[Frame]:
+        """
+        Yield every captured frame in order, as soon as it is on the server; failed frames (only
+        with ``on_failure="skip"``) are left out. Ends when the job is done, and raises
+        BurstJobFailedError after the last frame if the job failed.
+        """
+        next_index = 0
+        while True:
+            # Status first: once it is terminal, the listing that follows is complete.
+            info = self.info()
+            for entry in self.images():
+                if entry.index < next_index:
+                    continue
+                next_index = entry.index + 1
+                if isinstance(entry, ImageEntryOk):
+                    yield self.frame(entry.index)
+            if info.status.is_terminal:
+                if info.status == JobStatus.FAILED:
+                    raise BurstJobFailedError(info)
+                return
+            time.sleep(poll_interval)
+
+    def delete(self) -> None:
+        """Cancel the job if it still runs, and drop it and its frames from the server."""
+        self._client.delete_grab_job(self.camera.id, self.id)
+
+    cancel = delete
+
+    def __enter__(self) -> "BurstJob":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        try:
+            self.delete()
+        except NotFoundError:
+            pass
+
+    def __repr__(self) -> str:
+        return f"BurstJob(device_id={self.camera.id}, id='{self.id}')"

racs_python/camera.py

@@ -0,0 +1,229 @@
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
+from uuid import UUID
+
+from .burst import BurstJob
+from .errors import FeatureError, RacsError
+from .frame import Frame
+from .models import (
+    AutoPacketSize,
+    BurstFormat,
+    DeviceDiscoverInfo,
+    FeatureState,
+    GenICamNodeCategory,
+    GenICamNodeInfo,
+    GenICamNodeType,
+    LiveFormat,
+    OnFailure,
+    PacketSizeInfo,
+    PixelDepth,
+    StreamErrorInfo,
+)
+
+if TYPE_CHECKING:
+    from .client import RacsClient
+    from .live import LiveStream
+
+FeatureValue = Union[int, float, bool, str, None]
+
+
+def _names(names: tuple) -> List[str]:
+    """Accept both ``states("A", "B")`` and ``states(["A", "B"])``."""
+    if len(names) == 1 and not isinstance(names[0], str):
+        return list(names[0])
+    return list(names)
+
+
+def feature_value(state: FeatureState) -> FeatureValue:
+    """
+    A feature state's value as a Python value: int for Integer and Enum (enums are read as their
+    integer value), float, bool or str. None for a command or an unavailable feature.
+    """
+    if state.error:
+        raise FeatureError(state.name, state.error)
+    if state.value is None:
+        return None
+    if state.node_type in (GenICamNodeType.INTEGER, GenICamNodeType.ENUM):
+        return int(state.value)
+    if state.node_type == GenICamNodeType.FLOAT:
+        return float(state.value)
+    if state.node_type == GenICamNodeType.BOOLEAN:
+        return state.value.lower() == "true"
+    return state.value
+
+
+def format_value(value: Any) -> str:
+    """A Python value in the form the server parses: ``true``/``false`` for bools, else ``str()``."""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
+class Camera:
+    """
+    One device on a RACS server. Every call goes to the server; the handle only holds the id.
+
+    Get one from :meth:`RacsClient.camera`, :meth:`RacsClient.connect` or :meth:`RacsClient.cameras`::
+
+        cam = client.connect(0)
+        cam["ExposureTime"] = 5000
+        width = cam["Width"]
+    """
+
+    def __init__(self, client: "RacsClient", device_id: int):
+        self.client = client
+        self.id = device_id
+        self._categories: Optional[List[GenICamNodeCategory]] = None
+
+    def __repr__(self) -> str:
+        return f"Camera(id={self.id}, server={self.client.base_url!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Camera) and other.client is self.client and other.id == self.id
+
+    def __hash__(self) -> int:
+        return hash((id(self.client), self.id))
+
+    # --- CONNECTION ---
+
+    def info(self) -> DeviceDiscoverInfo:
+        """The device's identity as the server reports it. Raises RacsError if it is not connected."""
+        for device in self.client.get_connected_devices():
+            if device.id == self.id:
+                return device
+        raise RacsError(f"device {self.id} is not connected")
+
+    def is_connected(self) -> bool:
+        return any(d.id == self.id for d in self.client.get_connected_devices())
+
+    def connect(self, ip: Optional[str] = None) -> "Camera":
+        """Connect the device, by discovery or at ``ip``. Does nothing if it is connected already."""
+        self.client.connect_device(self.id, ip)
+        self._categories = None
+        return self
+
+    def disconnect(self) -> None:
+        self.client.disconnect_device(self.id)
+        self._categories = None
+
+    def xml(self) -> str:
+        """The device's GenICam XML."""
+        return self.client.get_device_xml(self.id)
+
+    def categories(self, refresh: bool = False) -> List[GenICamNodeCategory]:
+        """The GenICam categories and their features. Cached: they don't change while connected."""
+        if self._categories is None or refresh:
+            self._categories = self.client.get_device_gc_categories(self.id)
+        return self._categories
+
+    def feature_info(self, name: str) -> GenICamNodeInfo:
+        """A feature's description from :meth:`categories`: type, access, enum entries, ..."""
+        for category in self.categories():
+            for node in category.nodes:
+                if node.name == name:
+                    return node
+        raise FeatureError(name, "Feature not found")
+
+    # --- FEATURES ---
+
+    def state(self, name: str) -> FeatureState:
+        """A feature's live state: value, availability, lock, bounds."""
+        return self.states(name)[0]
+
+    def states(self, *names: Union[str, Iterable[str]]) -> List[FeatureState]:
+        """The live state of several features in one request, in the order asked."""
+        return self.client.get_device_gc_feature_states(self.id, _names(names))
+
+    def get(self, name: str) -> FeatureValue:
+        """
+        A feature's value, typed by the feature: int (Integer, Enum), float, bool or str. None
+        for a command or a feature that is unavailable right now. Raises FeatureError for an
+        unknown feature or a failed read.
+        """
+        return feature_value(self.state(name))
+
+    def get_many(self, *names: Union[str, Iterable[str]]) -> Dict[str, FeatureValue]:
+        """Several typed values in one request, as ``{name: value}``."""
+        return {s.name: feature_value(s) for s in self.states(*names)}
+
+    def set(self, name: str, value: Any) -> None:
+        """
+        Write a feature: an int or float for numbers, a bool for Boolean, an int or the entry
+        name for an Enum, a str for String.
+        """
+        self.client.set_device_gc_node_value(self.id, name, format_value(value))
+
+    def execute(self, command: str) -> None:
+        """Execute a command feature such as ``TriggerSoftware`` or ``UserSetLoad``."""
+        self.client.execute_device_gc_command(self.id, command)
+
+    def __getitem__(self, name: str) -> FeatureValue:
+        return self.get(name)
+
+    def __setitem__(self, name: str, value: Any) -> None:
+        self.set(name, value)
+
+    # --- FRAMES ---
+
+    def grab_jpeg(self, quality: Optional[int] = None) -> bytes:
+        """One frame as a JPEG file (Mono8)."""
+        return self.client.grab_jpg_frame(self.id, quality)
+
+    def grab_raw(self) -> Frame:
+        """One raw Mono8 frame with its size."""
+        data = self.client.grab_raw_frame(self.id)
+        size = self.get_many("Width", "Height")
+        width, height = int(size["Width"]), int(size["Height"])
+        if len(data) != width * height:
+            raise RacsError(f"raw frame of {len(data)} bytes does not match {width}x{height}; was the size changed?")
+        return Frame(data=data, width=width, height=height)
+
+    def stream_error(self) -> StreamErrorInfo:
+        """Why the last live stream ended, and whether one runs now."""
+        return self.client.get_stream_error(self.id)
+
+    def packet_size(self) -> PacketSizeInfo:
+        """
+        The stream packet size, the sizes it may take and the link MTU. Every grab, stream and
+        burst uses it as it is; change it with ``cam["GevSCPSPacketSize"] = 7960`` or
+        :meth:`auto_packet_size`.
+        """
+        return self.client.get_packet_size(self.id)
+
+    def auto_packet_size(self) -> AutoPacketSize:
+        """Find the largest packet size that reaches the server, with test packets, and set it."""
+        return self.client.auto_packet_size(self.id)
+
+    def live(
+        self,
+        format: Union[LiveFormat, str] = LiveFormat.JPEG,
+        pixel_depth: Union[PixelDepth, str, None] = None,
+        quality: Optional[int] = None,
+        fps: Optional[float] = None,
+        timeout: Optional[float] = None,
+    ) -> "LiveStream":
+        """
+        Start a live stream; iterate it for frames and close it when done::
+
+            with cam.live(format="raw", pixel_depth="mono16", fps=10) as stream:
+                for frame in stream:
+                    pixels = frame.to_numpy()
+        """
+        return self.client.stream_live(self.id, format, pixel_depth, quality, fps, timeout)
+
+    def burst(
+        self,
+        count: int,
+        format: Union[BurstFormat, str] = BurstFormat.RAW,
+        pixel_depth: Union[PixelDepth, str, None] = None,
+        quality: Optional[int] = None,
+        on_failure: Union[OnFailure, str, None] = None,
+        max_failures: Optional[int] = None,
+    ) -> BurstJob:
+        """Start a background burst of ``count`` (1-500) frames on the server."""
+        created = self.client.start_grab_job(
+            self.id, count, format, pixel_depth, quality, on_failure, max_failures)
+        return BurstJob(self, created.job_id)
+
+    def job(self, job_id: Union[UUID, str]) -> BurstJob:
+        """A handle for an existing burst job of this device."""
+        return BurstJob(self, job_id)

racs_python/client.py

@@ -1,35 +1,132 @@
+from enum import Enum
+from typing import Iterable, List, Optional, Union
+from urllib.parse import quote, urlsplit, urlunsplit
+from uuid import UUID
+
 import requests
-from typing import List, Optional
-from .models import DeviceConnections, GenICamNodeCategory
+
+from .camera import Camera
+from .errors import http_error
+from .live import LiveStream
+from .models import (
+    AutoPacketSize,
+    BurstFormat,
+    BurstJobCreated,
+    BurstJobInfo,
+    DeviceConnections,
+    DeviceDiscoverInfo,
+    FeatureState,
+    GenICamNodeCategory,
+    ImageEntry,
+    LiveFormat,
+    OnFailure,
+    PacketSizeInfo,
+    PixelDepth,
+    StreamErrorInfo,
+    image_entries,
+)
+
+API_PATH = "/api/v1"
+
+
+def normalize_base_url(base_url: str) -> str:
+    """Strip a trailing slash, and add ``/api/v1`` to a bare server URL such as ``http://host:8742``."""
+    url = base_url.rstrip("/")
+    if not urlsplit(url).path:
+        url += API_PATH
+    return url
+
+
+def websocket_url(base_url: str) -> str:
+    """The ``ws``/``wss`` counterpart of an ``http``/``https`` base URL."""
+    parts = urlsplit(base_url)
+    scheme = {"http": "ws", "https": "wss"}.get(parts.scheme, parts.scheme)
+    return urlunsplit((scheme, parts.netloc, parts.path, "", ""))
+
+
+def _segment(name: str) -> str:
+    """A feature or command name as one URL path segment."""
+    return quote(name, safe="")
+
+
+def _wire(value: Union[str, Enum]) -> str:
+    return value.value if isinstance(value, Enum) else str(value)
 
 
 class RacsClient:
-    def __init__(self, base_url: str, timeout: int = 10):
+    """
+    HTTP client for a RACS server.
+
+    The methods here map one to one onto the REST routes and take the device id each time. For
+    day-to-day use, get a :class:`Camera` from :meth:`camera`, :meth:`connect` or :meth:`cameras`
+    instead: it holds the id and adds typed feature access, live streaming and burst jobs.
+    """
+
+    def __init__(self, base_url: str, timeout: float = 10):
         """
         Initialize the client.
 
-        :param base_url: The root URL of the server (e.g. "http://localhost:8080/api/v1")
+        :param base_url: The API root (e.g. "http://localhost:8742/api/v1"). A bare server URL
+            such as "http://localhost:8742" gets "/api/v1" added.
         :param timeout: Request timeout in seconds.
         """
-        # Ensure no trailing slash for cleaner URL joining
-        self.base_url = base_url.rstrip('/')
+        self.base_url = normalize_base_url(base_url)
         self.timeout = timeout
+        self._session = requests.Session()
+
+    def close(self) -> None:
+        """Close the underlying HTTP session."""
+        self._session.close()
+
+    def __enter__(self) -> "RacsClient":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"RacsClient({self.base_url!r})"
 
     # --- HELPER METHODS ---
 
-    def _get(self, endpoint: str, **kwargs):
-        """Internal helper for GET requests."""
+    def _request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        """Send a request; an error status raises the matching :class:`RacsHttpError`."""
         url = f"{self.base_url}{endpoint}"
-        response = requests.get(url, timeout=self.timeout, **kwargs)
-        response.raise_for_status()
+        response = self._session.request(method, url, timeout=self.timeout, **kwargs)
+        if not response.ok:
+            raise http_error(response.status_code, response.text, url, response)
         return response
 
+    def _get(self, endpoint: str, **kwargs):
+        """Internal helper for GET requests."""
+        return self._request("GET", endpoint, **kwargs)
+
     def _put(self, endpoint: str, **kwargs):
         """Internal helper for PUT requests."""
-        url = f"{self.base_url}{endpoint}"
-        response = requests.put(url, timeout=self.timeout, **kwargs)
-        response.raise_for_status()
-        return response
+        return self._request("PUT", endpoint, **kwargs)
+
+    def _post(self, endpoint: str, **kwargs):
+        """Internal helper for POST requests."""
+        return self._request("POST", endpoint, **kwargs)
+
+    def _delete(self, endpoint: str, **kwargs):
+        """Internal helper for DELETE requests."""
+        return self._request("DELETE", endpoint, **kwargs)
+
+    # --- CAMERA HANDLES ---
+
+    def camera(self, device_id: int) -> Camera:
+        """A handle for device ``device_id``. Makes no request; the device need not be connected yet."""
+        return Camera(self, device_id)
+
+    def connect(self, device_id: int, ip: Optional[str] = None) -> Camera:
+        """Connect device ``device_id`` (by discovery, or at ``ip``) and return its handle."""
+        self.connect_device(device_id, ip)
+        return self.camera(device_id)
+
+    def cameras(self) -> List[Camera]:
+        """Handles for every device the server is connected to."""
+        return [self.camera(d.id) for d in self.get_connected_devices()]
 
     # --- DEVICE OPERATIONS ---
 
@@ -41,6 +138,14 @@ class RacsClient:
         response = self._get("/devices")
         return DeviceConnections.model_validate(response.json())
 
+    def get_connected_devices(self) -> List[DeviceDiscoverInfo]:
+        """
+        Lists the devices the server is connected to, without running a network discovery.
+        GET /devices/connected
+        """
+        response = self._get("/devices/connected")
+        return [DeviceDiscoverInfo.model_validate(d) for d in response.json()]
+
     def connect_device(self, device_id: int, ip: Optional[str] = None) -> None:
         """
         Connect to a specific device.
@@ -87,7 +192,7 @@ class RacsClient:
         Get a specific GenICam feature value.
         GET /devices/{id}/gc/feature/{feature_name}
         """
-        response = self._get(f"/devices/{device_id}/gc/feature/{feature_name}")
+        response = self._get(f"/devices/{device_id}/gc/feature/{_segment(feature_name)}")
         return response.text
 
     def set_device_gc_node_value(self, device_id: int, feature_name: str, value: str) -> None:
@@ -97,27 +202,161 @@ class RacsClient:
         """
         # 'value' is passed as a query parameter per the spec
         self._put(
-            f"/devices/{device_id}/gc/feature/{feature_name}",
+            f"/devices/{device_id}/gc/feature/{_segment(feature_name)}",
             params={"value": value}
         )
 
+    def get_device_gc_feature_states(self, device_id: int, names: Iterable[str]) -> List[FeatureState]:
+        """
+        Get the live state of 1 to 256 features in one request, in the order asked. A problem
+        with one feature is reported in that entry's ``error``.
+        POST /devices/{id}/gc/features/state
+        """
+        response = self._post(f"/devices/{device_id}/gc/features/state", json={"names": list(names)})
+        return [FeatureState.model_validate(item) for item in response.json()]
+
+    def execute_device_gc_command(self, device_id: int, command_name: str) -> None:
+        """
+        Execute a GenICam command feature such as TriggerSoftware.
+        POST /devices/{id}/gc/command/{command_name}
+        """
+        self._post(f"/devices/{device_id}/gc/command/{_segment(command_name)}")
+
     # --- STREAMING OPERATIONS ---
 
-    def grab_jpg_frame(self, device_id: int) -> bytes:
+    def grab_jpg_frame(self, device_id: int, quality: Optional[int] = None) -> bytes:
         """
-        Grab a single frame as JPEG.
+        Grab a single frame as JPEG, at ``quality`` 1-100 (the server's default is 80).
 
         PixelFormat is automatically set to MONO_8
         GET /devices/{id}/stream/frame/jpeg
         """
-        response = self._get(f"/devices/{device_id}/stream/frame/jpeg")
+        params = {"quality": quality} if quality is not None else None
+        response = self._get(f"/devices/{device_id}/stream/frame/jpeg", params=params)
         # Spec defines content as octet-stream/array of bytes
         return response.content
 
     def grab_raw_frame(self, device_id: int) -> bytes:
         """
-        Grab a single frame as RAW data.
+        Grab a single frame as RAW data: Width*Height bytes (Mono8).
         GET /devices/{id}/stream/frame/raw
         """
         response = self._get(f"/devices/{device_id}/stream/frame/raw")
-        return response.content
+        return response.content
+
+    def get_stream_error(self, device_id: int) -> StreamErrorInfo:
+        """
+        Why the last live stream on the device ended, and whether one runs now.
+        GET /devices/{id}/stream/error
+        """
+        response = self._get(f"/devices/{device_id}/stream/error")
+        return StreamErrorInfo.model_validate(response.json())
+
+    def get_packet_size(self, device_id: int) -> PacketSizeInfo:
+        """
+        The stream packet size (GevSCPSPacketSize), its bounds and the link MTU. Set it with
+        ``set_device_gc_node_value(id, "GevSCPSPacketSize", ...)``.
+        GET /devices/{id}/stream/packet-size
+        """
+        response = self._get(f"/devices/{device_id}/stream/packet-size")
+        return PacketSizeInfo.model_validate(response.json())
+
+    def auto_packet_size(self, device_id: int) -> AutoPacketSize:
+        """
+        Find the largest packet size that reaches the server, with test packets, and set it.
+        Works during a live stream too, which carries on with the new size.
+        POST /devices/{id}/stream/packet-size/auto
+        """
+        response = self._post(f"/devices/{device_id}/stream/packet-size/auto")
+        return AutoPacketSize.model_validate(response.json())
+
+    def stream_live(
+        self,
+        device_id: int,
+        format: Union[LiveFormat, str] = LiveFormat.JPEG,
+        pixel_depth: Union[PixelDepth, str, None] = None,
+        quality: Optional[int] = None,
+        fps: Optional[float] = None,
+        timeout: Optional[float] = None,
+    ) -> LiveStream:
+        """
+        Open the live-stream WebSocket. The camera is held until the stream is closed.
+
+        :param timeout: Seconds to wait for each frame; defaults to the client timeout.
+        GET /devices/{id}/stream/live (WebSocket)
+        """
+        params = {"format": _wire(format)}
+        if pixel_depth is not None:
+            params["pixel_depth"] = _wire(pixel_depth)
+        if quality is not None:
+            params["quality"] = str(quality)
+        if fps is not None:
+            params["fps"] = str(fps)
+        return LiveStream(
+            self,
+            device_id,
+            f"{websocket_url(self.base_url)}/devices/{device_id}/stream/live",
+            params,
+            self.timeout if timeout is None else timeout,
+        )
+
+    # --- BURST JOBS ---
+
+    def start_grab_job(
+        self,
+        device_id: int,
+        count: int,
+        format: Union[BurstFormat, str] = BurstFormat.RAW,
+        pixel_depth: Union[PixelDepth, str, None] = None,
+        quality: Optional[int] = None,
+        on_failure: Union[OnFailure, str, None] = None,
+        max_failures: Optional[int] = None,
+    ) -> BurstJobCreated:
+        """
+        Start a background burst of ``count`` (1-500) frames. Returns before the capture starts:
+        a busy camera shows up as a job that fails.
+        POST /devices/{id}/grab/jobs
+        """
+        body = {"count": count, "format": _wire(format)}
+        if pixel_depth is not None:
+            body["pixel_depth"] = _wire(pixel_depth)
+        if quality is not None:
+            body["quality"] = quality
+        if on_failure is not None:
+            body["on_failure"] = _wire(on_failure)
+        if max_failures is not None:
+            body["max_failures"] = max_failures
+        response = self._post(f"/devices/{device_id}/grab/jobs", json=body)
+        return BurstJobCreated.model_validate(response.json())
+
+    def get_grab_job(self, device_id: int, job_id: Union[UUID, str]) -> BurstJobInfo:
+        """
+        A burst job's progress.
+        GET /devices/{id}/grab/jobs/{job_id}
+        """
+        response = self._get(f"/devices/{device_id}/grab/jobs/{job_id}")
+        return BurstJobInfo.model_validate(response.json())
+
+    def list_grab_job_images(self, device_id: int, job_id: Union[UUID, str]) -> List[ImageEntry]:
+        """
+        The frames a burst job has attempted so far, in capture order.
+        GET /devices/{id}/grab/jobs/{job_id}/images
+        """
+        response = self._get(f"/devices/{device_id}/grab/jobs/{job_id}/images")
+        return image_entries.validate_python(response.json())
+
+    def get_grab_job_image(self, device_id: int, job_id: Union[UUID, str], index: int) -> bytes:
+        """
+        One captured frame, in the job's format. Raises NotFoundError for an index not captured
+        (yet) and ImageFailedError for one that failed.
+        GET /devices/{id}/grab/jobs/{job_id}/images/{index}
+        """
+        response = self._get(f"/devices/{device_id}/grab/jobs/{job_id}/images/{index}")
+        return response.content
+
+    def delete_grab_job(self, device_id: int, job_id: Union[UUID, str]) -> None:
+        """
+        Cancel a running burst job or discard a finished one, with its images.
+        DELETE /devices/{id}/grab/jobs/{job_id}
+        """
+        self._delete(f"/devices/{device_id}/grab/jobs/{job_id}")

racs_python/errors.py

@@ -0,0 +1,78 @@
+from typing import TYPE_CHECKING, Optional
+
+import requests
+
+if TYPE_CHECKING:
+    from .models import BurstJobInfo
+
+
+class RacsError(Exception):
+    """Base class of every error raised by this library."""
+
+
+class RacsHttpError(RacsError, requests.HTTPError):
+    """
+    The server answered with an error status.
+
+    Subclasses ``requests.HTTPError``, so code written against earlier versions of this library
+    (which raised that directly) keeps working.
+    """
+
+    def __init__(self, status_code: int, body: str, url: str, response: Optional[requests.Response] = None):
+        super().__init__(f"{status_code} for {url}: {body}", response=response)
+        self.status_code = status_code
+        self.body = body
+        self.url = url
+
+
+class CameraBusyError(RacsHttpError):
+    """The camera is held by another request: a live stream, a burst job or a frame grab."""
+
+
+class NotFoundError(RacsHttpError):
+    """404: no such burst job, or a burst image that has not been captured (yet)."""
+
+
+class ImageFailedError(RacsHttpError):
+    """410: that burst image was attempted and failed. ``body`` holds the reason."""
+
+
+class FeatureError(RacsError):
+    """A GenICam feature could not be read, e.g. ``Feature not found``."""
+
+    def __init__(self, name: str, error: str):
+        super().__init__(f"{name}: {error}")
+        self.name = name
+        self.error = error
+
+
+class BurstJobFailedError(RacsError):
+    """A burst job ended in ``failed``. ``info.error`` holds the reason."""
+
+    def __init__(self, info: "BurstJobInfo"):
+        super().__init__(f"burst job {info.job_id} failed: {info.error}")
+        self.info = info
+
+
+class LiveStreamError(RacsError):
+    """The server closed the live stream because of an error."""
+
+    def __init__(self, reason: str, code: Optional[int] = None):
+        super().__init__(reason)
+        self.reason = reason
+        self.code = code
+
+
+def http_error(status_code: int, body: str, url: str,
+               response: Optional[requests.Response] = None) -> RacsHttpError:
+    """The exception for an error response, picked by status and body."""
+    if status_code == 404:
+        cls = NotFoundError
+    elif status_code == 410:
+        cls = ImageFailedError
+    # The server reports a held camera as a 500 whose body names the `Busy` store error.
+    elif status_code == 500 and "Busy" in body:
+        cls = CameraBusyError
+    else:
+        cls = RacsHttpError
+    return cls(status_code, body, url, response)

racs_python/frame.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Frame:
+    """
+    One image, with what it takes to decode it.
+
+    For ``format == "raw"``, ``data`` is ``width * height`` pixels, row by row: one byte each at a
+    ``bit_depth`` of 8, otherwise a little-endian u16 each in the range ``0..2**bit_depth``. For
+    ``"jpeg"`` it is a JPEG file holding the top 8 significant bits.
+    """
+
+    data: bytes = field(repr=False)
+    width: int
+    height: int
+    format: str = "raw"
+    pixel_format: str = "Mono8"
+    bit_depth: int = 8
+    # Live stream only: the message number in the session, and the cumulative dropped count.
+    frame_number: Optional[int] = None
+    dropped: Optional[int] = None
+
+    @property
+    def bytes_per_pixel(self) -> int:
+        return 2 if self.bit_depth > 8 else 1
+
+    def to_numpy(self):
+        """
+        The raw pixels as a ``(height, width)`` array: ``uint8`` at 8 bit, ``uint16`` above.
+
+        Needs numpy (``pip install racs-python[numpy]``). JPEG frames are not decoded here; pass
+        ``frame.data`` to an image library such as OpenCV or Pillow.
+        """
+        if self.format != "raw":
+            raise ValueError(f"to_numpy() needs a raw frame, this one is {self.format}; decode frame.data instead")
+        import numpy as np
+
+        dtype = np.dtype("<u2") if self.bytes_per_pixel == 2 else np.dtype(np.uint8)
+        expected = self.width * self.height * dtype.itemsize
+        if len(self.data) != expected:
+            raise ValueError(
+                f"frame holds {len(self.data)} bytes, {self.width}x{self.height} at {self.bit_depth} bit needs {expected}")
+        return np.frombuffer(self.data, dtype=dtype).reshape((self.height, self.width))

racs_python/live.py

@@ -0,0 +1,121 @@
+import struct
+from typing import TYPE_CHECKING, Dict, Iterator, Optional, Tuple
+from urllib.parse import urlencode
+
+import websocket
+
+from .errors import LiveStreamError, http_error
+from .frame import Frame
+from .models import StreamInfo
+
+if TYPE_CHECKING:
+    from .client import RacsClient
+
+# `[u32 LE frame_number][u32 LE frames_dropped]` in front of every binary message.
+FRAME_HEADER = struct.Struct("<II")
+
+# Close codes that end a stream without an error: the client left (1000), or the camera stopped
+# delivering (1001).
+_NORMAL_CLOSE = (1000, 1001)
+
+
+def parse_frame_message(data: bytes) -> Tuple[int, int, bytes]:
+    """Split a binary live-stream message into ``(frame_number, dropped, image)``."""
+    if len(data) < FRAME_HEADER.size:
+        raise LiveStreamError(f"frame message of {len(data)} bytes is shorter than its header")
+    frame_number, dropped = FRAME_HEADER.unpack_from(data)
+    return frame_number, dropped, bytes(data[FRAME_HEADER.size:])
+
+
+def parse_close(data: bytes) -> Tuple[Optional[int], str]:
+    """The status code and reason of a WebSocket close frame's payload."""
+    if len(data) < 2:
+        return None, ""
+    return struct.unpack(">H", data[:2])[0], data[2:].decode("utf-8", "replace")
+
+
+class LiveStream:
+    """
+    A running live stream: an iterator of :class:`Frame` that ends when the server closes the
+    stream normally.
+
+    The camera is held while the stream is open, so close it (or use it as a context manager)
+    when done. GenICam reads and writes still work meanwhile; frame grabs and burst jobs on the
+    device fail as busy.
+    """
+
+    def __init__(self, client: "RacsClient", device_id: int, url: str, params: Dict[str, str], timeout: float):
+        self.device_id = device_id
+        # Describes the frames being received. Replaced whenever the geometry changes mid-stream.
+        self.info: Optional[StreamInfo] = None
+        self.closed = False
+        full_url = f"{url}?{urlencode(params)}"
+        try:
+            self._ws = websocket.create_connection(full_url, timeout=timeout)
+        except websocket.WebSocketBadStatusException as e:
+            body = (getattr(e, "resp_body", None) or b"").decode("utf-8", "replace")
+            if not body:
+                # The server records why an upgrade was refused.
+                body = client.get_stream_error(device_id).last_error or ""
+            raise http_error(e.status_code, body, full_url) from None
+
+    def read(self) -> Optional[Frame]:
+        """The next frame, or None once the stream has ended. Raises LiveStreamError on a failed stream."""
+        while not self.closed:
+            try:
+                opcode, frame = self._ws.recv_data_frame()
+            except websocket.WebSocketTimeoutException as e:
+                raise TimeoutError(f"no frame from device {self.device_id} within {self._ws.gettimeout()} s") from e
+            except websocket.WebSocketConnectionClosedException as e:
+                self.closed = True
+                raise LiveStreamError("connection closed without a close frame") from e
+
+            if opcode == websocket.ABNF.OPCODE_TEXT:
+                self.info = StreamInfo.model_validate_json(frame.data)
+            elif opcode == websocket.ABNF.OPCODE_BINARY:
+                if self.info is None:
+                    raise LiveStreamError("frame received before the stream info")
+                frame_number, dropped, image = parse_frame_message(frame.data)
+                return Frame(
+                    data=image,
+                    width=self.info.width,
+                    height=self.info.height,
+                    format=self.info.format.value,
+                    pixel_format=self.info.pixel_format,
+                    bit_depth=self.info.bit_depth,
+                    frame_number=frame_number,
+                    dropped=dropped,
+                )
+            elif opcode == websocket.ABNF.OPCODE_CLOSE:
+                self.closed = True
+                code, reason = parse_close(frame.data)
+                if code is not None and code not in _NORMAL_CLOSE:
+                    raise LiveStreamError(reason or f"stream closed with code {code}", code)
+        return None
+
+    def close(self) -> None:
+        """Stop the stream and release the camera."""
+        if not self.closed:
+            self.closed = True
+            try:
+                self._ws.close()
+            except websocket.WebSocketException:
+                pass
+
+    def __iter__(self) -> Iterator[Frame]:
+        return self
+
+    def __next__(self) -> Frame:
+        frame = self.read()
+        if frame is None:
+            raise StopIteration
+        return frame
+
+    def __enter__(self) -> "LiveStream":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"LiveStream(device_id={self.device_id}, info={self.info!r}, closed={self.closed})"

racs_python/models.py

@@ -1,6 +1,9 @@
-from typing import List, Optional
+from datetime import datetime
 from enum import Enum
-from pydantic import BaseModel, Field
+from typing import Annotated, List, Literal, Optional, Union
+from uuid import UUID
+
+from pydantic import BaseModel, Field, TypeAdapter
 
 # --- ENUMS ---
 
@@ -17,6 +20,8 @@ class GenICamNodeType(str, Enum):
     FLOAT = "Float"
     STRING = "String"
     ENUM = "Enum"
+    BOOLEAN = "Boolean"
+    COMMAND = "Command"
 
 class GenICamVisibility(str, Enum):
     BEGINNER = "Beginner"
@@ -25,6 +30,36 @@ class GenICamVisibility(str, Enum):
     INVISIBLE = "Invisible"
     UNDEFINED = "Undefined"
 
+class PixelDepth(str, Enum):
+    """Requested depth of live and burst frames. The camera's answer is in ``bit_depth``."""
+    MONO8 = "mono8"
+    # The deepest unpacked mono format the camera accepts: Mono16, 14, 12, then 10
+    # (Coord3D_C16 on a 3D camera in Linescan3D).
+    MONO16 = "mono16"
+
+class LiveFormat(str, Enum):
+    JPEG = "jpeg"
+    RAW = "raw"
+
+class BurstFormat(str, Enum):
+    RAW = "raw"
+    JPEG = "jpeg"
+
+class OnFailure(str, Enum):
+    ABORT = "abort"
+    SKIP = "skip"
+
+class JobStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+    @property
+    def is_terminal(self) -> bool:
+        return self in (JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED)
+
 # --- MODELS ---
 
 class GenICamEnumInfo(BaseModel):
@@ -41,6 +76,8 @@ class GenICamNodeInfo(BaseModel):
     visibility: GenICamVisibility
     # "enums" can be a list or null. Default to None if missing.
     enums: Optional[List[GenICamEnumInfo]] = None
+    # For a selector (e.g. GainSelector): the features whose value depends on it.
+    selected: List[str] = Field(default_factory=list)
 
 class GenICamNodeCategory(BaseModel):
     name: str
@@ -59,4 +96,105 @@ class DeviceDiscoverInfo(BaseModel):
 
 class DeviceConnections(BaseModel):
     available: List[DeviceDiscoverInfo]
-    connected: List[DeviceDiscoverInfo]
+    connected: List[DeviceDiscoverInfo]
+
+class FeatureState(BaseModel):
+    """Live state of a feature, from ``POST /devices/{id}/gc/features/state``."""
+    name: str
+    # None when the feature isn't known (see `error`).
+    node_type: Optional[GenICamNodeType] = None
+    # Formatted as by the single-feature GET. None for a command, a write-only or unavailable
+    # feature, or a failed read.
+    value: Optional[str] = None
+    available: bool
+    # The feature can be read but not written right now.
+    locked: bool
+    # int stays exact for 64-bit integer bounds.
+    min: Optional[Union[int, float]] = None
+    max: Optional[Union[int, float]] = None
+    inc: Optional[Union[int, float]] = None
+    unit: Optional[str] = None
+    representation: Optional[str] = None
+    # For an enum: the integer values of the entries the device currently offers.
+    available_entries: Optional[List[int]] = None
+    error: Optional[str] = None
+
+class StreamErrorInfo(BaseModel):
+    """Why the last live stream on a device ended, and whether one runs now."""
+    last_error: Optional[str] = None
+    timestamp: Optional[datetime] = None
+    active_stream: bool
+
+class StreamInfo(BaseModel):
+    """Describes every live-stream frame after it, until the next one."""
+    width: int
+    height: int
+    format: LiveFormat
+    pixel_format: str
+    # Significant bits per pixel. Above 8, raw frames are little-endian u16s.
+    bit_depth: int
+    # GevSCPSPacketSize the stream runs with. None from servers that don't report it.
+    packet_size: Optional[int] = None
+
+class PacketSizeInfo(BaseModel):
+    """A camera's stream packet size, what it may be set to, and the link it travels over."""
+    # GevSCPSPacketSize: bytes per stream packet, IP and UDP headers included.
+    packet_size: int
+    # Allowed sizes are the multiples of `inc` from `min` to `max`.
+    min: int
+    max: int
+    inc: int
+    # MTU of the local interface the camera is reached over; None when unknown. A larger packet
+    # size never arrives.
+    link_mtu: Optional[int] = None
+    interface: Optional[str] = None
+    local_ip: Optional[str] = None
+
+class AutoPacketSize(BaseModel):
+    """The outcome of a test-packet search for the largest packet size that arrives."""
+    packet_size: int
+    previous: int
+    # False when the camera answered no test packet; the size is then left as it was.
+    test_packets: bool
+    link_mtu: Optional[int] = None
+    interface: Optional[str] = None
+
+class BurstJobCreated(BaseModel):
+    job_id: UUID
+    device_id: int
+    status: JobStatus
+
+class BurstJobInfo(BaseModel):
+    job_id: UUID
+    device_id: int
+    status: JobStatus
+    format: BurstFormat
+    requested_count: int
+    captured_count: int
+    failed_count: int
+    created_at: datetime
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    # When the finished job is dropped from the server. None until it finishes.
+    expires_at: Optional[datetime] = None
+    # Why the job failed. None unless `status` is failed.
+    error: Optional[str] = None
+    # Frame geometry, None until the first frame is captured.
+    width: Optional[int] = None
+    height: Optional[int] = None
+    pixel_format: Optional[str] = None
+    bit_depth: Optional[int] = None
+
+class ImageEntryOk(BaseModel):
+    status: Literal["ok"] = "ok"
+    index: int
+    size_bytes: int
+
+class ImageEntryFailed(BaseModel):
+    status: Literal["failed"] = "failed"
+    index: int
+    error: str
+
+ImageEntry = Annotated[Union[ImageEntryOk, ImageEntryFailed], Field(discriminator="status")]
+
+image_entries = TypeAdapter(List[ImageEntry])

{racs_python-0.0.2.dist-info → racs_python-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: racs-python
-Version: 0.0.2
+Version: 0.3.0
 Summary: Client library to access racs api server
 Author-email: Jonas Ahlf <javerik@javerik.space>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -349,55 +349,127 @@ Keywords: racs,aravis,camera,client,api,genicam,gev,gigevision
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.31
 Requires-Dist: pydantic>=2.0
+Requires-Dist: websocket-client>=1.6
+Provides-Extra: numpy
+Requires-Dist: numpy; extra == "numpy"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: numpy; extra == "test"
 Dynamic: license-file
 
 # RACS python client library
 
-Simple client which uses `requests` to interact with the [racs-api server](https://codeberg.org/javerik/RACS-RustAravisCamServe).
+Client for the [racs-api server](https://codeberg.org/javerik/RACS-RustAravisCamServe): device
+discovery and connection, typed GenICam feature access, single frames, the live stream
+(WebSocket) and burst jobs.
 
 ## Install
 
 ```shell
-pip install racs-python
+pip install racs-python            # numpy is optional:
+pip install "racs-python[numpy]"   # adds Frame.to_numpy()
 ```
 
 ## Usage
 
 > **Make sure an instance of racs-api server is running**
 
+A `Camera` holds the device id, so nothing else needs to pass it around:
+
 ```python
 from racs_python import RacsClient
 
-client = RacsClient("http://localhost:8742/api/v1")
+client = RacsClient("http://localhost:8742")   # "/api/v1" is added to a bare server URL
 
-# discover devices
-devices = client.get_devices()
+devices = client.get_devices()                 # network discovery
 print(f"Found {len(devices.available)} available devices.")
 
-if devices.available:
-        target_id = devices.available[0].id
-        
-        # 2. Connection
-        client.connect_device(target_id)
-        print(f"Connected to device {target_id}")
+cam = client.connect(devices.available[0].id)  # or client.connect(5, ip="192.168.0.10")
 
-        # 3. Read/Write Settings
-        width = client.get_device_gc_node_value(target_id, "Width")
-        print(f"Current Width: {width}")
-        
-        client.set_device_gc_node_value(target_id, "Width", "1920")
+# Features are read and written as Python values
+print(cam["Width"])                            # 1280 (int)
+cam["ExposureTime"] = 5000.0
+cam["ReverseX"] = True
+width, height = cam.get_many("Width", "Height").values()
+cam.execute("TriggerSoftware")
+
+# Single frames
+with open("frame.jpg", "wb") as f:
+    f.write(cam.grab_jpeg(quality=90))
+frame = cam.grab_raw()                         # Mono8, with width/height
+pixels = frame.to_numpy()                      # (height, width) uint8
+
+cam.disconnect()
+```
+
+Already connected devices: `client.cameras()`, or `client.camera(id)` for a handle without a request.
+
+### Live stream
+
+The stream holds the camera until it is closed. Features can still be read and written while it
+runs; a change of size arrives as a new `stream.info` and applies to the frames after it.
+
+```python
+from itertools import islice
+
+with cam.live(format="raw", pixel_depth="mono16", fps=10) as stream:
+    for frame in islice(stream, 100):
+        pixels = frame.to_numpy()              # uint16 at bit_depth > 8
+        print(frame.frame_number, frame.dropped, frame.bit_depth, pixels.mean())
+```
+
+`format="jpeg"` (the default) delivers JPEG files in `frame.data`. A stream that the server ends
+because of an error raises `LiveStreamError`; `cam.stream_error()` reports the last one.
 
-        # 4. Grab an image
-        jpg_data = client.grab_jpg_frame(target_id)
-        with open("frame.jpg", "wb") as f:
-            f.write(jpg_data)
+### Packet size
 
-        # 5. Cleanup
-        client.disconnect_device(target_id)
+Every grab, stream and burst uses the camera's stream packet size (`GevSCPSPacketSize`, bytes per
+packet including IP and UDP headers) as it is. Jumbo frames such as 7960 need a link MTU of 9000.
 
+```python
+info = cam.packet_size()                       # packet_size, min/max/inc, link_mtu, interface
+cam["GevSCPSPacketSize"] = 7960                # a multiple of info.inc, not above the link MTU
+auto = cam.auto_packet_size()                  # the largest size whose test packets arrive
+```
+
+Both work during a live stream, which pauses briefly and carries on with the new size
+(`stream.info.packet_size`).
+
+### Burst jobs
+
+A burst grabs up to 500 frames on the server in the background. Leaving the `with` block deletes
+the job and its frames.
+
+```python
+with cam.burst(50, format="raw", pixel_depth="mono16") as job:
+    for frame in job.frames():                 # yields each frame as soon as it is captured
+        ...
+    info = job.wait()                          # final status
 ```
+
+`job.image(i)` returns the encoded bytes of one frame, `job.images()` lists what has been
+captured, and `cam.job(job_id)` re-attaches to a job by id.
+
+### Errors
+
+Every error is a `RacsError`. HTTP errors are `RacsHttpError` (a `requests.HTTPError`) with
+`status_code` and `body`; the specific ones are `CameraBusyError` (the camera is held by a stream,
+burst or grab), `NotFoundError` and `ImageFailedError`. Feature reads raise `FeatureError`, a
+failed burst `BurstJobFailedError`.
+
+### Low-level client
+
+`RacsClient` maps one method onto each REST route and takes the device id every time, e.g.
+`client.get_device_gc_node_value(0, "Width")` or `client.start_grab_job(0, 20, "raw")`. Values
+are strings there, exactly as the server sends them.
+
+## Tests
+
+`client_libs/run-tests.sh python` builds the repository's fake-camera server
+(`cargo run --example fake_server`), starts it and runs the tests against it. `pytest` on its own
+runs only the tests that need no server.

racs_python-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+racs_python/__init__.py,sha256=nwzPFp_Bkdl9UjSba1VNsjlsWDsdys-q-zPwWAUS-04,805
+racs_python/burst.py,sha256=4DzEBH9EpdYjA_BwyvrweYAhe52iL4oPHi7B12n1RBk,4556
+racs_python/camera.py,sha256=VG44sHqSaRXUumqFmEeXLrc7kVy-clNnWBFjofTrqpw,8686
+racs_python/client.py,sha256=1zN51ugwENVRJh5YoTNHxEJzJY7RU6OZdszPVfiwjcE,13678
+racs_python/errors.py,sha256=yiNt_ALUvUyvXjIhVFAHS75oiM9bJ4ya0Hh078tX9ns,2473
+racs_python/frame.py,sha256=NDyvYzKUsgS8S5LhiFuN8DNcLhiBFdyMBEl1YQ9YeyI,1750
+racs_python/live.py,sha256=KSq_XM3QQpE3M1VDQnXOiV1sr_33Xl04siySY673-5s,4905
+racs_python/models.py,sha256=ygGOpYohZzmcu7SsHSfAWQB0WkH-sfKuHgB2S9R4LIs,6100
+racs_python-0.3.0.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+racs_python-0.3.0.dist-info/METADATA,sha256=CyOqQAUNvJIZjt68BeTS-hz11PSQW9ShP-LfPIzPO9U,25899
+racs_python-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+racs_python-0.3.0.dist-info/top_level.txt,sha256=FnooQMJiYyMezNBcuvAIo569MQfg7e1V7t84Tw-evlY,12
+racs_python-0.3.0.dist-info/RECORD,,

{racs_python-0.0.2.dist-info → racs_python-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

racs_python-0.0.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-racs_python/__init__.py,sha256=gxcymsmUiGNEvWz4-y8EVM6qxIvFWswqqvNzJnlzAdM,53
-racs_python/client.py,sha256=1CNZ-wOB_Q0ySskFXu-tp2hx_wIhQLxyb6hnIa2NRrg,4263
-racs_python/models.py,sha256=kUGVMqxY4gu3HQjVyRWh47-aMPn9t-hhezP9hwPGuA0,1465
-racs_python-0.0.2.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
-racs_python-0.0.2.dist-info/METADATA,sha256=iJ3uXAuEALogV6lo73CLQAOGom7iasSlcs5hvMAwqlI,22656
-racs_python-0.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-racs_python-0.0.2.dist-info/top_level.txt,sha256=FnooQMJiYyMezNBcuvAIo569MQfg7e1V7t84Tw-evlY,12
-racs_python-0.0.2.dist-info/RECORD,,