sciveo 0.1.54__tar.gz → 0.1.56__tar.gz

{sciveo-0.1.54 → sciveo-0.1.56}/PKG-INFO

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

{sciveo-0.1.54 → sciveo-0.1.56}/sciveo/media/tools/nvr.py

@@ -25,12 +25,13 @@ from sciveo.tools.simple_counter import RunCounter
 
 
 class VideoCameraCaptureDaemon(DaemonBase):
-  def __init__(self, cam_id, url, dst_path, max_video_len=60, transport="tcp"):
+  def __init__(self, cam_id, url, dst_path, max_video_len=60, transport="tcp", max_timeout=30):
     super().__init__()
     self.cam_id = cam_id
     self.url = url
     self.dst_path = dst_path
     self.max_video_len = max_video_len
+    self.max_timeout = max_timeout
     self.transport = transport
     self.cmd = [
       "ffmpeg",
@@ -42,10 +43,6 @@ class VideoCameraCaptureDaemon(DaemonBase):
       "-segment_time", f"{self.max_video_len}",
       "-reset_timestamps", "1",
       "-strftime", "1",
-      "-reconnect", "1",
-      "-reconnect_at_eof", "1",
-      "-reconnect_streamed", "1",
-      "-reconnect_delay_max", "5",
       f"{self.dst_path}/{self.cam_id}___%Y-%m-%d___%H-%M-%S.mp4"
     ]
 
@@ -61,17 +58,53 @@ class VideoCameraCaptureDaemon(DaemonBase):
 
   def loop(self):
     info("start", self.cam_id)
-    while(True):
+
+    while True:
       self.clear()
 
