argussight 0.1.0__py3-none-any.whl

argussight/core/config.py

@@ -0,0 +1,20 @@
+from typing import Union
+
+from pydantic import BaseModel, Field
+
+
+class RedisConfiguration(BaseModel):
+    host: str = Field("localhost", description="redis host")
+    port: int = Field(6379, description="redis port")
+    channel: str = Field(
+        "video-streamer", description="redis-channel to publish stream"
+    )
+
+
+class CollectorConfiguration(BaseModel):
+    redis: RedisConfiguration
+
+
+def get_config_from_dict(config_data: dict) -> Union[CollectorConfiguration, None]:
+    data = CollectorConfiguration(**config_data)
+    return data

argussight/core/configurations/config.yaml

@@ -0,0 +1,40 @@
+---
+
+# This indicates the path to the files of the process classes
+modules_path: argussight.core.video_processes
+
+# List of available processes and their file locations from modules_path
+# If accessible=true then process can be started via grpc call
+worker_classes:
+  test:
+    location: vprocess.Test
+    accessible: true
+  flow_detection:
+    location: streamer.optical_flow_detection.OpticalFlowDetection
+    accessible: true
+  stream_buffer:
+    location: savers.stream_buffer.StreamBuffer
+    accessible: false
+  video_recorder:
+    location: savers.video_recorder.Recorder
+    accessible: false
+
+# This indicates the processes that are started by argussight,
+# if killed due to no response, they are restarted automatically
+processes:
+  - name: "Saver"
+    type: stream_buffer
+  - name: "Recorder"
+    type: video_recorder
+
+# This indicates the maximal waiting time (s),
+# the spawner waits on responds from processes, before killing them
+wait_time: 5
+
+# This is the port for the rerouting of the streams
+streams_layer_port: 7000
+
+# Argussight is configured to run streams on different ports
+# It will check for free ports, whenever a new streaming process starts
+# The value below indicates at which port the search for a free port begins,
+streams_starting_port: 9000

argussight/core/configurations/processes/savers/stream_buffer.yaml

@@ -0,0 +1,15 @@
+---
+
+parameters:
+  max_queue_len:
+    value: 200
+    exposed: false
+  main_save_folder:
+    value: "logs/"
+    exposed: false
+  save_format:
+    value: "both"
+    exposed: true
+  personnal_folder:
+    value: "test"
+    exposed: true

argussight/core/configurations/processes/savers/video_recorder.yaml

@@ -0,0 +1,22 @@
+---
+
+parameters:
+  main_save_folder:
+    value: "logs/recordings"
+    exposed: false
+  # pay attention to the setting of the temp folder, as the folder will
+  # be cleared when the recorder is initialised,
+  # IMPORTANT: do NOT use an existing folder!!!
+  temp_folder:
+    value: "temp"
+    exposed: false
+  save_format:
+    value: "both"
+    exposed: true
+  personnal_folder:
+    value: "test"
+    exposed: true
+  max_recording_time:
+    # unit: seconds, 0 means not set
+    value: 0
+    exposed: false

argussight/core/configurations/processes/savers/video_saver.yaml

@@ -0,0 +1,16 @@
+---
+
+parameters:
+  main_save_folder:
+    value: "logs/"
+    exposed: false
+  save_format:
+    value: "both"
+    exposed: true
+  personnal_folder:
+    value: "test"
+    exposed: true
+  max_recording_time:
+    # unit: seconds, 0 means not set
+    value: 0
+    exposed: false

argussight/core/configurations/processes/streamer/flow_detection.yaml

@@ -0,0 +1,21 @@
+---
+
+parameters:
+  feature_params:
+    value:
+      maxCorners: 5
+      qualityLevel: 0.7
+      minDistance: 50
+      blockSize: 7
+    exposed: false
+
+  lk_params:
+    value:
+      winSize: [15, 15]
+      maxLevel: 2
+      criteria: [3, 10, 0.03]
+    exposed: false
+
+  roi:
+    value: [550, 450, 200, 500]
+    exposed: true

