sciveo 0.1.19__tar.gz → 0.1.21__tar.gz

{sciveo-0.1.19 → sciveo-0.1.21}/PKG-INFO

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

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/api/base.py

@@ -26,7 +26,7 @@ class APIRemoteClient:
       base_url = self.config["api_base_url"]
     self.base_url = f"{base_url}/api/v{ver}/"
     self.headers = { "Auth-Token": self.config['secret_access_key'] }
-    debug(type(self).__name__, f"base url: {self.base_url}")
+    debug(f"base url: {self.base_url}")
 
   def POST_SCI(self, content_type, data, timeout=30):
     return self.POST(f"sci/{content_type}/", data, timeout)

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/api/upload.py

@@ -33,17 +33,17 @@ class APIFileUploader:
     file_name = self.local_path.split("/")[-1]
     url_presigned_post = f"aws/s3/presigned_post/?content_type={self.content_type}&file_name={file_name}"
     presigned_post = APIFileUploader.api.GET(url_presigned_post)
-    debug(type(self).__name__, "upload presigned_post", url_presigned_post, "=>", presigned_post)
+    debug("upload presigned_post", url_presigned_post, "=>", presigned_post)
     if "fields" in presigned_post:
       response = None
       with open(self.local_path, 'rb') as fh:
         files = { 'file': (presigned_post['fields']['key'], fh) }
         response = requests.post(presigned_post['url'], data=presigned_post['fields'], files=files)
       if response.status_code == 204:
-        debug(type(self).__name__, self.content_type, self.local_path, "uploaded")
+        debug(self.content_type, self.local_path, "uploaded")
         url_append = f"content/append/?content_type={self.content_type}&name={file_name}&key={presigned_post['fields']['key']}&parent_id={self.parent_guid}"
         result = APIFileUploader.api.GET(url_append)
-        debug(type(self).__name__, "upload", url_append, result, "appended")
+        debug("upload", url_append, result, "appended")
       else:
-        error(type(self).__name__, "upload", self.content_type, self.local_path, "FAIL")
+        error("upload", self.content_type, self.local_path, "FAIL")
 

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/cli.py

@@ -29,6 +29,7 @@ def main():
   parser.add_argument('--block', type=bool, default=True, help='Block flag')
   parser.add_argument('--auth', type=str, default=config['secret_access_key'], help='Auth secret access key')
   parser.add_argument('--timeout', type=float, default=1.0, help='Timeout')
+  parser.add_argument('--net', type=str, default=None, help='Network like 192.168.10.0/24')
   parser.add_argument('--port', type=int, default=22, help='Host port number, used for network ops')
   parser.add_argument('--localhost', type=bool, default=False, help='Add localhost to list of hosts')
   args = parser.parse_args()
@@ -36,7 +37,7 @@ def main():
   if args.command == 'monitor':
     MonitorStart(period=args.period, block=args.block)()
   elif args.command == 'scan':
-    NetworkTools(timeout=args.timeout, localhost=args.localhost).scan_port(port=args.port)
+    NetworkTools(timeout=args.timeout, localhost=args.localhost).scan_port(port=args.port, network=args.net)
   elif args.command == 'init':
     home = os.path.expanduser('~')
     base_path = os.path.join(home, '.sciveo')

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/configuration.py

@@ -72,7 +72,7 @@ class Configuration:
         setattr(self, c, None)
     for k, v in configuration.items():
       setattr(self, k, v)
-    debug(type(self).__name__, "init", configuration)
+    debug("init", configuration)
 
   def set(self, key, value):
     self.configuration[key] = value

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/optimizers.py

@@ -27,7 +27,7 @@ class BaseOptimizer:
     self.use_keys = set(use_keys)
     self.remain_keys = self.keys - self.use_keys
     self.iteration = 0
-    debug(type(self).__name__, "init", self.use_keys, learning_rate, learning_rate_decay)
+    debug("init", self.use_keys, learning_rate, learning_rate_decay)
 
   def x_to_list(self, x1, x2):
     list_x1 = []
