sciveo 0.3.2__tar.gz → 0.3.4__tar.gz

{sciveo-0.3.2 → sciveo-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.3.2
+Version: 0.3.4
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: agent
@@ -2396,6 +2396,19 @@ staging, and `BASE/video` for retained recordings. No separate `tmp`, `video`,
 `motion.src`, or `motion.dst` paths are needed. Camera-specific motion settings
 remain under `motion`.
 
+To keep temporary video I/O in RAM while retaining recordings on those HDD roots,
+set `"temp_path": "/mnt/nvr-ram"` to a separately mounted, size-limited tmpfs.
+Capture, motion processing and upload staging then use `TEMP/tmp2`, `TEMP/tmp3`
+and `TEMP/tmp4`; archives still use the ordered `BASE/video` roots and their
+capacity-based cleanup. The same free-space reserve applies to the temporary
+filesystem, so size it above that reserve plus the expected queued video volume.
+When temporary space runs low, capture waits while processing drains the queues;
+it does not switch temporary writes onto an HDD or delete archives to free RAM.
+Make the NVR service require the tmpfs mount at boot. RAM queues are volatile
+across reboot; finalized HDD archives remain persistent. Existing HDD queues are
+not moved or deleted when changing `temp_path`. Point external uploaders at
+`TEMP/tmp4` when this option is enabled.
+
 Optional per-stage transcoding is disabled unless configured. Put `transcode`
 under `cam.CAMERA` to transcode every completed clip before archival and motion
 processing. Put it under `motion.CAMERA` to transcode **only motion-selected**
@@ -2432,7 +2445,7 @@ processing continues without repeatedly encoding the same failed clip. Storage
 write failures retain the source for retry; no incomplete MP4 enters the uploader
 queue. An all-zero motion grid skips video decoding entirely.
 
-All stages use the first available root in list order, skipping absent, unmounted,
+Stages without a separate `temp_path` use the first available root in list order, skipping absent, unmounted,
 or unwritable roots. Low space does not cause fallback. Free space must cover
 both the incoming clip and the larger of `min_free_bytes` and `min_free_ratio`
 (defaults: 1 GiB and 5%). Capture rechecks
@@ -2473,7 +2486,7 @@ With no usable root, capture waits and queued files are retained until storage
 recovers. This provides fallback, not replication: clips already on a disconnected
 disk become available again when that disk returns.
 
-External uploaders must watch `BASE/tmp4` on **every** configured root, including
+Without `temp_path`, external uploaders must watch `BASE/tmp4` on **every** configured root, including
 roots that recover after startup. Existing queued files are not relocated when
 migrating configurations. Legacy single-directory `path.tmp`, `path.video`,
 `motion.src`, and `motion.dst` configurations remain supported when `paths` is

sciveo-0.3.2/sciveo.egg-info/PKG-INFO → sciveo-0.3.4/README.md

@@ -1,28 +1,3 @@
-Metadata-Version: 2.1
-Name: sciveo
-Version: 0.3.2
-Description-Content-Type: text/markdown
-Provides-Extra: mon
-Provides-Extra: agent
-Provides-Extra: agent-local
-Provides-Extra: net
-Provides-Extra: server
-Provides-Extra: storage
-Provides-Extra: storage-postgres
-Provides-Extra: chat
-Provides-Extra: media
-Provides-Extra: media-ml
-Provides-Extra: sciveyolo
-Provides-Extra: sciveyolo-gpu
-Provides-Extra: sciveyolo-trt
-Provides-Extra: web
-Provides-Extra: db
-Provides-Extra: power
-Provides-Extra: industrial
-Provides-Extra: energy
-Provides-Extra: all
-Provides-Extra: ml
-
 # SCIVEO
 
 Sciveo is a Python toolkit and CLI for ML/AI workflows, engineering automation,
@@ -2396,6 +2371,19 @@ staging, and `BASE/video` for retained recordings. No separate `tmp`, `video`,
 `motion.src`, or `motion.dst` paths are needed. Camera-specific motion settings
 remain under `motion`.
 
+To keep temporary video I/O in RAM while retaining recordings on those HDD roots,
+set `"temp_path": "/mnt/nvr-ram"` to a separately mounted, size-limited tmpfs.
+Capture, motion processing and upload staging then use `TEMP/tmp2`, `TEMP/tmp3`
+and `TEMP/tmp4`; archives still use the ordered `BASE/video` roots and their
+capacity-based cleanup. The same free-space reserve applies to the temporary
+filesystem, so size it above that reserve plus the expected queued video volume.
+When temporary space runs low, capture waits while processing drains the queues;
+it does not switch temporary writes onto an HDD or delete archives to free RAM.
+Make the NVR service require the tmpfs mount at boot. RAM queues are volatile
+across reboot; finalized HDD archives remain persistent. Existing HDD queues are
+not moved or deleted when changing `temp_path`. Point external uploaders at
+`TEMP/tmp4` when this option is enabled.
+
 Optional per-stage transcoding is disabled unless configured. Put `transcode`
 under `cam.CAMERA` to transcode every completed clip before archival and motion
 processing. Put it under `motion.CAMERA` to transcode **only motion-selected**
@@ -2432,7 +2420,7 @@ processing continues without repeatedly encoding the same failed clip. Storage
 write failures retain the source for retry; no incomplete MP4 enters the uploader
 queue. An all-zero motion grid skips video decoding entirely.
 
-All stages use the first available root in list order, skipping absent, unmounted,
+Stages without a separate `temp_path` use the first available root in list order, skipping absent, unmounted,
 or unwritable roots. Low space does not cause fallback. Free space must cover
 both the incoming clip and the larger of `min_free_bytes` and `min_free_ratio`
 (defaults: 1 GiB and 5%). Capture rechecks
@@ -2473,7 +2461,7 @@ With no usable root, capture waits and queued files are retained until storage
 recovers. This provides fallback, not replication: clips already on a disconnected
 disk become available again when that disk returns.
 
-External uploaders must watch `BASE/tmp4` on **every** configured root, including
+Without `temp_path`, external uploaders must watch `BASE/tmp4` on **every** configured root, including
 roots that recover after startup. Existing queued files are not relocated when
 migrating configurations. Legacy single-directory `path.tmp`, `path.video`,
 `motion.src`, and `motion.dst` configurations remain supported when `paths` is

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/network/sniff/terminal.py

@@ -280,7 +280,7 @@ class CameraDashboard:
 
   @staticmethod
   def selection_marker(record):
-    return {'rtsp': '▶', 'file': '▣', 'sniff': '◉'}.get(record.get('source_kind'), '>')
+    return {'rtsp': '▶', 'file': '▷', 'sniff': '»'}.get(record.get('source_kind'), '>')
 
   @staticmethod
   def label(record):

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/storage/config.py

@@ -97,6 +97,8 @@ class StorageConfig:
     self.iam = dict(iam or {})
     self.iam_base_path = os.path.abspath(os.path.expanduser(str(iam_base_path))) if iam_base_path else None
     self.http = self._normalize_http_config(http)
+    if not 0 <= self.http["max_downloads"] < self.threads:
+      raise ValueError("Storage http.max_downloads must be zero (unlimited) or smaller than threads")
     self.limits = dict(limits or {})
     self.retention = dict(retention or {})
     if self.resume_free_ratio < self.min_free_ratio:
@@ -406,6 +408,7 @@ class StorageConfig:
       "read_timeout": max(1.0, float(value.get("read_timeout") or min(timeout, 120))),
       "lock_timeout": max(0.1, float(value.get("lock_timeout") or 30)),
       "keepalive": max(1, int(value.get("keepalive") or 65)),
+      "max_downloads": int(value.get("max_downloads") or 0),
     }
 
   def db_label(self):

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/storage/filesystem.py