argussight/core/configurations/processes/streamer/optical_flow_detection.yaml

@@ -0,0 +1,16 @@
+---
+
+parameters:
+  flow_params:
+    value:
+      pyr_scale: 0.5
+      levels: 3
+      winsize: 15
+      iterations: 3
+      poly_n: 5
+      poly_sigma: 1.1
+      flags: 0
+    exposed: false
+  roi:
+    value: [550, 450, 200, 500]
+    exposed: true

argussight/core/configurations/processes/streamer/streamer.yaml

@@ -0,0 +1,3 @@
+---
+
+parameters: {}

argussight/core/configurations/processes/vprocess.yaml

@@ -0,0 +1,3 @@
+---
+
+parameters: {}

argussight/core/helper_functions.py

@@ -0,0 +1,35 @@
+import socket
+from typing import Union
+
+import Levenshtein
+
+
+def find_close_key(d: dict, key: str, max_distance: int = 3) -> Union[str, None]:
+    """Return first key in dict whose Levenshtein distance to key is <= max_distance"""
+    min_distance = float("inf")
+    closest_key = None
+
+    for dict_key in d:
+        distance = Levenshtein.distance(key, dict_key)
+        if distance < min_distance:
+            min_distance = distance
+            closest_key = dict_key
+
+    if min_distance <= max_distance:
+        return closest_key
+
+    return None
+
+
+def is_port_free(port):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(1)  # Optional: set a short timeout for connection attempt
+        result = s.connect_ex(("localhost", port))
+        return result != 0  # If result is non-zero, port is free
+
+
+def find_free_port(start_port=9000):
+    port = start_port
+    while not is_port_free(port):
+        port += 1
+    return port

argussight/core/manager.py

@@ -0,0 +1,71 @@
+import queue
+from datetime import datetime
+from multiprocessing import Queue
+from threading import Event
+
+from argussight.core.video_processes.vprocess import ProcessError
+
+
+class Manager:
+    def __init__(
+        self,
+        command_queue: Queue,
+        response_queue: Queue,
+        finished_event: Event,
+        failed_event: Event,
+    ) -> None:
+        self._commands_list = queue.Queue(
+            maxsize=20
+        )  # commands that are waiting to be processed by Manager
+        self._command_queue = (
+            command_queue  # commands that are sent to process for being processed
+        )
+        self._response_queue = response_queue
+        self._finished_event = finished_event
+        self._failed_event = failed_event
+
+    def receive_command(
+        self,
+        command: str,
+        wait_time: int,
+        processed_event: Event,
+        result_queue: queue.Queue,
+        args,
+    ) -> None:
+        if self._commands_list.full():
+            raise ProcessError(
+                f"Cannot execute command {command}: too many commands in waiting list"
+            )
+        self._commands_list.put(
+            {
+                "command": command,
+                "max_wait_time": wait_time,
+                "time_stamp": datetime.now(),
+                "args": args,
+                "processed_event": processed_event,
+                "result_queue": result_queue,
+            }
+        )
+
+    def handle_commands(self) -> None:
+        while not self._commands_list.empty():
+            command = self._commands_list.get()
+
+            # Check if command is alive
+            if (datetime.now() - command["time_stamp"]).total_seconds() > command[
+                "max_wait_time"
+            ]:
+                continue
+
+            self._command_queue.put((command["command"], command["args"]))
+            command["processed_event"].set()
+
+            try:
+                result = self._response_queue.get(timeout=command["max_wait_time"])
+                command["result_queue"].put(result)
+
+            except queue.Empty:
+                self._failed_event.set()
+                break
+
+        self._finished_event.set()

argussight/core/spawner.py

