sciveo 0.1.66__tar.gz → 0.1.68__tar.gz

{sciveo-0.1.66 → sciveo-0.1.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.66
+Version: 0.1.68
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

sciveo-0.1.68/sciveo/media/capture/motion_detection.py

@@ -0,0 +1,139 @@
+#
+# Stanislav Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact s.georgiev@softel.bg.
+#
+# 2025
+#
+
+import time
+import os
+import shutil
+import cv2
+import numpy as np
+
+from sciveo.tools.logger import *
+from sciveo.tools.daemon import DaemonBase
+from sciveo.media.capture.readers import VideoReaderFFMPEG
+from sciveo.tools.queue import TouchedFilePathQueue
+
+
+class MotionDetectorGrid:
+  def __init__(self, grid):
+    self.grid = np.array(grid)
+    self.grid_mask = None
+    self.zero = False
+
+  def init_grid(self, frame):
+    self.grid_mask = np.zeros_like(frame, dtype=np.float32)
+
+    for i in range(0, self.grid_mask.shape[0]):
+      for j in range(0, self.grid_mask.shape[1]):
+        gi = int(self.grid.shape[0] * i / self.grid_mask.shape[0])
+        gj = int(self.grid.shape[1] * j / self.grid_mask.shape[1])
+
+        self.grid_mask[i][j] = self.grid[gi][gj]
+
+    self.zero = self.grid_mask.sum() <= 0.0
+
+  def apply(self, frame):
+    if self.grid_mask is None:
+      self.init_grid(frame)
+    result = (frame * self.grid_mask).astype(np.uint8)
+    return result
+
+
+class VideoMotionDetector:
+  def __init__(self, source_id, configuration):
+    super().__init__()
+    self.source_id = source_id
+    self.configuration = configuration
+    self.count_motion_hold = 0
+    self.detection_grid = MotionDetectorGrid(self.configuration["grid"])
+
+    self.init()
+
+  def init(self):
+    self.fgbg = cv2.createBackgroundSubtractorMOG2(history=50, varThreshold=20, detectShadows=False)
+
+  def apply(self, frame):
+    md_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    md_frame = cv2.blur(src=md_frame, ksize=(10,10))
+    md_frame = self.fgbg.apply(md_frame)
+    md_frame = self.detection_grid.apply(md_frame)
+    return md_frame
+
+  def check_motion(self, fgmask):
+    k_motion_level = 0.5 + 0.5 * min(self.configuration["threshold_motion_hold"], self.count_motion_hold) / self.configuration["threshold_motion_hold"]
+    current_threshold = self.configuration["threshold_motion"] * k_motion_level
+    motion_level = np.mean(fgmask)
+
+    if motion_level > current_threshold:
+      self.count_motion_hold += 1
+      if self.count_motion_hold >= self.configuration["threshold_motion_hold"]:
+        debug(self.source_id, "motion detected", motion_level, "threshold", current_threshold)
+        return True
+    else:
+      self.count_motion_hold = 0
+    return False
+
+  def __call__(self, list_frames):
+    self.count_motion_hold = 0
+
+    for frame in list_frames:
+      try:
+        if self.detection_grid.zero:
+          continue
+
+        fgmask = self.apply(frame)
+
+        if self.check_motion(fgmask):
+          return True
+      except Exception as e:
+        exception(e)
+        time.sleep(3)
+
+    return False
+
+
+class MotionDetectorDaemon(DaemonBase):
+  def __init__(self, configuration):
+    super().__init__()
+    self.configuration = configuration
+    self.queue = TouchedFilePathQueue(self.configuration["src"], period=3, touched_timeout=3)
+    self.motion_detectors = {}
+
+  def on_motion(self, source_id, file_name, file_path, configuration):
+    debug("MOTION", source_id, file_name, configuration)
+    if "dst" in self.configuration:
+      dst_file_path = os.path.join(self.configuration["dst"], file_name)
+      shutil.copy(file_path, dst_file_path)
+      debug("CP", file_path, "=>", dst_file_path)
+
+  def run(self):
+    while(self.is_running):
+      try:
+        file_name, file_path = self.queue.pop()
+        debug("pop", file_name, file_path)
+
+        file_name_split = file_name.split("___")
+        if len(file_name_split) >= 3:
+          source_id = file_name_split[0]
+
+          if source_id in self.configuration:
+            configuration = self.configuration.get(source_id, { "threshold_motion": 5, "threshold_motion_hold": 8, "grid": [[0.0]] })
+            md = self.motion_detectors.get(source_id, VideoMotionDetector(source_id, configuration))
+            motion = md(VideoReaderFFMPEG.read(file_path, resolution=360, RGB=False, gpu_id=0))
+
+            if motion:
+              self.on_motion(source_id, file_name, file_path, configuration)
+
+          os.remove(file_path)
+          debug("RM", file_path)
+
+      except Exception as e:
+        exception(e)
+        time.sleep(5)

{sciveo-0.1.66 → sciveo-0.1.68}/sciveo/media/capture/nvr.py

@@ -22,6 +22,7 @@ from sciveo.tools.logger import *
 from sciveo.tools.daemon import DaemonBase
 from sciveo.tools.queue import TouchedFilePathQueue
 from sciveo.tools.simple_counter import RunCounter
+from sciveo.media.capture.motion_detection import MotionDetectorDaemon
 
 
 class VideoCameraCaptureDaemon(DaemonBase):
@@ -117,7 +118,7 @@ class VideoRecorder:
   def __init__(self, path_configuration):
     with open(path_configuration, 'r') as fp:
       self.configuration = json.load(fp)
-    self.cams = []
+    self.daemons = []
 
     for cam_id, cam_config in self.configuration["cam"].items():
       cam = VideoCameraCaptureDaemon(
@@ -126,14 +127,17 @@ class VideoRecorder:
         self.configuration.get("max_video_len", 60),
         self.configuration.get("transport", "tcp")
       )
-      self.cams.append(cam)
+      self.daemons.append(cam)
+
+    if "motion" in self.configuration:
+      self.daemons.append(MotionDetectorDaemon(configuration=self.configuration["motion"]))
 
     self.queue = TouchedFilePathQueue(self.configuration["path"]["tmp"], period=5, touched_timeout=5)
     self.cleaner_timer = RunCounter(1000, self.clean_old_videos)
 
   def start(self):
-    for cam in self.cams:
-      cam.start()
+    for d in self.daemons:
+      d.start()
 
     time.sleep(10)
 
@@ -171,9 +175,17 @@ class VideoRecorder:
     video_base_path = os.path.join(self.configuration["path"]["video"], cam_id, video_date)
     video_file_path = os.path.join(video_base_path, video_file_name)
 
-    debug("MV", file_path, "=>", video_file_path)
     os.makedirs(video_base_path, exist_ok=True)
-    shutil.move(file_path, video_file_path)
+    shutil.copy(file_path, video_file_path)
+    debug("CP", file_path, "=>", video_file_path)
+
+    if "motion" in self.configuration:
+      motion_file_path = os.path.join(self.configuration["motion"]["src"], f"{cam_id}___{video_date}___{video_file_name}")
+      shutil.move(file_path, motion_file_path)
+      debug("MV", file_path, "=>", motion_file_path)
+    else:
+      os.remove(file_path)
+      debug("RM", file_path)
 
   def clean_old_videos(self):
     try:
@@ -182,7 +194,7 @@ class VideoRecorder:
       debug("cmd", cmd)
       os.system(cmd)
     except Exception as e:
-      excprint([self], e, cmd)
+      exception(e, cmd)
 
 
 if __name__ == '__main__':

sciveo-0.1.68/sciveo/media/capture/readers.py

@@ -0,0 +1,122 @@
+#
+# Stanislav Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact s.georgiev@softel.bg.
+#
+# 2025
+#
+
+import os
+import select
+import json
+import subprocess
+import ffmpeg
+import json
+import numpy as np
+from sciveo.tools.logger import *
+from sciveo.tools.timers import Timer
+
+
+class VideoReaderFFMPEG:
+  def __init__(self, path, resolution=720, RGB=False, gpu_id=-1) -> None:
+    self.path = path
+    self.resolution = resolution
+    self.RGB = RGB
+    self.gpu_id = gpu_id
+
+  @staticmethod
+  def get_dim(w, h, resolution):
+    if resolution <= 0:
+      return w, h
+
+    if h > resolution:
+      ratio = resolution / h
+    else:
+      ratio = 1.0
+    width = int(w * ratio)
+    height = int(h * ratio)
+    width += width % 2
+    height += height % 2
+    return width, height
+
+  @staticmethod
+  def read(file_path, resolution=720, RGB=False, gpu_id=-1, timeout=30):
+    timer_video_read = Timer()
+    frames = []
+
+    probe = subprocess.check_output([
+      "ffprobe", "-v", "error",
+      "-select_streams", "v:0",
+      "-show_entries", "stream=width,height,codec_name",
+      "-of", "json", file_path
+    ])
+    stream_data = json.loads(probe)["streams"][0]
+
+    in_w, in_h = int(stream_data["width"]), int(stream_data["height"])
+    out_w, out_h = VideoReaderFFMPEG.get_dim(in_w, in_h, resolution)
+    frame_size = out_w * out_h * 3
+
+    gpu_nvdec_id = int(os.environ.get("GPU_NVDEC_H264_ID", gpu_id))
+
+    codec = stream_data["codec_name"]
+    if codec in ["h264", "avc1"]:
+      decoder = "h264_cuvid"
+    elif codec in ["hevc", "h265", "hvc1"]:
+      decoder = "hevc_cuvid"
+      gpu_nvdec_id = int(os.environ.get("GPU_NVDEC_H265_ID", gpu_nvdec_id))
+
+    HW = "CPU"
+    pix_fmt = "rgb24" if RGB else "bgr24"
+
+    if min(gpu_id, gpu_nvdec_id) < 0:
+      HW = "CPU"
+      ffmpeg_input = ffmpeg.input(file_path)
+    else:
+      HW = "GPU"
+      ffmpeg_input = ffmpeg.input(file_path, hwaccel='cuda', hwaccel_device=gpu_nvdec_id, c=decoder)
+
+    if in_w != out_w or in_h != out_h:
+      ffmpeg_input = ffmpeg_input.filter('scale', out_w, out_h)
+
+    process = (
+      ffmpeg_input
+      .output('pipe:', format='rawvideo', pix_fmt=pix_fmt, vsync='vfr')
+      .global_args('-v', 'quiet')
+      .run_async(pipe_stdout=True, pipe_stderr=subprocess.DEVNULL)
+    )
+
+    fd = process.stdout.fileno()
+
+    while True:
+      ready, _, _ = select.select([fd], [], [], timeout)
+      if not ready:
+        warning("VideoReaderFFMPEG::read", file_path, f"[{HW}][{gpu_id}] not ready FAIL")
+        process.kill()
+        process.wait()
+        frames = []
+        break
+
+      in_bytes = process.stdout.read(frame_size)
+      if not in_bytes:
+        break
+      frame = np.frombuffer(in_bytes, np.uint8).reshape([out_h, out_w, 3]).copy()
+      frames.append(frame)
+
+    process.wait()
+
+    if gpu_id >= 0 and len(frames) == 0:
+      warning("VideoReaderFFMPEG::read", file_path, f"[{HW}][{gpu_id}] reading not successful, fallback to CPU")
+      return VideoReaderFFMPEG.read(file_path, resolution, RGB, gpu_id=-1)
+
+    elapsed = timer_video_read.stop()
+    FPS = round(len(frames) / elapsed, 2)
+    debug("VideoReaderFFMPEG::read", file_path, f"[{HW}] video reading {len(frames)} frames, codec[{codec}] decoder[{decoder}] pix_fmt[{pix_fmt}] [{out_w}x{out_h}], elapsed {round(elapsed, 1)} FPS {FPS}")
+    return frames
+
+  def __call__(self):
+    return VideoReaderFFMPEG.read(self.path, self.resolution, RGB=self.RGB, gpu_id=self.gpu_id)
+
+

sciveo-0.1.68/sciveo/tools/totp.py

@@ -0,0 +1,80 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2025
+#
+
+
+import os
+import hmac
+import base64
+import struct
+import hashlib
+import time
+
+from sciveo.tools.logger import *
+
+
+class AuthTOTP:
+  def __init__(self, secret: str, interval: int = 30, digits: int = 6, algo=hashlib.sha1):
+    """
+    secret: the private key
+    interval: time step in seconds (default 30)
+    digits: number of digits in code (default 6)
+    algo: hash function (default SHA1, per RFC 6238)
+    """
+    self.secret = secret
+    self.interval = interval
+    self.digits = digits
+    self.algo = algo
+
+  @staticmethod
+  def new_private_key(length: int = 20) -> str:
+    """
+    Generate a new Base32 secret key.
+    """
+    raw = os.urandom(length)
+    return base64.b32encode(raw).decode("utf-8").replace("=", "")
+
+  def _generate_otp(self, for_time: int) -> int:
+    """
+    Internal: generate OTP for given time counter.
+    """
+    pad_len = (8 - len(self.secret) % 8) % 8
+    secret_padded = self.secret + ("=" * pad_len)
+    key = base64.b32decode(secret_padded, casefold=True)
+
+    counter = struct.pack(">Q", for_time)
+    hmac_digest = hmac.new(key, counter, self.algo).digest()
+
+    offset = hmac_digest[-1] & 0x0F
+    code = struct.unpack(">I", hmac_digest[offset:offset+4])[0] & 0x7FFFFFFF
+    return code % (10 ** self.digits)
+
+  def next_token(self, for_time: int = None) -> str:
+    """
+    Return the TOTP token for current (or given) time.
+    """
+    if for_time is None:
+      for_time = int(time.time())
+    counter = for_time // self.interval
+    return str(self._generate_otp(counter)).zfill(self.digits)
+
+  def verify_token(self, token: str, for_time: int = None, window: int = 1) -> bool:
+    """
+    Verify a token, allowing ±window intervals (to handle clock skew).
+    """
+    if for_time is None:
+      for_time = int(time.time())
+    counter = for_time // self.interval
+    for delta in range(-window, window + 1):
+      candidate = str(self._generate_otp(counter + delta)).zfill(self.digits)
+      # debug("verify", token, "delta", delta, "candidate", candidate)
+      if hmac.compare_digest(candidate, token):
+        return True
+    return False

sciveo-0.1.68/sciveo/version.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.1.68'

{sciveo-0.1.66 → sciveo-0.1.68}/sciveo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.66
+Version: 0.1.68
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.66 → sciveo-0.1.68}/sciveo.egg-info/SOURCES.txt