@@ -62,7 +62,7 @@ class BaseOptimizer:
     x_new = x1 * (1 + self.learning_rate * grads)
 
     self.on_iteration()
-    # debug(type(self).__name__, self.iteration, "update", [x1.tolist(), y], "x_new", x_new.tolist(), "grads", grads.tolist(), "lr", self.learning_rate)
+    # debug(self.iteration, "update", [x1.tolist(), y], "x_new", x_new.tolist(), "grads", grads.tolist(), "lr", self.learning_rate)
 
     return delta_y, self.list_to_x(x, x_new)
 
@@ -109,6 +109,6 @@ class AdamOptimizer(BaseOptimizer):
     x_new = x1 + self.learning_rate * m_hat / (np.sqrt(v_hat) + self.epsilon)
 
     self.on_iteration()
-    # debug(type(self).__name__, self.iteration, "update", [x1.tolist(), y], "x_new", x_new.tolist(), "grads", grads.tolist(), "lr", self.learning_rate)
+    # debug(self.iteration, "update", [x1.tolist(), y], "x_new", x_new.tolist(), "grads", grads.tolist(), "lr", self.learning_rate)
 
     return delta_y, self.list_to_x(x, x_new)

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/sampling.py

@@ -79,7 +79,7 @@ class BaseSampler:
     for k, v in self.configuration.items():
       sample[k] = self.sample_field(v)
     self.idx += 1
-    # debug(type(self).__name__, "next", sample)
+    # debug("next", sample)
     return Configuration(sample)
 
   def __call__(self):
@@ -149,7 +149,7 @@ class GridSampler(BaseSampler):
     sample = next(self.sample_iterator)
     self.idx += 1
     sample = dict(zip(self.configuration_lists.keys(), sample))
-    # debug(type(self).__name__, "next", sample)
+    # debug("next", sample)
     return Configuration(sample)
 
 
@@ -230,7 +230,7 @@ class AutoSampler(BaseSampler):
   def __next__(self):
     self.idx += 1
     if len(self.project.list_experiments) < self.num_random_samples:
-      debug(type(self).__name__, "next random sample from", type(self.random_sampler).__name__, len(self.project.list_experiments), "from", self.num_random_samples)
+      debug("next random sample from", type(self.random_sampler).__name__, len(self.project.list_experiments), "from", self.num_random_samples)
       return next(self.random_sampler)
     else:
       # Find highest score experiment. Run with close to this current best experiment so to be able to calc gradient.
@@ -240,14 +240,14 @@ class AutoSampler(BaseSampler):
           if E.data["experiment"]["eval"]["score"] > max_score:
             max_score = E.data["experiment"]["eval"]["score"]
             self.best_random_experiment = E
-        debug(type(self).__name__, "next best experiment", E.name, E.data["experiment"]["config"])
+        debug("next best experiment", E.name, E.data["experiment"]["config"])
         new_params = {}
         for k, v in E.data["experiment"]["config"].items():
           if k in self.optimize_keys:
             new_params[k] = v * self.next_sample_ratio
           else:
             new_params[k] = v
-        debug(type(self).__name__, "next sample with ratio", self.next_sample_ratio, new_params)
+        debug("next sample with ratio", self.next_sample_ratio, new_params)
         return Configuration(new_params)
       else:
         # Already have best random experiment and its close experiment
@@ -267,12 +267,12 @@ class AutoSampler(BaseSampler):
 
         for k, v in self.optimize_limits.items():
           if new_params[k] < v[0] or new_params[k] > v[1]:
-            debug(type(self).__name__, "next out of limits", k, new_params[k], v)
+            debug("next out of limits", k, new_params[k], v)
             raise StopIteration
 
         if np.linalg.norm(delta_score) > self.min_delta_score:
-          debug(type(self).__name__, "next", type(self.optimizer).__name__, new_params, [delta_score, self.min_delta_score])
+          debug("next", type(self.optimizer).__name__, new_params, [delta_score, self.min_delta_score])
           return Configuration(new_params)
         else:
-          debug(type(self).__name__, "next small improvement", new_params, "delta", delta_score)
+          debug("next small improvement", new_params, "delta", delta_score)
           raise StopIteration

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/compress.py

@@ -13,7 +13,7 @@ class CompressJsonData:
     json_data = json.dumps(data).encode('utf-8')
     compressed_data = gzip.compress(json_data)
     encoded_data = base64.b64encode(compressed_data).decode('utf-8')
-    debug(type(self).__name__, "compress", len(json_data), "->", len(encoded_data))
+    debug("compress", len(json_data), "->", len(encoded_data))
     return encoded_data
 
   def decompress(self, encoded_data):
@@ -21,6 +21,6 @@ class CompressJsonData:
     decompressed_data = gzip.decompress(compressed_data)
     json_data = decompressed_data.decode('utf-8')
     data = json.loads(json_data)
-    debug(type(self).__name__, "decompress", len(encoded_data), "->", len(json_data))
+    debug("decompress", len(encoded_data), "->", len(json_data))
     return data
 

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/configuration.py

@@ -32,7 +32,7 @@ class GlobalConfiguration:
       self.read_local_files()
       self.read_environment()
     except Exception as e:
-      error(type(self).__name__, "Exception", e)
+      error("Exception", e)
 
   @staticmethod
   def get(name='sciveo', reload=False):

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/daemon.py

@@ -26,12 +26,12 @@ class SignalHandler:
     signal.signal(signal.SIGUSR1, self.handler_usr1)
 
   def handler_int(self, signum, frame):
-    info(type(self).__name__, "INT signal received", signum, frame)
+    info("INT signal received", signum, frame)
     for daemon in self.daemons:
       daemon.stop()
 
   def handler_usr1(self, signum, frame):
-    info(type(self).__name__, "USR1 signal received", signum, frame)
+    info("USR1 signal received", signum, frame)
 
 
 class DaemonBase:
@@ -73,14 +73,14 @@ class DaemonBase:
       try:
         self.loop()
       except Exception as e:
-        error(type(self).__name__, e)
+        error(e)
       time.sleep(self.period)
 
   def safe_run(self):
     try:
       self.run()
     except Exception as e:
-      error(type(self).__name__, e)
+      error(e)
 
 
 class TasksDaemon(DaemonBase):

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/logger.py

@@ -11,6 +11,7 @@
 
 import os
 import logging
+import inspect
 from threading import Lock
 
 from sciveo.common.tools.configuration import GlobalConfiguration
@@ -35,15 +36,22 @@ def _sciveo_get_logger(name):
         logger.propagate = False
   return logger
 
+def _sciveo_append_classname(*args):
+  frame = inspect.currentframe().f_back.f_back
+  class_name = frame.f_locals.get('self', None).__class__.__name__ if 'self' in frame.f_locals else None
+  if class_name is not None:
+    args = (class_name,) + args
+  return args
+
 def debug(*args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).debug(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).debug(_sciveo_append_classname(*args))
 def info(*args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).info(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).info(_sciveo_append_classname(*args))
 def warning(*args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).warning(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).warning(_sciveo_append_classname(*args))
 def error(*args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).error(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).error(_sciveo_append_classname(*args))
 def critical(*args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).critical(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).critical(_sciveo_append_classname(*args))
 def exception(e, *args):
-  _sciveo_get_logger(SCIVEO_LOGGER_NAME).exception(args)
+  _sciveo_get_logger(SCIVEO_LOGGER_NAME).exception(_sciveo_append_classname(*args))

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/remote.py

@@ -22,7 +22,7 @@ from sciveo.common.tools.compress import CompressJsonData
 
 class PredictorRemoteClient:
   def __init__(self, url="http://localhost:8901", verify=True, auth_token=None, api_prefix=None):