@@ -0,0 +1,321 @@
+import importlib
+import inspect
+import multiprocessing
+import os
+import queue
+import threading
+from typing import Any, Dict, List, Tuple
+
+import psutil
+import requests
+import yaml
+
+import argussight.streamsproxy as StreamsProxy
+from argussight.core.helper_functions import find_close_key, find_free_port
+from argussight.core.manager import Manager
+from argussight.core.video_processes.streamer.streamer import Streamer
+from argussight.core.video_processes.vprocess import ProcessError, Vprocess
+
+
+class Spawner:
+    def __init__(self, collector_config) -> None:
+        self._processes = {}
+        self._worker_classes = {}
+        self._managers_dict = {}
+        self._restricted_classes = []
+        self._streamer_types = []
+        self.collector_config = collector_config
+        self._settings_manager = multiprocessing.Manager()
+        self._streams = set([])
+
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        self.load_config(os.path.join(current_dir, "configurations/config.yaml"))
+
+        print(f"running stream_layer on port {self.config['streams_layer_port']}")
+        streams_layer_process = multiprocessing.Process(
+            target=StreamsProxy.run, args=(self.config["streams_layer_port"],)
+        )
+        streams_layer_process.start()
+
+    def load_config(self, path_config_file: str) -> None:
+        with open(path_config_file, "r") as f:
+            self.config = yaml.safe_load(f)
+        self.load_worker_classes()
+
+        for process in self.config["processes"]:
+            self.start_process(process["name"], process["type"])
+
+    def load_worker_classes(self):
+        worker_classes_config = self.config["worker_classes"]
+        modules_path = self.config["modules_path"]
+        for key, worker_class in worker_classes_config.items():
+            class_path = worker_class["location"]
+            module_name, class_name = class_path.rsplit(".", 1)
+            module = importlib.import_module(modules_path + "." + module_name)
+            self._worker_classes[key] = getattr(module, class_name)
+            if not worker_class["accessible"]:
+                self._restricted_classes.append(key)
+            if issubclass(self._worker_classes[key], Streamer):
+                self._streamer_types.append(key)
+
+    def create_worker(
+        self, worker_type: str, free_port, settings: Dict[str, Any]
+    ) -> Vprocess:
+        if worker_type in self._streamer_types:
+            return self._worker_classes.get(worker_type)(
+                self.collector_config, free_port, settings
+            )
+        return self._worker_classes.get(worker_type)(self.collector_config, settings)
+
+    def add_process(
+        self,
+        name: str,
+        worker_type: str,
+        process: multiprocessing.Process,
+        command_queue: multiprocessing.Queue,
+        response_queue: multiprocessing.Queue,
+        settings: Dict[str, Any],
+    ) -> None:
+        self._processes[name] = {
+            "process_instance": process,
+            "command_queue": command_queue,
+            "response_queue": response_queue,
+            "type": worker_type,
+            "settings": settings,
+        }
+
+    # This function checks if worker_type can be accessed
+    def check_restricted_access(self, worker_type: str) -> bool:
+        # First check if access is restricted
+        if worker_type not in self._restricted_classes:
+            return True
+
+        # If access is restricted, check if the caller is the server
+        stack = inspect.stack()
+
+        # The caller's frame will be two levels up in the stack:
+        # - The current frame
+        # - The frame of the function that called check_restricted_access
+        # - The frame of the function that called that function (the original caller)
+        caller_frame = stack[2]
+
+        # Get the calling function's name and module
+        caller_module = inspect.getmodule(caller_frame.frame)
+
+        # Check if the caller is a method in the same class
+        if caller_module and caller_module.__name__ == self.__class__.__module__:
+            caller_class = caller_frame.frame.f_locals.get("self")
+            if isinstance(caller_class, self.__class__):
+                return True
+
+        return False
+
+    def add_stream(self, name, port, stream_id) -> None:
+        requests.post(
+            f"http://localhost:{str(self.config['streams_layer_port'])}/add-stream",
+            params={
+                "path": name,
+                "port": port,
+                "id": stream_id,
+            },
+        )
+        self._streams.add(name)
+
+    def start_process(self, name, type) -> None:
+        if name in self._processes:
+            raise ProcessError(
+                f"Process names must be unique. '{name}' already exists. Either terminate '{name}' or choose a different unique name"
+            )
+        if type not in self._worker_classes:
+            raise ProcessError(f"Type {type} does not exist")
+        # check if somebody tries to start a restricted worker type from outside this class
+        if not self.check_restricted_access(type):
+            raise ProcessError(f"Worker of type {type} can only be started by server.")
+
+        free_port = find_free_port(self.config["streams_starting_port"])
+        settings = self._settings_manager.dict()
+        worker_instance = self.create_worker(type, free_port, settings)
+        command_queue = multiprocessing.Queue()
+        response_queue = multiprocessing.Queue()
+        p = multiprocessing.Process(
+            target=worker_instance.run, args=(command_queue, response_queue)
+        )
+        print(f"started {name} of type {type}")
+        p.start()
+        if isinstance(worker_instance, Streamer):
+            self.add_stream(name, free_port, worker_instance.get_stream_id())
+        self.add_process(name, type, p, command_queue, response_queue, settings)
+
+    # check if process is running otherwise throw ProcessError
+    def check_for_running_process(self, name: str) -> None:
+        if name not in self._processes:
+            errorMessage = f"{name} is not a running process."
+            closest_key = find_close_key(self._processes, name)
+            if closest_key:
+                errorMessage += f" Did you mean: {closest_key}"
+
+            raise ProcessError(errorMessage)
+
+    def find_process_in_config_by_name(self, name: str) -> Dict:
+        for process in self.config["processes"]:
+            if process["name"] == name:
+                return process
+        return None
+
+    def terminate_processes(self, names: List[str]) -> None:
+        for name in names:
+            self.check_for_running_process(name)
+            worker_type = self._processes[name]["type"]
+            # check if somebody tries to kill a restricted worker type from outside this class
+            if not self.check_restricted_access(worker_type):
+                raise ProcessError(
+                    f"Worker of type {worker_type} can only be terminated by server."
+                )
+
+        for name in names:
+            p = self._processes[name]["process_instance"]
+            worker_type = self._processes[name]["type"]
+            # first kill all possible children
+            parent = psutil.Process(p.pid)
+            children = parent.children(recursive=True)
+            for child in children:
+                print(f"Terminating child process: {child.pid}")
+                child.terminate()
+            # now kill the process itself and clean up
+            p.terminate()
+            p.join()
+            del self._processes[name]["settings"]
+            del self._processes[name]
+
+            if worker_type in self._streamer_types:
+                requests.post(
+                    f"http://localhost:{str(self.config['streams_layer_port'])}/remove-stream",
+                    params={"path": name},
+                )
+                self._streams.discard(name)
+
+            print(f"terminated {name} of type {worker_type}")
+            if (
+                worker_type in self._restricted_classes
+                and self.check_restricted_access(worker_type)
+            ):
+                process = self.find_process_in_config_by_name(name)
+                self.start_process(process["name"], process["type"])
+
+    def wait_for_manager(
+        self,
+        finished_event: threading.Event,
+        failed_event: threading.Event,
+        name: str,
+        manager: threading.Thread,
+    ) -> None:
+        while manager.is_alive():
+            finished_event.wait(timeout=1000)
+            if finished_event.is_set():
+                del self._managers_dict[name]
+                if failed_event.is_set():
+                    self.terminate_processes([name])
+                return
+
+        if name in self._managers_dict:
+            del self._managers_dict[name]
+            print("manager is not alive anymore but hasn't finished")
+
+    def send_command_to_manager(
+        self, name: str, command: str, args
+    ) -> Tuple[threading.Event, queue.Queue]:
+        processed_event = threading.Event()
+        response_queue = queue.Queue()
+
+        self._managers_dict[name]["manager"].receive_command(
+            command, self.config["wait_time"], processed_event, response_queue, args
+        )
+
+        return processed_event, response_queue
+
+    # this function should only be called by the spawner service and used as Thread
+    def manage_process(self, name: str, command: str, args) -> None:
+        self.check_for_running_process(name)
+
+        # Check if manager already exists
+        if name not in self._managers_dict:
+            finished_event = threading.Event()
+            failed_event = threading.Event()
+            self._managers_dict[name] = {
+                "manager": Manager(
+                    self._processes[name]["command_queue"],
+                    self._processes[name]["response_queue"],
+                    finished_event,
+                    failed_event,
+                ),
+                "failed_event": failed_event,
+            }
+            processed_event, result_queue = self.send_command_to_manager(
+                name, command, args
+            )
+
+            manager_thread = threading.Thread(
+                target=self._managers_dict[name]["manager"].handle_commands
+            )
+            waiter_thread = threading.Thread(
+                target=self.wait_for_manager,
+                args=(finished_event, failed_event, name, manager_thread),
+            )
+            manager_thread.start()
+            waiter_thread.start()
+        else:
+            try:
+                processed_event, result_queue = self.send_command_to_manager(
+                    name, command, args
+                )
+                failed_event = self._managers_dict[name]["failed_event"]
+            except ProcessError as e:
+                e.message += f" for {name}. Try again later"
+
+        is_processing = processed_event.wait(timeout=self.config["wait_time"])
+        if is_processing:
+            try:
+                result = result_queue.get(timeout=self.config["wait_time"])
+                if isinstance(result, Exception):
+                    raise result
+
+                return
+            except queue.Empty:
+                wait_time = self.config["wait_time"]
+                raise ProcessError(
+                    f"Command {command} could not be executed in time {wait_time}. Hence process {name} is getting terminated"
+                )
+
+        elif failed_event.is_set():
+            raise ProcessError(
+                f"An error occured in process {name}. Process is no longer alive."
+            )
+        else:
+            raise ProcessError(
+                f"Process {name} is busy and could not start command in time. Try again later."
+            )
+
+    def get_processes(self):
+        running_processes = {}
+        for uname, process in self._processes.items():
+            type = process["type"]
+            current_class = self._worker_classes[type]
+            commands = [
+                command
+                for command in current_class.create_commands_dict().keys()
+                if command != "settings" and command != "default_settings"
+            ]
+            settings = dict(process["settings"])
+            running_processes[uname] = {
+                "type": type,
+                "commands": commands,
+                "settings": settings,
+            }
+
+        available_types = [
+            type
+            for type in self._worker_classes
+            if type not in self._restricted_classes
+        ]
+
+        return running_processes, available_types, self._streams

argussight/core/video_processes/savers/stream_buffer.py

@@ -0,0 +1,32 @@
+from collections import deque
+from typing import Any, Dict
+
+from argussight.core.video_processes.savers.video_saver import VideoSaver
+
+
+class StreamBuffer(VideoSaver):
+    def __init__(self, collector_config, exposed_parameters: Dict[str, Any]) -> None:
+        super().__init__(collector_config, exposed_parameters)
+        self._queue = deque(maxlen=self._parameters["max_queue_len"])
+
+    @classmethod
+    def create_commands_dict(cls) -> Dict[str, Any]:
+        result = super().create_commands_dict()
+        result.update({"save": cls.save_queue})
+        return result
+
+    def save_queue(self) -> None:
+        queue = self._queue.copy()
+        self.executor.submit(
+            self.save_iterable,
+            queue,
+        )
+
+    def add_to_iterable(self, frame: Dict) -> None:
+        self._queue.append(frame)
+
+    def _max_recording_callback(self) -> None:
+        self.save_queue()
+        # this should normally not be called but if it is,
+        # there is no way to reset recording except by restarting the server
+        self._parameters["recording"] = False