@@ -9,6 +9,7 @@
 # 2026
 #
 
+import contextlib
 import errno
 import hashlib
 import json
@@ -40,6 +41,14 @@ class StorageSizeExceeded(StoragePathError):
   pass
 
 
+class StorageUploadNotFound(StoragePathError):
+  pass
+
+
+class StoragePartNotFound(StoragePathError):
+  pass
+
+
 class StorageRequestBodyError(StoragePathError):
   def __init__(self, message, bytes_read=0, expected_size=None):
     super().__init__(message)
@@ -52,6 +61,7 @@ class StoragePathMapper:
   MARKER_FILE_NAME = ".sciveo-s3-prefix-marker"
   ROOT_IDENTITY_FILE = ".sciveo-storage-root.json"
   MUTATION_DIRECTORY = "mutations"
+  UNHEALTHY_RECHECK_INTERVAL = 30.0
 
   @classmethod
   def from_config(cls, config, metadata, namespace="sciveo-s3"):
@@ -1178,6 +1188,8 @@ class StoragePathMapper:
     with self.health_lock:
       state = dict(self.root_health[root_index])
     interval = max(0.0, self.health_check_interval)
+    if not state["healthy"]:
+      interval = min(interval, self.UNHEALTHY_RECHECK_INTERVAL)
     if not force and state["healthy"] and interval <= 0:
       return
     if not force and time.time() - float(state.get("last_checked") or 0.0) < interval:
@@ -1288,7 +1300,7 @@ class StoragePathMapper:
 
   def health_monitor_loop(self):
     intervals = [value for value in (self.health_check_interval, self.capacity_check_interval) if value > 0]
-    interval = max(1.0, min(intervals))
+    interval = max(1.0, min(min(intervals), self.UNHEALTHY_RECHECK_INTERVAL))
     while not self.health_stop.wait(interval):
       try:
         self.refresh_unhealthy_roots(force=False)
@@ -1332,8 +1344,7 @@ class StoragePathMapper:
       candidate = os.path.join(self.base_path(path), "multipart", safe_upload_id)
       if os.path.exists(candidate):
         return candidate
-    root_index = self.writable_root_indices()[0]
-    return os.path.join(self.base_path(self.paths[root_index]), "multipart", safe_upload_id)
+    return os.path.join(self.base_path(self.paths[0]), "multipart", safe_upload_id)
 
   def create_multipart_upload(self, bucket, key, storage_class="STANDARD", content_type=None, metadata=None, tags=None):
     bucket = self.validate_bucket(bucket)
@@ -1367,8 +1378,27 @@ class StoragePathMapper:
     raise StoragePathUnavailable(f"No writable storage paths are available for multipart upload: {last_error}")
 
   def multipart_upload_info(self, upload_id):
-    with open(os.path.join(self.multipart_root(upload_id), "source"), "r") as fp:
-      return json.load(fp)
+    last_error = None
+    for root_index in range(len(self.paths)):
+      try:
+        with open(os.path.join(self.multipart_root(upload_id, root_index=root_index), "source"), "r") as fp:
+          return json.load(fp)
+      except FileNotFoundError:
+        continue
+      except OSError as error:
+        last_error = self.write_error(root_index, error)
+    if last_error is not None:
+      raise last_error
+    for root_index in range(len(self.paths)):
+      self.assert_root_present(root_index)
+    raise StorageUploadNotFound("Multipart upload does not exist")
+
+  def missing_multipart_file(self, upload_id, root_index):
+    # An abort may remove staging files while a part is still streaming.
+    # Verify the actual disk before classifying this as an upload-level error.
+    self.assert_root_present(root_index)
+    self.multipart_upload_info(upload_id)
+    return StoragePartNotFound("Multipart part does not exist")
 
   def multipart_root_index(self, upload_id):
     info = self.multipart_upload_info(upload_id)
@@ -1393,7 +1423,8 @@ class StoragePathMapper:
       source,
       chunk_size=1024 * 1024,
       expected_size=None,
-      max_size=None):
+      max_size=None,
+      publish_lock=None):
     root_index = self.multipart_root_index(upload_id)
     expected_size = max(0, int(expected_size or 0))
     max_size = None if max_size is None else max(0, int(max_size))
@@ -1404,7 +1435,6 @@ class StoragePathMapper:
     size = 0
     tmp_path = None
     try:
-      os.makedirs(os.path.dirname(path), exist_ok=True)
       fd, tmp_path = tempfile.mkstemp(prefix=".part-", dir=os.path.dirname(path))
       with os.fdopen(fd, "wb") as fp:
         self.preallocate(fp, expected_size)
@@ -1420,8 +1450,14 @@ class StoragePathMapper:
         fp.truncate(size)
         fp.flush()
         os.fsync(fp.fileno())