@@ -27,7 +27,9 @@ sciveo/content/runner.py
 sciveo/media/__init__.py
 sciveo/media/capture/__init__.py
 sciveo/media/capture/cam.py
+sciveo/media/capture/motion_detection.py
 sciveo/media/capture/nvr.py
+sciveo/media/capture/readers.py
 sciveo/media/ml/__init__.py
 sciveo/media/ml/base.py
 sciveo/media/ml/encoders/__init__.py
@@ -143,6 +145,7 @@ sciveo/tools/remote.py
 sciveo/tools/simple_counter.py
 sciveo/tools/synchronized.py
 sciveo/tools/timers.py
+sciveo/tools/totp.py
 sciveo/tools/aws/__init__.py
 sciveo/tools/aws/priority_queue.py
 sciveo/tools/aws/s3.py
@@ -159,4 +162,5 @@ test/test_ml_datasets.py
 test/test_monitoring.py
 test/test_runner.py
 test/test_sampling.py
-test/test_tokenizers.py
+test/test_tokenizers.py
+test/test_totp.py

sciveo-0.1.68/test/test_totp.py

@@ -0,0 +1,41 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2025
+#
+
+import time
+import unittest
+
+from sciveo.tools.totp import *
+
+
+class TestTOTP(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    cls.secret = AuthTOTP.new_private_key(length=32)
+    cls.auth = AuthTOTP(cls.secret, digits=8)
+
+  def test_pass(self):
+    token = self.auth.next_token()
+    self.assertTrue(self.auth.verify_token(token=token))
+
+  def test_expiry_time_fail(self):
+    auth = AuthTOTP(self.secret, interval=3, digits=8)
+    token = auth.next_token()
+    self.assertTrue(auth.verify_token(token=token))
+    time.sleep(2)
+    self.assertTrue(auth.verify_token(token=token))
+    time.sleep(2)
+    self.assertTrue(auth.verify_token(token=token))
+    time.sleep(2)
+    self.assertFalse(auth.verify_token(token=token))
+
+
+if __name__ == '__main__':
+  unittest.main()

sciveo-0.1.66/sciveo/version.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.1.66'