-    debug(type(self).__name__, "init url", url, verify)
+    debug("init url", url, verify)
     config = GlobalConfiguration.get()
     if auth_token is None:
       auth_token = config["api_auth_token"]
@@ -36,7 +36,7 @@ class PredictorRemoteClient:
 
   def predict(self, params):
     try:
-      debug(type(self).__name__, "predict", params)
+      debug("predict", params)
       headers = {"Authorization": f"Bearer {self.auth_token}"}
       response = requests.post(self.url, json=params, headers=headers, verify=self.verify)
 
@@ -48,10 +48,10 @@ class PredictorRemoteClient:
           predicted = CompressJsonData().decompress(predicted)
           data[params["predictor"]] = predicted
       else:
-        error(type(self).__name__, f"Request [{self.url}] failed with status code {response.status_code}")
+        error(f"Request [{self.url}] failed with status code {response.status_code}")
         data = {"error": response.status_code}
     except Exception as e:
-      exception(type(self).__name__, "predict", e)
+      exception("predict", e)
       data = {"error": str(e)}
     return data
 

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/common/tools/timers.py

@@ -25,7 +25,7 @@ class FPSCounter:
     self.n += 1
     t2 = time.time()
     if t2 - self.t1 > self.period:
-      debug(type(self).__name__, self.tag, "FPS", self.n / (t2 - self.t1))
+      debug(self.tag, "FPS", self.n / (t2 - self.t1))
       self.n = 0
       self.t1 = time.time()
 

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/content/experiment.py

@@ -54,7 +54,7 @@ class Experiment:
     # TODO: Consider better experiment naming
     # perhaps include some eval
     self.name = self.config.name
-    debug(type(self).__name__, "init", self.name)
+    debug("init", self.name)
 
   def on_guid(self, guid):
     self.guid = guid
@@ -66,7 +66,7 @@ class Experiment:
     self.data["experiment"]["end_at"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     self.data["experiment"]["elapsed"] = format_elapsed_time(self.elapsed)
     self.data["experiment"]["dataset"] = Dataset.get().info
-    debug(type(self).__name__, "close", self.name)
+    debug("close", self.name)
 
   def append(self, d):
     self.data["experiment"]["log"].append(d)
@@ -152,14 +152,14 @@ class RemoteExperiment(Experiment):
     else:
       remote_data["project_name"] = self.project_name
     result = self.api.POST_SCI("experiment", remote_data)
-    debug(type(self).__name__, "init", self.name, "api", result)
+    debug("init", self.name, "api", result)
     if result and "error" not in result:
       if result["name"] == self.name:
         self.on_guid(result["guid"])
       else:
-        error(type(self).__name__, "Project name mismatch", result, self.name)
+        error("Project name mismatch", result, self.name)
     else:
-      error(type(self).__name__, "init", self.name, "api", result)
+      error("init", self.name, "api", result)
 
   def close(self):
     super().close()
@@ -169,7 +169,7 @@ class RemoteExperiment(Experiment):
       "data": self.data
     }
     result = self.api.POST_SCI("experiment", remote_data)
-    debug(type(self).__name__, "close", self.name, "api", result)
+    debug("close", self.name, "api", result)
 
   def on_guid(self, guid):
     super().on_guid(guid)
@@ -179,7 +179,7 @@ class RemoteExperiment(Experiment):
     if self.guid is not None:
       UPLOAD(content_type, local_path, self.guid)
     else:
-      error(type(self).__name__, "upload", local_path)
+      error("upload", local_path)
   def upload_image(self, local_path):
     self.upload("image", local_path)
   def upload_file(self, local_path):

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/content/project.py

@@ -40,15 +40,15 @@ class ProjectBase:
       }
     }
 
-    debug(type(self).__name__, "init", self.project_name)
+    debug("init", self.project_name)
 
   def open(self):