-      os.replace(tmp_path, path)
-      self.fsync_directory(os.path.dirname(path))
+      # Keep streaming abortable; serialize only publication with completion/abort.
+      with publish_lock or contextlib.nullcontext():
+        self.multipart_upload_info(upload_id)
+        os.replace(tmp_path, path)
+        self.fsync_directory(os.path.dirname(path))
+        etag = self.stat_etag(os.stat(path))
+    except FileNotFoundError as e:
+      raise self.missing_multipart_file(upload_id, root_index) from e
     except OSError as e:
       raise self.write_error(root_index, e, source_consumed=size > 0) from e
     finally:
@@ -1430,13 +1466,22 @@ class StoragePathMapper:
           os.unlink(tmp_path)
         except OSError:
           pass
-    return path, size, self.stat_etag(os.stat(path))
+    return path, size, etag
 
   def multipart_size(self, upload_id, part_numbers):
-    return sum(os.path.getsize(self.multipart_part_path(upload_id, part_number)) for part_number in part_numbers)
+    return sum(self.multipart_part_stat(upload_id, part_number).st_size for part_number in part_numbers)
 
   def multipart_part_etag(self, upload_id, part_number):
-    return self.stat_etag(os.stat(self.multipart_part_path(upload_id, part_number)))
+    return self.stat_etag(self.multipart_part_stat(upload_id, part_number))
+
+  def multipart_part_stat(self, upload_id, part_number):
+    root_index = self.multipart_root_index(upload_id)
+    try:
+      return os.stat(self.multipart_part_path(upload_id, part_number))
+    except FileNotFoundError as error:
+      raise self.missing_multipart_file(upload_id, root_index) from error
+    except OSError as error:
+      raise self.write_error(root_index, error) from error
 
   def list_multipart_uploads(self, bucket=None, prefix=""):
     uploads = []
@@ -1505,8 +1550,6 @@ class StoragePathMapper:
         self.preallocate(output, expected_size)
         for part_number in part_numbers:
           part_path = self.multipart_part_path(upload_id, part_number)
-          if not os.path.exists(part_path):
-            raise StoragePathError(f"Missing multipart part: {part_number}")
           with open(part_path, "rb") as part:
             while True:
               chunk = part.read(chunk_size)
@@ -1519,6 +1562,9 @@ class StoragePathMapper:
         os.fsync(output.fileno())
       os.replace(tmp_path, path)
       self.fsync_directory(directory)
+    except FileNotFoundError as e:
+      self.assert_root_present(root_index)
+      raise self.missing_multipart_file(upload_id, multipart_root_index) from e
     except OSError as e:
       raise self.write_error(root_index, e, source_consumed=False) from e
     finally:
@@ -1540,7 +1586,10 @@ class StoragePathMapper:
       return
     for dirpath, dirnames, filenames in os.walk(root, topdown=False):
       for filename in filenames:
-        os.unlink(os.path.join(dirpath, filename))
+        try:
+          os.unlink(os.path.join(dirpath, filename))
+        except FileNotFoundError:
+          pass
       for dirname in dirnames:
         os.rmdir(os.path.join(dirpath, dirname))
     os.rmdir(root)

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/storage/server.py

@@ -18,6 +18,7 @@ import json
 import mimetypes
 import os
 import sys
+import threading
 import uuid
 import zlib
 import xml.etree.ElementTree as ET
@@ -35,6 +36,8 @@ from sciveo.storage.filesystem import (
   StoragePathError,
   StoragePathMapper,
   StoragePathUnavailable,
+  StorageUploadNotFound,
+  StoragePartNotFound,
   StorageRequestBodyError,
   StorageSizeExceeded,
 )
@@ -235,11 +238,59 @@ class TimedInputStream:
     return getattr(self.source, name)
 
 
