app size optimization enhancements

- Add an explicit artifact check that fails if any .onnx file is still bundled.
- Use from __future__ import annotations for Python <3.9 compatibility.
- DELETE /{model_key} delete guard against active sessions.
- De-duplication for concurrent /setup or /download/{model_key} for the same model.
- SSE heartbeat interval.
- Nested HTTP streams on 416 raise_for_status() ordering.
- Fix divide-by-zero edge case.

Author: rohan-pandeyy

.github/workflows/build-and-release.yml

@@ -34,6 +34,16 @@ jobs:
           cd backend
           pyinstaller PictoPy.spec
 
+      - name: Verify no .onnx artifacts
+        shell: pwsh
+        run: |
+          $onnxFiles = Get-ChildItem -Path "backend/dist/PictoPy_Server" -Recurse -Filter "*.onnx" -File
+          if ($onnxFiles) {
+            Write-Error "Found bundled .onnx artifacts in backend/dist/PictoPy_Server:"
+            $onnxFiles | ForEach-Object { Write-Error $_.FullName }
+            exit 1
+          }
+
       - name: Create ZIP package
         run: |
           cd backend/dist/PictoPy_Server
@@ -69,6 +79,16 @@ jobs:
           cd backend
           pyinstaller PictoPy.spec
 
+      - name: Verify no .onnx artifacts
+        shell: bash
+        run: |
+          onnx_files=$(find backend/dist/PictoPy_Server -type f -name "*.onnx")
+          if [ -n "$onnx_files" ]; then
+            echo "Found bundled .onnx artifacts in backend/dist/PictoPy_Server:"
+            echo "$onnx_files"
+            exit 1
+          fi
+
       - name: Create ZIP package
         run: |
           cd backend/dist/PictoPy_Server
@@ -102,6 +122,16 @@ jobs:
           cd backend
           pyinstaller PictoPy.spec
 
+      - name: Verify no .onnx artifacts
+        shell: bash
+        run: |
+          onnx_files=$(find backend/dist/PictoPy_Server -type f -name "*.onnx")
+          if [ -n "$onnx_files" ]; then
+            echo "Found bundled .onnx artifacts in backend/dist/PictoPy_Server:"
+            echo "$onnx_files"
+            exit 1
+          fi
+
       - name: Create ZIP package
         run: |
           cd backend/dist/PictoPy_Server

backend/PictoPy.spec

@@ -16,8 +16,6 @@ a = Analysis(
     noarchive=False,
 )
 
-# Filter out models from the build in case any linger in the development directory
-# We ensure the distribution bundle remains lightweight.
 def exclude_models(datas):
     filtered_datas = []
     for data in datas:

backend/app/models/FaceNet.py

@@ -1,7 +1,13 @@
+from __future__ import annotations
+
 import os
 import threading
 import onnxruntime
-from app.models.model_registry import MODEL_REGISTRY
+from app.models.model_registry import MODEL_REGISTRY, get_model_key_from_path
+from app.models.session_registry import (
+    mark_model_session_active,
+    mark_model_session_inactive,
+)
 from app.utils.FaceNet import FaceNet_util_normalize_embedding
 from app.utils.ONNX import ONNX_util_get_execution_providers
 from app.logging.setup_logging import get_logger
@@ -12,14 +18,14 @@
 class FaceNet:
     def __init__(self, model_path):
         self.model_path = model_path
+        self._model_key = get_model_key_from_path(model_path)
+        self._session_registered = False
         self._session: onnxruntime.InferenceSession | None = None
         self.input_tensor_name: str | None = None
         self.output_tensor_name: str | None = None
         self._lock = threading.Lock()
 
     def get_session(self) -> onnxruntime.InferenceSession:
-        # Fast path: capture reference before returning so close() on another
-        # thread between the check and the return cannot cause a None return.
         session = self._session
         if session is not None:
             return session
@@ -43,11 +49,12 @@ def get_session(self) -> onnxruntime.InferenceSession:
                 self._session = onnxruntime.InferenceSession(
                     self.model_path, providers=ONNX_util_get_execution_providers()
                 )