-    debug(type(self).__name__, "open", self.project_name)
+    debug("open", self.project_name)
     self.current_experiment = Experiment(self.project_name, self.guid, self.config)
     return self.current_experiment
 
   def close(self):
-    debug(type(self).__name__, "close", self.project_name)
+    debug("close", self.project_name)
     self.project_data["project"]["dataset"] = Dataset.get().info
     self.current_experiment.close()
     self.list_experiments.append(self.current_experiment)
@@ -76,18 +76,18 @@ class RemoteProject(ProjectBase):
     if parent_id is not None:
       remote_data["parent_id"] = parent_id
     result = self.api.POST_SCI("project", remote_data)
-    debug(type(self).__name__, "init api", result)
+    debug("init api", result)
     if result and "error" not in result:
       if result["name"] == project_name:
         self.guid = result["guid"]
         self.list_content_size = result["list_content_size"]
       else:
-        error(type(self).__name__, "Project name mismatch", result, project_name)
+        error("Project name mismatch", result, project_name)
     else:
-      error(type(self).__name__, "api", remote_data, result)
+      error("api", remote_data, result)
 
   def open(self):
-    debug(type(self).__name__, "open", self.project_name)
+    debug("open", self.project_name)
     self.current_experiment = RemoteExperiment(self.project_name, self.guid, self.config)
     return self.current_experiment
 
@@ -101,7 +101,7 @@ class RemoteProject(ProjectBase):
       "data": self.project_data
     }
     result = self.api.POST_SCI("project", remote_data)
-    debug(type(self).__name__, "close", self.project_name, "api", result)
+    debug("close", self.project_name, "api", result)
 
 
 class LocalProject(ProjectBase):

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/content/runner.py

@@ -48,7 +48,7 @@ class ProjectRunner:
     else:
       self.configuration_sampler = RandomSampler(configuration)
 
-    debug(type(self).__name__, f"start remote[{remote}] count[{self.count}] sampler[{sampler}]", configuration)
+    debug(f"start remote[{remote}] count[{self.count}] sampler[{sampler}]", configuration)
 
   def get(self, a):
     return self.kwargs.get(a, self.arguments[a])
@@ -66,5 +66,5 @@ class ProjectRunner:
 
       self.project.config = configuration_sample
       self.project.config.set_name(f"[{self.project.list_content_size + i + 1}]")
-      debug(type(self).__name__, "run", i, self.project.config)
+      debug("run", i, self.project.config)
       self.function()

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/monitoring/monitor.py

@@ -73,7 +73,7 @@ class BaseMonitor(DaemonBase):
 
     self.data["serial"] = MonitorTools.serial()
 
-    debug(type(self).__name__, f"init monitor with period={period}", self.data["serial"], "initial_cpu_usage", initial_cpu_usage)
+    debug(f"init monitor with period={period}", self.data["serial"], "initial_cpu_usage", initial_cpu_usage)
 
   def __call__(self):
     return self.data
@@ -91,7 +91,7 @@ class BaseMonitor(DaemonBase):
 
     api_result = self.api.POST_SCI("monitor", {"data": self.data})
 
-    debug(type(self).__name__, self(), "api_result", api_result)
+    debug(self(), "api_result", api_result)
 
   def tail_logs(self):
     for log_name, log_path in self.list_logs:

sciveo-0.1.21/sciveo/network/sniffer.py