+class StorageDownloadSlot:
+  """Hold admission until the WSGI server finishes or closes a download."""
+
+  def __init__(self, slots, close_body):
+    self.slots, self.close_body = slots, close_body
+
+  @classmethod
+  def wrap(cls, body, slots, file_wrapper):
+    slot = cls(slots, getattr(body, "close", None))
+    if isinstance(file_wrapper, type) and isinstance(body, file_wrapper):
+      # Gunicorn dispatches to sendfile by checking the response iterable's type.
+      try:
+        body.close = slot.close
+      except (AttributeError, TypeError):
+        pass
+      else:
+        return body
+    return StorageDownloadIterator(body, slot.close)
+
+  def close(self):
+    if self.slots is None:
+      return
+    slots, self.slots = self.slots, None
+    close_body, self.close_body = self.close_body, None
+    try:
+      if close_body is not None:
+        close_body()
+    finally:
+      slots.release()
+
+
+class StorageDownloadIterator:
+  def __init__(self, body, close):
+    self.iterator, self.close = iter(body), close
+
+  def __iter__(self):
+    return self
+
+  def __next__(self):
+    try:
+      return next(self.iterator)
+    except BaseException:
+      self.close()
+      raise
+
+
 class S3StorageService:
   XMLNS = "http://s3.amazonaws.com/doc/2006-03-01/"
 
   def __init__(self, config):
     self.config = config
+    maximum = config.http.get("max_downloads", 0)
+    self.download_slots = threading.BoundedSemaphore(maximum) if maximum else None
     self.config.validate_server_credentials()
     self.metadata = StorageMetadata.from_config(config)
     self.mapper = StoragePathMapper.from_config(config, self.metadata)
@@ -627,7 +678,7 @@ class S3StorageService:
     if max_size is not None:
       part_options["max_size"] = max_size
     _, _, etag = self.mapper.write_multipart_part(
-      upload_id, part_number, self.request_body_stream(), **part_options)
+      upload_id, part_number, self.request_body_stream(), publish_lock=self.mutations.object(bucket, key), **part_options)
     return Response("", status=200, headers={"ETag": f"\"{etag}\""})
 
   def complete_multipart_upload(self, bucket, key):
@@ -635,11 +686,12 @@ class S3StorageService:
     self.mapper.assert_multipart_source(upload_id, bucket, key)
     parts = self.complete_parts(self.request_data_verified())
     part_numbers = [part["part_number"] for part in parts]
-    for part in parts:
-      actual = self.mapper.multipart_part_etag(upload_id, part["part_number"])
-      if part["etag"] and part["etag"] != actual:
-        return self.error("InvalidPart", "Multipart part ETag does not match", 400)
     with self.mutations.write(bucket, key, serialize_bucket=self.policy.has_quota(bucket)):