-      p = sp.Popen(self.cmd, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
-      p.wait()
+      try:
+        last_known_file = None
+        last_mod_time = None
+        last_progress_time = time.time()
+
+        p = sp.Popen(self.cmd, stdout=sp.DEVNULL, stderr=sp.DEVNULL)
+
+        while True:
+          time.sleep(5)
+
+          if p.poll() is not None:
+            break
+
+          current_files = [
+            f for f in os.listdir(self.dst_path)
+            if f.startswith(f"{self.cam_id}___") and f.endswith(".mp4")
+          ]
+          if current_files:
+            current_files.sort(key=lambda x: os.path.getmtime(os.path.join(self.dst_path, x)), reverse=True)
+            newest_file = os.path.join(self.dst_path, current_files[0])
+
+            mod_time = os.path.getmtime(newest_file)
+            if newest_file == last_known_file:
+              if mod_time > last_mod_time:
+                last_progress_time = time.time()
+              elif time.time() - last_progress_time > self.max_timeout:
+                warning(self.cam_id, f"No file update for over {self.max_timeout} seconds, killing ffmpeg...")
+                p.kill()
+                break
+            else:
+              last_known_file = newest_file
+              last_mod_time = mod_time
+              last_progress_time = time.time()
+
+      except Exception as e:
+        exception(e)
 
       self.clear()
       warning(self.cam_id, "streaming interrupted, wait to retry...")
       time.sleep(5)
 
 
+
 class VideoRecorder:
   def __init__(self, path_configuration):
     with open(path_configuration, 'r') as fp:

sciveo-0.1.56/sciveo/ml/evaluation/markdown.py

@@ -0,0 +1,227 @@
+#
+# 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 re
+import difflib
+from collections import defaultdict
+
+
+class EvalMarkdownSimple:
+  def __init__(self, md_true: str, md_predicted: str, similarity_threshold=0.8):
+    self.md_true = md_true.split("\n")
+    self.md_predicted = md_predicted.split("\n")
+    self.similarity_threshold = similarity_threshold
+    self.results = {"EM": [], "PM": [], "FN": [], "FP": [], "RI": [], "H": [], "FE": []}
+
+  def _find_best_match(self, text, candidates):
+    """
+    Finds the best matching text block from predicted Markdown using similarity comparison.
+
+    :param text: The labeled Markdown text to match.
+    :param candidates: The list of LLM-generated Markdown text blocks.
+    :return: (best_match, similarity_score) or (None, 0) if no match found.
+    """
+    best_match = None
+    best_score = 0
+    text_lower = text.lower()
+
+    for candidate in candidates:
+      score = difflib.SequenceMatcher(None, text_lower, candidate.lower()).ratio()
+      if score > best_score:
+        best_score = score
+        best_match = candidate
+
+    return (best_match, best_score) if best_score >= self.similarity_threshold else (None, 0)
+
+  def _check_formatting_errors(self, original, predicted):
+    """
+    Checks for incorrect Markdown formatting in predicted text.
+
+    :param original: The manually labeled Markdown text.
+    :param predicted: The LLM-generated Markdown text.
+    :return: True if formatting errors exist, False otherwise.
+    """
+    # Basic check: header formatting, bold/italic differences
+    if original.strip("#*`").strip() == predicted.strip("#*`").strip():
+      return True
+    return False
+
+  def evaluate(self):
+    """
+    Evaluates Markdown
+    """
+    matched_predicted_blocks = set()
+    predicted_idx_map = {block: idx for idx, block in enumerate(self.md_predicted)}
+
+    for true_text in self.md_true:
+      best_match, score = self._find_best_match(true_text, self.md_predicted)
+
+      if best_match:
+        matched_predicted_blocks.add(best_match)
+        if score == 1.0:
+          self.results["EM"].append((true_text, best_match))
+        else:
+          self.results["PM"].append((true_text, best_match, score))
+
+        # Check for formatting errors
+        if self._check_formatting_errors(true_text, best_match):
+          self.results["FE"].append((true_text, best_match))
+      else:
+        self.results["FN"].append(true_text)
+
+    # False Positives (extra predicted blocks that don't match labeled Markdown)
+    for pred_text in self.md_predicted:
+      if pred_text not in matched_predicted_blocks:
+        self.results["FP"].append(pred_text)
+
+    # Check for hallucinations (predicted content not in labeled text)
+    for pred_text in self.results["FP"]:
+      best_match, _ = self._find_best_match(pred_text, self.md_true)
+      if best_match is None:
+        self.results["H"].append(pred_text)
+
+    # Check for order issues (text found but misordered)
+    true_texts = [t for t, _ in self.results["EM"]] + [t for t, _, _ in self.results["PM"]]
+    pred_texts = [p for _, p in self.results["EM"]] + [p for _, p, _ in self.results["PM"]]
+
+    true_indices = [predicted_idx_map[text] for text in pred_texts if text in predicted_idx_map]
+    if true_indices != sorted(true_indices):
+      self.results["RI"].append(true_indices)
+
+    return self.results
+
+  def score(self):
+    """
+    Computes an improved similarity score with weighted Partial Matches (PM).
+    """
+    TP = len(self.results["EM"])
+    PM_weighted = sum(score for _, _, score in self.results["PM"])
+    FN = len(self.results["FN"])
+    FP = len(self.results["FP"])
+
+    precision = (TP + PM_weighted) / (TP + PM_weighted + FP) if (TP + PM_weighted + FP) > 0 else 0
+    recall = (TP + PM_weighted) / (TP + PM_weighted + FN) if (TP + PM_weighted + FN) > 0 else 0
+    f1_score = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {"Precision": precision, "Recall": recall, "F1 Score": f1_score}
+
+
+class EvalMarkdown:
+  def __init__(self, md_true, md_predicted):
+    """
+    Evaluates labeled (true) Markdown against predicted Markdown with section-wise evaluation.
+    """
+    self.md_true = self._parse_markdown(md_true.lower())
+    self.md_predicted = self._parse_markdown(md_predicted.lower())
+    self.results = defaultdict(lambda: {"EM": [], "PM": [], "FN": [], "FP": []})
+
+  def _parse_markdown(self, markdown_text):
+    """
+    Parses Markdown into a dictionary of sections where key = heading, value = list of text blocks.
+    """
+    sections = defaultdict(list)
+    current_section = "INTRO"  # Default section if no heading appears
+
+    for line in markdown_text.split("\n"):
+      heading_match = re.match(r"^(#{1,6})\s+(.+)", line)
+      if heading_match:
+        current_section = heading_match.group(2).strip()  # Extract section title
+      else:
+        if line.strip():
+          sections[current_section].append(line.strip())
+
+    return sections
+
+  def _find_best_match(self, text, true_texts):
+    """
+    Finds the best match for a given text within a list of true texts.
+    Returns (best_match_text, similarity_score).
+    """
+    if not true_texts:
+      return None, 0
+
+    from difflib import SequenceMatcher
+    best_match, best_score = None, 0
+
+    for true_text in true_texts:
+      score = SequenceMatcher(None, text, true_text).ratio()
+      if score > best_score:
+        best_match, best_score = true_text, score
+
+    return best_match, best_score
+
+  def evaluate(self):
+    all_sections = set(self.md_true.keys()).union(set(self.md_predicted.keys()))
+    for section in all_sections:
+      true_texts = self.md_true.get(section, [])
+      pred_texts = self.md_predicted.get(section, [])
+
+      matched_true = set()
+      matched_pred = set()
+
+      # Exact matches
+      for pred_text in pred_texts:
+        if pred_text in true_texts:
+          self.results[section]["EM"].append((pred_text, pred_text))
+          matched_true.add(pred_text)
+          matched_pred.add(pred_text)
+
+      # Partial matches
+      for pred_text in pred_texts:
+        if pred_text not in matched_pred:
+          best_match, score = self._find_best_match(pred_text, true_texts)
+          if best_match and score > 0.8:  # Accept only good matches
+            self.results[section]["PM"].append((best_match, pred_text, score))
+            matched_true.add(best_match)
+            matched_pred.add(pred_text)
+
+      # False negatives (missed text from ground truth)
+      for true_text in true_texts:
+        if true_text not in matched_true:
+          self.results[section]["FN"].append(true_text)
+
+      # False positives (extra predicted text)
+      for pred_text in pred_texts:
+        if pred_text not in matched_pred:
+          self.results[section]["FP"].append(pred_text)
+
+    return self.results
+
+  def score(self):
+    """
+    Computes section-wise and global similarity scores.
+    """
+    section_scores = {}
+    global_TP, global_PM, global_FN, global_FP = 0, 0, 0, 0
+
+    for section, result in self.results.items():
+      TP = len(result["EM"])
+      PM_weighted = sum(score for _, _, score in result["PM"])
+      FN = len(result["FN"])
+      FP = len(result["FP"])
+
+      precision = (TP + PM_weighted) / (TP + PM_weighted + FP) if (TP + PM_weighted + FP) > 0 else 0
+      recall = (TP + PM_weighted) / (TP + PM_weighted + FN) if (TP + PM_weighted + FN) > 0 else 0
+      f1_score = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+      section_scores[section] = {"Precision": precision, "Recall": recall, "F1 Score": f1_score}
+
+      global_TP += TP
+      global_PM += PM_weighted
+      global_FN += FN
+      global_FP += FP
+
+    # Global precision/recall across all sections
+    global_precision = (global_TP + global_PM) / (global_TP + global_PM + global_FP) if (global_TP + global_PM + global_FP) > 0 else 0
+    global_recall = (global_TP + global_PM) / (global_TP + global_PM + global_FN) if (global_TP + global_PM + global_FN) > 0 else 0
+    global_f1 = (2 * global_precision * global_recall) / (global_precision + global_recall) if (global_precision + global_recall) > 0 else 0
+
+    return {"Sections": section_scores, "Global": {"Precision": global_precision, "Recall": global_recall, "F1 Score": global_f1}}

{sciveo-0.1.54 → sciveo-0.1.56}/sciveo/monitoring/monitor.py

@@ -169,7 +169,7 @@ class BaseMonitor(DaemonBase):
 
       lines = result.stdout.strip().split('\n')
       self.data["GPU"] = {
-        "raw_lines": lines
+        "raw_lines": lines[:7] # TODO: FIX this! Due to aws timestream constraints.
       }
     except Exception as e:
       pass

sciveo-0.1.56/sciveo/version.py

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

{sciveo-0.1.54 → sciveo-0.1.56}/sciveo.egg-info/PKG-INFO

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

{sciveo-0.1.54 → sciveo-0.1.56}/sciveo.egg-info/SOURCES.txt

@@ -97,13 +97,13 @@ sciveo/ml/base.py
 sciveo/ml/dataset/__init__.py
 sciveo/ml/dataset/object_detection.py
 sciveo/ml/evaluation/__init__.py
+sciveo/ml/evaluation/markdown.py
 sciveo/ml/evaluation/object_detection.py
 sciveo/ml/images/__init__.py
 sciveo/ml/images/base.py
 sciveo/ml/images/description.py
 sciveo/ml/images/embeddings.py
 sciveo/ml/images/object_detection.py
-sciveo/ml/images/segmentation.py
 sciveo/ml/images/tools.py
 sciveo/ml/images/transformers.py
 sciveo/ml/nlp/__init__.py
@@ -147,6 +147,7 @@ test/test_complexity.py
 test/test_compress.py
 test/test_configuration.py
 test/test_crypto.py
+test/test_eval_markdown.py
 test/test_ml_datasets.py
 test/test_monitoring.py
 test/test_runner.py

sciveo-0.1.56/test/test_eval_markdown.py

@@ -0,0 +1,41 @@
+#
+# 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 math
+import unittest
+
+from sciveo.tools.logger import *
+from sciveo.ml.evaluation.markdown import *
+
+
+class TestEvalMarkdown(unittest.TestCase):
+  def test_1(self):
+    md_true = """
+      "# Breaking News"
+      "A major fire broke out in the city center."
+      "Authorities are investigating the cause."
+    """
+
+    md_predicted = """
+      "# BREAKING NEWS",
+      "A major fire broke out in city center.",
+      "Authorities investigate the cause.",
+      "Stay tuned for updates."
+    """
+
+    em = EvalMarkdown(md_true, md_predicted)
+    results = em.evaluate()
+    info(results)
+    info("Score", em.score())
+
+
+if __name__ == '__main__':
+  unittest.main()