@@ -0,0 +1,75 @@
+#
+# 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.
+#
+# 2024
+#
+
+import socket
+import threading
+from scapy.all import sniff, IP, TCP
+
+from sciveo.common.tools.logger import *
+from sciveo.common.tools.timers import Timer
+
+
+class StreamSniffer:
+  def __init__(self, iface=None):
+    self.iface = iface
+    self.running = False
+    self.lock = threading.Lock()
+    self.streams = {}
+
+  def start(self):
+    self.running = True
+    self.sniff_thread = threading.Thread(target=self.sniff_packets)
+    self.sniff_thread.start()
+
+  def stop(self):
+    debug("stopping...")
+    self.running = False
+    self.sniff_thread.join()
+
+  def sniff_packets(self):
+    debug("start sniffing on", self.iface)
+    sniff(iface=self.iface, prn=self.on_packet, stop_filter=self.should_stop)
+
+  def on_packet(self, packet):
+    if IP in packet:
+      self.append_ip_packet(packet)
+
+  def should_stop(self, packet):
+    return not self.running
+
+  def append_ip_packet(self, packet):
+    ip_src = packet[IP].src
+    with self.lock:
+      self.streams.setdefault(ip_src, [])
+      self.streams[ip_src].append(packet)
+
+  def get_ip_stream(self, ip):
+    current_packets = []
+    with self.lock:
+      if ip in self.streams:
+        current_packets = self.streams[ip][:]
+        self.streams[ip] = []
+    return current_packets
+
+  def keys(self):
+    with self.lock:
+      return list(self.streams.keys())
+
+
+if __name__ == "__main__":
+  # debug(NetworkTools(timeout=1.0, localhost=False).scan_port(port=9901))
+
+  import time
+  sniffer = StreamSniffer(iface="en0")
+  sniffer.start()
+  time.sleep(5)
+  sniffer.stop()
+  debug(sniffer.keys())

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo/network/tools.py

@@ -10,8 +10,8 @@
 #
 
 import socket
+import ipaddress
 import threading
-from scapy.all import sniff, IP, TCP
 
 from sciveo.common.tools.logger import *
 from sciveo.common.tools.timers import Timer
@@ -48,7 +48,7 @@ class NetworkTools:
             if ip.startswith(net_class):
               list_local_ips.append(ip)
     except Exception as e:
-      warning(type(self).__name__, "netifaces not installed")
+      warning("netifaces not installed")
     return list_local_ips
 
   def generate_ip_list(self, base_ip):
@@ -56,18 +56,27 @@ class NetworkTools:
     network_prefix = '.'.join(octets[:3])
     return [f'{network_prefix}.{i}' for i in range(1, 255)]
 
-  def scan_port(self, port=22):
+  def scan_port(self, port=22, network=None):
     t = Timer()
-    list_local_ips = self.get_local_nets()
-    # debug(type(self).__name__, "scan_port", "list_local_ips", list_local_ips)
     self.data["scan"].setdefault(port, [])
-    for local_ip in list_local_ips:
-      list_ip = self.generate_ip_list(local_ip)
+
+    if network is None:
+      list_local_ips = self.get_local_nets()
+      # debug("scan_port", "list_local_ips", list_local_ips)
+      for local_ip in list_local_ips:
+        list_ip = self.generate_ip_list(local_ip)
+        self.scan_port_hosts(list_ip, port)
+    else:
+      list_ip = []
+      net = ipaddress.ip_network(network, strict=False)
+      for ip in net.hosts():
+        list_ip.append(str(ip))
       self.scan_port_hosts(list_ip, port)
+
     if self.arguments["localhost"]:
       self.scan_port_hosts(["127.0.0.1"], port)
     self.data["scan"][port].sort(key=lambda ip: int(ip.split('.')[-1]))
-    debug(type(self).__name__, f"scan_port [{port}] elapsed time {t.stop():.1f}s", self.data["scan"][port])
+    debug(f"scan_port [{port}] elapsed time {t.stop():.1f}s", self.data["scan"][port])
     return self.data["scan"][port]
 
   def scan_port_hosts(self, list_ip, port=22):
@@ -88,64 +97,6 @@ class NetworkTools:
         if result == 0:
           with self.data_lock:
             self.data["scan"][port].append(ip)
-        # debug(type(self).__name__, "scan_ports", ip, port, result)
+        # debug("scan_ports", ip, port, result)
     except socket.error:
       pass