+      upload_info = self.mapper.assert_multipart_source(upload_id, bucket, key)
+      for part in parts:
+        actual = self.mapper.multipart_part_etag(upload_id, part["part_number"])
+        if part["etag"] and part["etag"] != actual:
+          return self.error("InvalidPart", "Multipart part ETag does not match", 400)
       self.mutation_journal.recover_identity_locked(bucket, key)
       existing = self.metadata.get_object(bucket, key)
       self.policy.validate_overwrite(
@@ -648,13 +700,12 @@ class S3StorageService:
       write_state = {}
       root_index, path, size, etag = self.complete_multipart_upload_file(
         bucket, key, upload_id, part_numbers, existing=existing, write_state=write_state)
-      upload_info = self.mapper.multipart_upload_info(upload_id)
       content_type = upload_info.get("content_type") or request.headers.get("Content-Type")
       storage_class = self.storage_class_from_headers(default=upload_info.get("storage_class") or "STANDARD")
       obj = self.put_object_metadata_after_write(
         bucket, key, root_index, path, size, etag, content_type, dict(upload_info.get("metadata") or {}),
         storage_class=storage_class, existing=existing, write_state=write_state, tags=upload_info.get("tags"))
-    self.mapper.cleanup_multipart(upload_id)
+      self.mapper.cleanup_multipart(upload_id)
     self.record_operation("multipart_complete", bucket=bucket, root_index=root_index, bytes=size)
 
     body = [
@@ -671,8 +722,9 @@ class S3StorageService:
     self.mapper.validate_bucket(bucket)
     self.mapper.validate_key(key)
     upload_id = request.args.get("uploadId")
-    self.mapper.assert_multipart_source(upload_id, bucket, key)
-    self.mapper.cleanup_multipart(upload_id)
+    with self.mutations.object(bucket, key):
+      self.mapper.assert_multipart_source(upload_id, bucket, key)
+      self.mapper.cleanup_multipart(upload_id)
     return Response("", status=204)
 
   def list_multipart_uploads(self, bucket):
@@ -722,6 +774,25 @@ class S3StorageService:
     return self.xml(body)
 
   def get_object(self, bucket, key):
+    if self.download_slots is None:
+      return self.get_object_response(bucket, key)
+    if not self.download_slots.acquire(blocking=False):
+      self.record_failure("failure_download_limit")
+      response = self.error("SlowDown", "Concurrent download limit reached; retry later", 503)
+      response.headers["Retry-After"] = "1"
+      return response
+    try:
+      response = self.get_object_response(bucket, key)
+      if response.status_code in (200, 206):
+        response.response = StorageDownloadSlot.wrap(response.response, self.download_slots, request.environ.get("wsgi.file_wrapper"))
+        return response
+    except BaseException:
+      self.download_slots.release()
+      raise
+    self.download_slots.release()
+    return response
+
+  def get_object_response(self, bucket, key):
     with self.mutations.object(bucket, key):
       obj = self.committed_object(bucket, key)
       if obj is None:
@@ -1813,6 +1884,12 @@ class S3StorageService:
     except StoragePolicyError as e:
       self.record_failure("failure_policy")
       return self.error("PolicyDenied", str(e), 409)
+    except StorageUploadNotFound as e:
+      self.record_failure("failure_no_such_upload")
+      return self.error("NoSuchUpload", str(e), 404)
+    except StoragePartNotFound as e:
+      self.record_failure("failure_invalid_part")
+      return self.error("InvalidPart", str(e), 400)
     except StoragePathError as e:
       self.record_failure("failure_invalid_argument")
       return self.error("InvalidArgument", str(e), 400)

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/tools/defaults.py

@@ -124,6 +124,8 @@ class CLIOptions:
     for word in argv:
       if word.startswith("-"):
         option = self.parser._parse_optional(word)
+        if isinstance(option, list):  # Python 3.12.11+ returns a list of matches.
+          option = option[0] if len(option) == 1 else None
         if option and option[0] is not None:
           explicit.add(option[0].dest)
     command = "sniff" if args.command == "sniffer" else args.command

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo/version.py

@@ -9,4 +9,4 @@
 # 2026
 #
 
-__version__ = '0.3.2'
+__version__ = '0.3.4'

sciveo-0.3.2/README.md → sciveo-0.3.4/sciveo.egg-info/PKG-INFO

@@ -1,3 +1,28 @@
+Metadata-Version: 2.1
+Name: sciveo
+Version: 0.3.4
+Description-Content-Type: text/markdown
+Provides-Extra: mon
+Provides-Extra: agent
+Provides-Extra: agent-local
+Provides-Extra: net
+Provides-Extra: server
+Provides-Extra: storage
+Provides-Extra: storage-postgres
+Provides-Extra: chat
+Provides-Extra: media
+Provides-Extra: media-ml
+Provides-Extra: sciveyolo
+Provides-Extra: sciveyolo-gpu
+Provides-Extra: sciveyolo-trt
+Provides-Extra: web
+Provides-Extra: db
+Provides-Extra: power
+Provides-Extra: industrial
+Provides-Extra: energy
+Provides-Extra: all
+Provides-Extra: ml
+
 # SCIVEO
 
 Sciveo is a Python toolkit and CLI for ML/AI workflows, engineering automation,
@@ -2371,6 +2396,19 @@ staging, and `BASE/video` for retained recordings. No separate `tmp`, `video`,
 `motion.src`, or `motion.dst` paths are needed. Camera-specific motion settings
 remain under `motion`.
 
+To keep temporary video I/O in RAM while retaining recordings on those HDD roots,
+set `"temp_path": "/mnt/nvr-ram"` to a separately mounted, size-limited tmpfs.
+Capture, motion processing and upload staging then use `TEMP/tmp2`, `TEMP/tmp3`
+and `TEMP/tmp4`; archives still use the ordered `BASE/video` roots and their
+capacity-based cleanup. The same free-space reserve applies to the temporary
+filesystem, so size it above that reserve plus the expected queued video volume.
+When temporary space runs low, capture waits while processing drains the queues;
+it does not switch temporary writes onto an HDD or delete archives to free RAM.
+Make the NVR service require the tmpfs mount at boot. RAM queues are volatile
+across reboot; finalized HDD archives remain persistent. Existing HDD queues are
+not moved or deleted when changing `temp_path`. Point external uploaders at
+`TEMP/tmp4` when this option is enabled.
+
 Optional per-stage transcoding is disabled unless configured. Put `transcode`
 under `cam.CAMERA` to transcode every completed clip before archival and motion
 processing. Put it under `motion.CAMERA` to transcode **only motion-selected**
@@ -2407,7 +2445,7 @@ processing continues without repeatedly encoding the same failed clip. Storage
 write failures retain the source for retry; no incomplete MP4 enters the uploader
 queue. An all-zero motion grid skips video decoding entirely.
 
-All stages use the first available root in list order, skipping absent, unmounted,
+Stages without a separate `temp_path` use the first available root in list order, skipping absent, unmounted,
 or unwritable roots. Low space does not cause fallback. Free space must cover
 both the incoming clip and the larger of `min_free_bytes` and `min_free_ratio`
 (defaults: 1 GiB and 5%). Capture rechecks
@@ -2448,7 +2486,7 @@ With no usable root, capture waits and queued files are retained until storage
 recovers. This provides fallback, not replication: clips already on a disconnected
 disk become available again when that disk returns.
 
-External uploaders must watch `BASE/tmp4` on **every** configured root, including
+Without `temp_path`, external uploaders must watch `BASE/tmp4` on **every** configured root, including
 roots that recover after startup. Existing queued files are not relocated when
 migrating configurations. Legacy single-directory `path.tmp`, `path.video`,
 `motion.src`, and `motion.dst` configurations remain supported when `paths` is

{sciveo-0.3.2 → sciveo-0.3.4}/sciveo.egg-info/SOURCES.txt

@@ -458,6 +458,7 @@ test/test_chint_dtsu666_catalog.py
 test/test_cli_defaults.py
 test/test_cli_delegation.py
 test/test_cli_modules.py
+test/test_cli_regression.py
 test/test_cli_themes.py
 test/test_complexity.py
 test/test_compress.py
@@ -523,6 +524,7 @@ test/test_storage.py
 test/test_storage_auth_hardening.py
 test/test_storage_cluster.py
 test/test_storage_cors.py
+test/test_storage_downloads.py
 test/test_storage_iam.py
 test/test_storage_iam_users.py
 test/test_storage_metadata_hardening.py

{sciveo-0.3.2 → sciveo-0.3.4}/test/test_cli_defaults.py

@@ -54,6 +54,24 @@ class TestCLIOptions(unittest.TestCase):
     args, _ = self.arguments("scan")
     self.assertEqual((args.timeout, args.theme), (2, "light"))
 
+  def test_explicit_options_support_old_and_new_argparse_results(self):
+    self.preferences.update({"scan.port": "22", "timeout": "7", "local-echo": "false", "theme": "amber"})
+    options = self.definitions(self.preferences)
+    argv = ["scan", "--port", "502", "--timeo=-2", "--handle-local-echo"]
+    matches = [(options.actions["port"], "--port", None, None),
+               (options.actions["timeout"], "--timeout", "=", "-2"),
+               (options.actions["local-echo"], "--handle-local-echo", None, None)]
+    for result_type in ("tuple", "list"):
+      with self.subTest(result_type=result_type):
+        args = options.parser.parse_args(argv)
+        results = [(action, name, value) for action, name, _, value in matches]
+        if result_type == "list":
+          results = [[match] for match in matches]
+        with patch.object(options.parser, "_parse_optional", side_effect=results):
+          applied = options.apply(args, argv)
+        self.assertEqual((args.port, args.timeout, args.handle_local_echo, args.theme), (502, -2, True, "amber"))
+        self.assertEqual(applied, {"theme"})
+
   def test_camera_expiry_global_command_and_explicit_precedence(self):
     options = self.definitions()
     for command in ("sniff", "nvr", "rtsp"):