tinesight 0.0.2.dev1__tar.gz → 0.0.5.dev1__tar.gz

{tinesight-0.0.2.dev1 → tinesight-0.0.5.dev1}/PKG-INFO

@@ -1,10 +1,12 @@
 Metadata-Version: 2.3
 Name: tinesight
-Version: 0.0.2.dev1
+Version: 0.0.5.dev1
 Summary: Tinesight SDK
 Requires-Dist: cryptography>=46.0.3
 Requires-Dist: pycognito>=2024.5.1
+Requires-Dist: opencv-python>=4.13.0.90 ; extra == 'video'
 Requires-Python: >=3.12
+Provides-Extra: video
 Description-Content-Type: text/markdown
 
 # Tinesight SDK

{tinesight-0.0.2.dev1 → tinesight-0.0.5.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tinesight"
-version = "0.0.2.dev1"
+version = "0.0.5.dev1"
 description = "Tinesight SDK"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -9,6 +9,11 @@ dependencies = [
     "pycognito>=2024.5.1",
 ]
 
+[project.optional-dependencies]
+video = [
+    "opencv-python>=4.13.0.90",
+]
+
 [build-system]
 requires = ["uv_build"]
 build-backend = "uv_build"

tinesight-0.0.5.dev1/src/tinesight/__init__.py

@@ -0,0 +1 @@
+__all__ = ["TinesightClient", "TinesightRegistrar"]

tinesight-0.0.2.dev1/src/tinesight/api.py → tinesight-0.0.5.dev1/src/tinesight/_api.py

@@ -10,5 +10,5 @@ class TinesightApiMixin:
 
     @property
     def public_ux_api_uri(self) -> str:
-        api_ref = "p1pco7l9b1" if os.getenv("TINESIGHT_DEV") else "api"
+        api_ref = "17bx575oxl" if os.getenv("TINESIGHT_DEV") else "api"
         return f"https://{api_ref}.execute-api.us-east-1.amazonaws.com"

tinesight-0.0.5.dev1/src/tinesight/client.py

@@ -0,0 +1,225 @@
+from collections.abc import Callable
+from functools import partial
+from pathlib import Path
+import time
+
+import requests
+
+from tinesight._api import TinesightApiMixin
+
+
+class TinesightClient(TinesightApiMixin):
+    """
+    Client for invoking the Tinesight API from a device.
+
+    To use this class, a device must be registered with a signed certificate using the
+    `TinesightRegistrar`.
+
+    Examples:
+        >>> result = TinesightClient(my_key_path, my_cert_path).classify(my_image_bytes)
+        >>> print(result.json)
+        >>> {'class': 'deer', 'probability': 0.98}
+
+    """
+
+    @property
+    def _mtls_post(self) -> Callable:
+        """Private wrapper for making invoking requests with a certa"""
+        return partial(requests.post, cert=(self.cert_path, self.key_path))
+
+    def __init__(self, x509_key_path: Path | str, x509_cert_path: Path | str):
+        self.key_path: str = str(x509_key_path)
+        self.cert_path: str = str(x509_cert_path)
+
+    def classify(self, image: str | Path | bytes) -> requests.Response:
+        """Invokes the classification model for the specified image
+
+        Args:
+            image: Can be a file path (str or Path) or raw image bytes
+
+        Returns:
+            requests.Response containing classification results
+        """
+        classification_url = self.tenant_base_api_uri + "/classify/v1"
+
+        if isinstance(image, bytes):
+            image_bytes = image
+            file_name = "frame.jpg"
+        else:
+            if isinstance(image, str):
+                image = Path(image)
+            with open(image, "rb") as fp:
+                image_bytes = fp.read()
+            file_name = image.name
+
+        return self._mtls_post(classification_url, files={"file": (file_name, image_bytes)})
+
+    def classify_video_stream(
+        self,
+        video_source: str | int = 0,
+        frame_skip: int = 10,
+        probability_threshold: float = 0.55,
+        window_name: str = "Tinesight Classification",
+    ) -> None:
+        """
+        Continuously classify frames from a video stream and display results.
+
+        Captures video from a source (camera, RTSP stream, etc.), classifies frames
+        at regular intervals, and displays the video with classification annotations.
+        Press Ctrl+C to stop.
+
+        Args:
+            video_source: Video source - can be device index (0 for default camera),
+                         RTSP URL (e.g., "rtsp://192.168.1.100:8554/stream"),
+                         or HTTP stream URL
+            frame_skip: Classify every Nth frame (default: 10). Higher values = faster but less frequent updates
+            probability_threshold: Minimum confidence threshold to display classification (default: 0.55)
+            window_name: Name of the display window
+
+        Examples:
+            >>> client = TinesightClient(key_path, cert_path)
+            >>> # Local camera
+            >>> client.classify_video_stream(0)
+            >>> # Raspberry Pi RTSP stream
+            >>> client.classify_video_stream("rtsp://raspberrypi.local:8554/stream")
+            >>> # With custom threshold
+            >>> client.classify_video_stream(0, probability_threshold=0.75)
+        """
+        try:
+            import cv2
+        except ImportError:
+            raise ImportError(
+                "OpenCV is required for video streaming. Install with: pip install opencv-python"
+            )
+
+        # Open video stream
+        cap = cv2.VideoCapture(video_source)
+        if not cap.isOpened():
+            raise RuntimeError(f"Could not open video source: {video_source}")
+
+        print(f"Starting video stream from: {video_source}")
+        print(f"Classifying every {frame_skip} frames")
+        print("Press Ctrl+C to stop")
+
+        frame_count = 0
+        last_classification = None
+        last_probability = None
+        fps_start = time.time()
+        fps_frame_count = 0
+        current_fps = 0
+        last_latency = 0
+
+        try:
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    print("Failed to read frame, attempting to reconnect...")
+                    cap.release()
+                    time.sleep(1)
+                    cap = cv2.VideoCapture(video_source)
+                    continue
+
+                # Calculate FPS
+                fps_frame_count += 1
+                if time.time() - fps_start >= 1.0:
+                    current_fps = int(fps_frame_count / (time.time() - fps_start))
+                    fps_frame_count = 0
+                    fps_start = time.time()
+
+                # Classify every Nth frame
+                if frame_count % frame_skip == 0:
+                    # Encode frame as JPEG
+                    _, buffer = cv2.imencode(".jpg", frame)
+                    image_bytes = buffer.tobytes()
+
+                    # Classify with timing
+                    classify_start = time.time()
+                    try:
+                        response = self.classify(image_bytes)
+                        last_latency = int((time.time() - classify_start) * 1000)  # ms
+
+                        if response.status_code == 200:
+                            result = response.json()
+                            last_classification = result.get("class", "Unknown")
+                            last_probability = result.get("probability", 0.0)
+                        else:
+                            last_classification = f"Error: {response.status_code}"
+                            last_probability = None
+                    except Exception as e:
+                        last_classification = f"Error: {str(e)}"
+                        last_probability = None
+                        last_latency = int((time.time() - classify_start) * 1000)
+
+                # Draw annotations on frame
+                height, width = frame.shape[:2]
+
+                # Semi-transparent overlay for text background
+                overlay = frame.copy()
+                cv2.rectangle(overlay, (10, 10), (width - 10, 120), (0, 0, 0), -1)
+                frame = cv2.addWeighted(overlay, 0.6, frame, 0.4, 0)
+
+                # Display classification results only if above threshold
+                y_offset = 40
+                if (
+                    last_classification
+                    and last_probability is not None
+                    and last_probability >= probability_threshold
+                ):
+                    cv2.putText(
+                        frame,
+                        f"Class: {last_classification}",
+                        (20, y_offset),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.7,
+                        (0, 255, 0),
+                        2,
+                    )
+                    y_offset += 30
+                    cv2.putText(
+                        frame,
+                        f"Confidence: {last_probability:.2%}",
+                        (20, y_offset),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.7,
+                        (0, 255, 0),
+                        2,
+                    )
+                elif last_classification and last_probability is not None:
+                    # Show low confidence indicator
+                    cv2.putText(
+                        frame,
+                        f"Low confidence ({last_probability:.2%})",
+                        (20, y_offset),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.6,
+                        (100, 100, 100),
+                        2,
+                    )
+                    y_offset += 30
+
+                # Display metrics
+                y_offset += 30
+                cv2.putText(
+                    frame,
+                    f"FPS: {current_fps:.1f} | Latency: {last_latency:.0f}ms",
+                    (20, y_offset),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.6,
+                    (255, 255, 255),
+                    2,
+                )
+
+                # Show frame
+                cv2.imshow(window_name, frame)
+
+                # Check for ESC key or window close
+                if cv2.waitKey(1) & 0xFF == 27:
+                    break
+
+                frame_count += 1
+
+        except KeyboardInterrupt:
+            print("\nStopping video stream...")
+        finally:
+            cap.release()
+            cv2.destroyAllWindows()

{tinesight-0.0.2.dev1 → tinesight-0.0.5.dev1}/src/tinesight/registrar.py

@@ -1,4 +1,3 @@
-import io
 import os
 from http import HTTPStatus
 from pathlib import Path
@@ -10,12 +9,12 @@ from cryptography.hazmat.primitives import serialization
 from cryptography.x509.oid import NameOID
 from pycognito.utils import RequestsSrpAuth, TokenType
 
-from tinesight.api import TinesightApiMixin
+from tinesight._api import TinesightApiMixin
 
 # Cognito configuration - these should be set before using TinesightRegistrar
 # TODO (NP) figure out how to switch between dev and prod
-COGNITO_USER_POOL_ID = os.environ.get("COGNITO_USER_POOL_ID", "us-east-1_g1yNKyU6h")
-COGNITO_CLIENT_ID = os.environ.get("COGNITO_CLIENT_ID", "3255n0uofh58rqqiqhodtqtdp7")
+COGNITO_USER_POOL_ID = os.environ.get("COGNITO_USER_POOL_ID", "us-east-1_mNTHmkVBB")
+COGNITO_CLIENT_ID = os.environ.get("COGNITO_CLIENT_ID", "7e77oj9t00qakod07crel9s82t")
 AWS_REGION = os.environ.get("AWS_REGION", "us-east-1")
 
 
@@ -50,7 +49,7 @@ class TinesightRegistrar(TinesightApiMixin):
         Basic login to using Cognito IDP with the SRP flow. This method is required to be called
         prior to registering any devices.
         """
-        self.auth: RequestsSrpAuth = RequestsSrpAuth(
+        self.auth = RequestsSrpAuth(
             username=username,
             password=password,
             user_pool_id=COGNITO_USER_POOL_ID,
@@ -69,8 +68,27 @@ class TinesightRegistrar(TinesightApiMixin):
             pk_contents, password=key_password.encode() if key_password else None
         )
 
+    def _is_authorized(self) -> bool:
+        if self.auth is None:
+            print("Need to call login prior to invoking any API methods")
+        return self.auth is not None
+
+    def unregister_device(self, device_id: str):
+        """
+        Unregisters a device (idempotent) from your account.
+
+        :param device_id: unique device identifier
+
+        :return: dict
+        """
+        if not self._is_authorized():
+            return None
+        target_url = self.public_ux_api_uri + "/unregister-device/v1"
+        response = requests.post(target_url, json={"device_id": device_id}, auth=self.auth)
+        return response.json()
+
     def register_device(
-        self, device_id: str, pem_key_path: Path, key_password: str = None
+        self, device_id: str, pem_key_path: Path, key_password: str = None, renew: bool = False
     ) -> bytes | None:
         """
         Registers a uniquely identified device for your account by creating a certificate
@@ -87,11 +105,11 @@ class TinesightRegistrar(TinesightApiMixin):
         :param device_id: unique device identifier
         :param pem_key_path: path to your secret key
         :param key_password: str, default None - password to your secret key
+        :param renew: bool, default False - if True, will force a renewal of the certificate
 
-        :return: certificate (str)
+        :return: certificate (bytes)
         """
-        if self.auth is None:
-            print("Need to call login prior to registering a device")
+        if not self._is_authorized():
             return None
 
         key = self._read_private_key(pem_key_path, key_password)
@@ -125,7 +143,7 @@ class TinesightRegistrar(TinesightApiMixin):
         )
 
         # request the signed certificate
-        target_url = self.public_ux_api_uri + "/register-device/v1"
+        target_url = self.public_ux_api_uri + f"/register-device/v1?renew={int(renew)}"
         response = requests.post(
             target_url,
             data=csr.public_bytes(serialization.Encoding.PEM),
@@ -134,5 +152,10 @@ class TinesightRegistrar(TinesightApiMixin):
         if response.status_code == HTTPStatus.OK:
             json_response = response.json()
             return json_response["certificate"].encode("utf-8")
+        elif response.status_code == HTTPStatus.CONFLICT:
+            json_response = response.json()
+            print(json_response["message"])
+            return None
         else:
+            print("Unable to register device")
             return None

tinesight-0.0.2.dev1/src/tinesight/client.py

@@ -1,36 +0,0 @@
-from collections.abc import Callable
-from functools import partial
-from pathlib import Path
-
-import requests
-
-from tinesight.api import TinesightApiMixin
-
-
-class TinesightClient(TinesightApiMixin):
-    """
-    Client for invoking the Tinesight API from a device.
-
-    To use this class, a device must be registered with a signed certificate using the
-    `TinesightRegistrar`.
-
-    Examples:
-        >>> result = TinesightClient(my_key_path, my_cert_path).classify(my_image_bytes)
-        >>> print(result.json)
-        >>> {'class': 'deer', 'probability': 0.98}
-
-    """
-
-    @property
-    def _mtls_post(self) -> Callable:
-        """Private wrapper for making invoking requests with a certa"""
-        return partial(requests.post, cert=(self.cert_path, self.key_path))
-
-    def __init__(self, x509_key_path: Path | str, x509_cert_path: Path | str):
-        self.key_path: str = str(x509_key_path)
-        self.cert_path: str = str(x509_cert_path)
-
-    def classify(self, image_bytes: bytes) -> requests.Response:
-        """Invokes the classification model for the specified image"""
-        classification_url = self.tenant_base_api_uri + "/classify/v1"
-        return self._mtls_post(classification_url, files={"file": image_bytes})