-
-
-class StreamSniffer:
-  def __init__(self, iface=None):
-    self.iface = iface
-    self.running = False
-    self.lock = threading.Lock()
-    self.streams = {}
-
-  def start(self):
-    self.running = True
-    self.sniff_thread = threading.Thread(target=self.sniff_packets)
-    self.sniff_thread.start()
-
-  def stop(self):
-    debug(type(self).__name__, "stopping...")
-    self.running = False
-    self.sniff_thread.join()
-
-  def sniff_packets(self):
-    debug(type(self).__name__, "start sniffing on", self.iface)
-    sniff(iface=self.iface, prn=self.on_packet, stop_filter=self.should_stop)
-
-  def on_packet(self, packet):
-    if IP in packet:
-      self.append_ip_packet(packet)
-
-  def should_stop(self, packet):
-    return not self.running
-
-  def append_ip_packet(self, packet):
-    ip_src = packet[IP].src
-    with self.lock:
-      self.streams.setdefault(ip_src, [])
-      self.streams[ip_src].append(packet)
-
-  def get_ip_stream(self, ip):
-    current_packets = []
-    with self.lock:
-      if ip in self.streams:
-        current_packets = self.streams[ip][:]
-        self.streams[ip] = []
-    return current_packets
-
-  def keys(self):
-    with self.lock:
-      return list(self.streams.keys())
-
-
-if __name__ == "__main__":
-  # debug(NetworkTools(timeout=1.0, localhost=False).scan_port(port=9901))
-
-  import time
-  sniffer = StreamSniffer(iface="en0")
-  sniffer.start()
-  time.sleep(5)
-  sniffer.stop()
-  debug(sniffer.keys())

sciveo-0.1.21/sciveo/network/tunnel.py

@@ -0,0 +1,17 @@
+#
+# 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.
+#
+# 2024
+#
+
+
+import os
+import subprocess
+
+from sciveo.common.tools.logger import *
+

sciveo-0.1.21/sciveo/version.py

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

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo.egg-info/PKG-INFO

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

{sciveo-0.1.19 → sciveo-0.1.21}/sciveo.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ sciveo/monitoring/monitor.py
 sciveo/monitoring/start.py
 sciveo/network/__init__.py
 sciveo/network/camera.py
+sciveo/network/sniffer.py
 sciveo/network/tools.py
 sciveo/network/tunnel.py
 test/test_compress.py

{sciveo-0.1.19 → sciveo-0.1.21}/test/test_sampling.py

@@ -247,7 +247,7 @@ class TestSamplerAuto(unittest.TestCase):
       E.score(i * 0.0001)
       E.name = f"E[{i}]"
       project.close()
-      # debug(type(self).__name__, i, configuration_sample.configuration)
+      # debug(i, configuration_sample.configuration)
       if i > 5:
         break
 

sciveo-0.1.19/sciveo/network/tunnel.py