+                if self._model_key is not None and not self._session_registered:
+                    mark_model_session_active(self._model_key)
+                    self._session_registered = True
                 self.input_tensor_name = self._session.get_inputs()[0].name
                 self.output_tensor_name = self._session.get_outputs()[0].name
 
-            # Capture inside the lock before releasing — prevents close() on
-            # another thread from nulling _session between lock release and return.
             session = self._session
 
         return session
@@ -66,4 +73,13 @@ def close(self):
                 self._session = None
                 self.input_tensor_name = None
                 self.output_tensor_name = None
+                if self._model_key is not None and self._session_registered:
+                    mark_model_session_inactive(self._model_key)
+                    self._session_registered = False
                 logger.info("FaceNet model session closed.")
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass

backend/app/models/ObjectClassifier.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import cv2
 from app.models.YOLO import YOLO
 from app.utils.YOLO import YOLO_util_get_model_path

backend/app/models/YOLO.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
 import onnxruntime
 import time
 import cv2
 import numpy as np
+from app.models.model_registry import MODEL_REGISTRY, get_model_key_from_path
+from app.models.session_registry import (
+    mark_model_session_active,
+    mark_model_session_inactive,
+)
 from app.utils.YOLO import (
     YOLO_util_xywh2xyxy,
     YOLO_util_draw_detections,
@@ -17,6 +24,8 @@
 class YOLO:
     def __init__(self, path, conf_threshold=0.7, iou_threshold=0.5):
         self.model_path = path
+        self._model_key = get_model_key_from_path(path)
+        self._session_registered = False
         self.conf_threshold = conf_threshold
         self.iou_threshold = iou_threshold
         self._session = None
@@ -31,7 +40,6 @@ def get_session(self):
         with self._lock:
             if self._session is None:
                 import os
-                from app.models.model_registry import MODEL_REGISTRY
 
                 if not os.path.exists(self.model_path):
                     model_key = None
@@ -48,6 +56,9 @@ def get_session(self):
                 self._session = onnxruntime.InferenceSession(
                     self.model_path, providers=ONNX_util_get_execution_providers()
                 )
+                if self._model_key is not None and not self._session_registered:
+                    mark_model_session_active(self._model_key)
+                    self._session_registered = True
                 # Initialize model info once session is created
                 self.get_input_details()
                 self.get_output_details()
@@ -61,8 +72,17 @@ def close(self):
         with self._lock:
             if self._session is not None:
                 self._session = None
+                if self._model_key is not None and self._session_registered:
+                    mark_model_session_inactive(self._model_key)
+                    self._session_registered = False
         logger.info("YOLO model session closed.")
 
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
     @log_memory_usage
     def detect_objects(self, image):
         session = self.get_session()

backend/app/models/model_registry.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import TypedDict, Literal
 import json
 import os
@@ -106,3 +108,11 @@ def get_model_path(key: str) -> str:
     # In development, strictly use the local repo folder
     return os.path.normpath(os.path.join(LOCAL_ONNX_EXPORTS, filename))
 
+
+def get_model_key_from_path(model_path: str) -> str | None:
+    target_filename = os.path.basename(os.path.normpath(model_path)).lower()
+    for key, spec in MODEL_REGISTRY.items():
+        if spec["filename"].lower() == target_filename:
+            return key
+    return None
+

backend/app/models/session_registry.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import threading
+
+_active_sessions: dict[str, int] = {}
+_registry_lock = threading.Lock()
+
+
+def mark_model_session_active(model_key: str) -> None:
+    with _registry_lock:
+        _active_sessions[model_key] = _active_sessions.get(model_key, 0) + 1
+
+
+def mark_model_session_inactive(model_key: str) -> None:
+    with _registry_lock:
+        count = _active_sessions.get(model_key, 0)
+        if count <= 1:
+            _active_sessions.pop(model_key, None)
+            return
+        _active_sessions[model_key] = count - 1
+
+
+def get_active_session_count(model_key: str) -> int:
+    with _registry_lock:
+        return _active_sessions.get(model_key, 0)