@@ -1,131 +0,0 @@
-#
-# 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.
-#
-# 2024
-#
-
-
-import os
-import subprocess
-
-from sciveo.common.tools.logger import *
-
-
-class WireGuardBase:
-  def __init__(self, interface='wg0'):
-    self.interface = interface
-    self.config_path = f'/etc/wireguard/{self.interface}.conf'
-    self.private_key = None
-    self.public_key = None
-
-  def _run_command(self, command):
-    try:
-      result = subprocess.run(command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-      return result.stdout.decode().strip()
-    except subprocess.CalledProcessError as e:
-      debug(type(self).__name__, f"Error executing command: {e.stderr.decode().strip()}")
-      return None
-
-  def generate_keys(self, private_key_path=None, public_key_path=None):
-    # Generate the private key
-    self.private_key = self._run_command("wg genkey")
-    if not self.private_key:
-      raise Exception("Failed to generate private key.")
-
-    # Generate the public key from the private key
-    self.public_key = self._run_command(f"echo {self.private_key} | wg pubkey")
-    if not self.public_key:
-      raise Exception("Failed to generate public key.")
-
-    # Optionally save the keys to files
-    if private_key_path:
-      with open(private_key_path, 'w') as f:
-        f.write(self.private_key)
-      debug(type(self).__name__, f"Private key saved to {private_key_path}")
-
-    if public_key_path:
-      with open(public_key_path, 'w') as f:
-        f.write(self.public_key)
-      debug(type(self).__name__, f"Public key saved to {public_key_path}")
-
-    return self.private_key, self.public_key
-
-  def start(self):
-    debug(type(self).__name__, f"Starting WireGuard interface {self.interface}...")
-    return self._run_command(f'sudo systemctl start [email protected]{self.interface}')
-
-  def stop(self):
-    debug(type(self).__name__, f"Stopping WireGuard interface {self.interface}...")
-    return self._run_command(f'sudo systemctl stop [email protected]{self.interface}')
-
-  def restart(self):
-    debug(type(self).__name__, f"Restarting WireGuard interface {self.interface}...")
-    return self._run_command(f'sudo systemctl restart [email protected]{self.interface}')
-
-  def status(self):
-    debug(type(self).__name__, f"Checking status of WireGuard interface {self.interface}...")
-    return self._run_command(f'sudo systemctl status [email protected]{self.interface}')
-
-class WGServer(WireGuardBase):
-  def init(self, private_key=None, listen_port=51820, address='192.168.21.1/24'):
-    if not private_key:
-      private_key = self.private_key
-    config = f"""
-    [Interface]
-    Address = {address}
-    ListenPort = {listen_port}
-    PrivateKey = {private_key}
-    SaveConfig = true
-    """
-    with open(self.config_path, 'w') as config_file:
-      config_file.write(config.strip())
-    debug(type(self).__name__, f"Server configuration written to {self.config_path}")
-
-  def add_peer(self, peer_public_key, allowed_ips):
-    peer_config = f"""
-    [Peer]
-    PublicKey = {peer_public_key}
-    AllowedIPs = {allowed_ips}
-    """
-    with open(self.config_path, 'a') as config_file:
-      config_file.write(peer_config.strip())
-    debug(type(self).__name__, f"Added peer with PublicKey: {peer_public_key}")
-
-class WGClient(WireGuardBase):
-  def init(self, private_key=None, server_public_key=None, endpoint=None, address='192.168.21.2/24', allowed_ips='0.0.0.0/0', keepalive=25):
-    if not private_key:
-      private_key = self.private_key
-    config = f"""
-    [Interface]
-    Address = {address}
-    PrivateKey = {private_key}
-
-    [Peer]
-    PublicKey = {server_public_key}
-    Endpoint = {endpoint}
-    AllowedIPs = {allowed_ips}
-    PersistentKeepalive = {keepalive}
-    """
-    with open(self.config_path, 'w') as config_file:
-      config_file.write(config.strip())
-    debug(type(self).__name__, f"Client configuration written to {self.config_path}")
-
-
-if __name__ == "__main__":
-  server = WGServer(interface='wg0')
-  server.generate_keys(private_key_path='/etc/wireguard/server_private.key', public_key_path='/etc/wireguard/server_public.key')
-  server.init(private_key=server.private_key, listen_port=51820, address='192.168.21.1/24')
-  server.add_peer(peer_public_key='<client_public_key>', allowed_ips='192.168.21.2/32')
-  server.start()
-  debug(type(self).__name__, server.status())
-
-  # client = WGClient(interface='wg0')
-  # client.generate_keys(private_key_path='/etc/wireguard/client_private.key', public_key_path='/etc/wireguard/client_public.key')
-  # client.init(private_key=client.private_key, server_public_key='<server_public_key>', endpoint='<server_ip>:51820')
-  # client.start()
-  # debug(type(self).__name__, client.status())

sciveo-0.1.19/sciveo/version.py

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