naeural-core 7.7.246__tar.gz → 7.7.247__tar.gz

{naeural_core-7.7.246 → naeural_core-7.7.247}/AGENTS.md

@@ -32,4 +32,5 @@ Latest:
 - `2026-02-02`: Comms send/recv queues are bounded deques (1000); when MQTT is down, one message is popped and retried while queues fill/drop, and the main loop will shut down once retries exceed `CONN_MAX_RETRY_ITERS` unless bypassed (see `naeural_core/comm` + `naeural_core/main/orchestrator.py`).
 - `2026-02-02`: Correction: comm send loops pop from `_send_buff` even when disconnected, so messages may be dropped while offline; buffering is best-effort (see `naeural_core/comm/mixins`).
 - `2026-02-04`: Business plugin instantiation runs inside the main loop (`naeural_core/business/business_manager.py` `_check_instances`), so `_get_module_name_and_class` plus plugin config/validation/inspect checks can stall the loop; heavy imports or safety checks show up as startup latency.
+- `2026-02-04`: Plugin discovery in `ratio1._PluginsManagerMixin._get_plugin_by_name` walks the filesystem (`Logger.get_all_subfolders`) and safety checks call `inspect.getsource` + code scanning; first load per signature can be expensive if many distinct plugins.
 - `2026-02-05`: Comm failure triggers main-loop shutdown only when `WORK_OFFLINE` is false; failure is `comm._nr_conn_retry_iters > CONN_MAX_RETRY_ITERS` (incremented on server connect failures, reset on success) and comm threads sleep `CONNECTION_FAIL_SLEEP_TIME` between retries, so shutdown is delayed until retries exceed the threshold (see `naeural_core/comm/default/mqtt.py`, `naeural_core/comm/base/base_comm_thread.py`, `naeural_core/main/orchestrator.py`).

{naeural_core-7.7.246 → naeural_core-7.7.247}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: naeural_core
-Version: 7.7.246
+Version: 7.7.247
 Summary: Ratio1 Core is the backbone of the Ratio1 Edge Protocol.
 Project-URL: Homepage, https://github.com/Ratio1/naeural_core
 Project-URL: Bug Tracker, https://github.com/Ratio1/naeural_core/issues

naeural_core-7.7.247/docs/business_manager.md

@@ -0,0 +1,70 @@
+# Business Manager Findings
+
+## Scope
+This note focuses on `BusinessManager._check_instances()` and the critical path for plugin discovery, loading, and configuration. It summarizes current bottlenecks observed during stress testing and the improvement ideas discussed so far. It also records recently added optional optimizations (flag‑gated) for config handler creation and validation.
+
+## Critical Path (New Instance)
+`BusinessManager._check_instances()` → `Manager._get_module_name_and_class()` → `ratio1._PluginsManagerMixin._get_module_name_and_class()` → plugin class `__init__` → `BasePluginExecutor.startup()` → `_instance_init()` → `_update_instance_config()` → `setup_config_and_validate()` → `create_config_handlers()` + `validate()` → `_create_alert_state_machine()` + `timebins_create_bin()` + `init_plugins_shared_memory()`.
+
+## Observed Timing Behavior
+- First instance: `get_class` dominates (~1–2s) for cold discovery.
+- Later instances (e.g., 71st/79): `get_class` and `init` can grow significantly (8–9s + 15–17s), with total cumulative time exceeding 10 minutes.
+- The `(ALL=...)` in logs is cumulative time since start of `_check_instances()`.
+
+## Primary Bottlenecks
+1. **Plugin discovery and import**
+   - `_get_plugin_by_name()` walks filesystem and uses `find_spec` for each candidate.
+   - Safety check (`inspect.getsource` + code scan) is executed per unique signature even on unsecured nodes.
+   - `sys.modules` is forcibly cleared on load in ratio1, preventing reuse of import cache.
+
+2. **Plugin initialization**
+   - `BasePluginExecutor.startup()` invokes `_instance_init()` and `_update_instance_config()` in the main loop.
+   - Config handling involves deep merge + dynamic property creation + reflection for validation.
+
+3. **Shared memory initialization**
+   - `SharedMemoryManager.reset()` and link checks can add per‑instance overhead.
+
+4. **Logging overhead**
+   - Per‑instance logs add measurable time when many instances are created.
+
+## Implemented Improvements (Flag‑Gated)
+### 1) Cache config handlers
+File: `naeural_core/local_libraries/config_handler_mixin.py`
+- Flag: `BM_CACHE_CONFIG_HANDLERS` (global config)
+- Behavior: caches already created config keys per class and pre‑creates BasePluginExecutor base keys once using MRO lookup.
+- Default: off (rollback by setting flag false).
+
+### 2) Cache validation method list
+File: `naeural_core/local_libraries/config_handler_mixin.py`
+- Flag: `BM_CACHE_VALIDATORS` (global config)
+- Behavior: caches `validate_*` methods per class; avoids repeated reflection.
+- Default: off (rollback by setting flag false).
+
+## Proposed Improvements (Drafts)
+### A) Pre‑index plugin discovery
+- Flag: `BM_PREINDEX_PLUGINS` (global config)
+- Idea: one `os.walk()` per plugin location to build `{signature_snake: module_path}` map. Fall back to old search on miss.
+- Benefit: remove repeated filesystem traversal per signature.
+
+### B) Cache safety checks
+- Flag: `BM_CACHE_SAFETY_CHECK`
+- Idea: cache `(is_good, msg)` per module name to skip repeated `inspect.getsource` and code scan.
+
+### C) Skip forced module reload
+- Flag: `BM_SKIP_MODULE_RELOAD`
+- Idea: avoid `del sys.modules[_module_name]` for repeat loads.
+
+### D) Limit new instance creation per loop
+- Flag: `BM_MAX_NEW_INSTANCES_PER_TICK` (0 = unlimited)
+- Idea: reduce long stalls by processing new instances in batches.
+
+### E) Reduce verbosity
+- Flag: `BM_VERBOSE_START_LOGS` (default true)
+- Idea: summary logging rather than per‑instance logs.
+
+## Notes
+- Safety checks run even on unsecured nodes; they simply do not block loading.
+- Circular import issues in test scripts can be avoided by pre‑importing `naeural_core.serving` and `naeural_core.serving.ai_engines` before loading `BasePluginExecutor` subclasses.
+
+## Configuration
+All new optimizations are intended to be controlled from global config (`self.log.config_data`) for easy rollback.

{naeural_core-7.7.246 → naeural_core-7.7.247}/naeural_core/local_libraries/config_handler_mixin.py

@@ -208,8 +208,58 @@ class _ConfigHandlerMixin(object):
 
   
   def create_config_handlers(self, verbose=0):    
-    if hasattr(self, 'config_data') and isinstance(self.config_data, dict) and len(self.config_data) > 0:
-      res = []
+    if not (hasattr(self, 'config_data') and isinstance(self.config_data, dict) and len(self.config_data) > 0):
+      return
+
+    cache_enabled = False
+    if hasattr(self, 'log') and hasattr(self.log, 'config_data'):
+      cache_enabled = self.log.config_data.get('BM_CACHE_CONFIG_HANDLERS', False)
+
+    res = []
+    cls = type(self)
+
+    if cache_enabled:
+      # 1) Ensure BasePluginExecutor base keys are created once (no import)
+      base_cls = next((c for c in cls.mro() if c.__name__ == "BasePluginExecutor"), None)
+      if base_cls is not None:
+        base_created = getattr(base_cls, '_cfg_keys_created', None)
+        if base_created is None:
+          base_created = set()
+          setattr(base_cls, '_cfg_keys_created', base_created)
+
+        base_cfg = getattr(base_cls, 'CONFIG', {}) or {}
+        base_keys = set(base_cfg.keys())
+        missing_base = base_keys - base_created
+
+        for k in missing_base:
+          func_name = self._get_prop(k)
+          if not hasattr(base_cls, func_name):
+            fnc = partial(getter, key=k) # create the func
+            fnc_prop = property(fget=fnc, doc="Get '{}' from config_data".format(k)) # create prop from func 
+            setattr(base_cls, func_name, fnc_prop) # set the prop of the class
+          base_created.add(k)
+
+      # 2) Per-subclass cache for extra keys
+      created_keys = getattr(cls, '_cfg_keys_created', None)
+      if created_keys is None:
+        created_keys = set()
+        setattr(cls, '_cfg_keys_created', created_keys)
+
+      current_keys = set(self.config_data.keys())
+      missing_keys = current_keys - created_keys
+
+      for k in missing_keys:
+        func_name = self._get_prop(k)
+        if not hasattr(cls, func_name):
+          # below is a bit tricky: using a lambda generates a non-deterministic abnormal behavior
+          # the ideea is to create a global func instance that wil be then loaded on the class (not instance)
+          # as a descriptor object - ie a `property`. "many Bothans died to bring the plans of the Death Star..."
+          fnc = partial(getter, key=k) # create the func
+          fnc_prop = property(fget=fnc, doc="Get '{}' from config_data".format(k)) # create prop from func 
+          setattr(cls, func_name, fnc_prop) # set the prop of the class
+          res.append(func_name)
+        created_keys.add(k)
+    else:
       for k in self.config_data:
         func_name = self._get_prop(k)
         if not hasattr(self, func_name):
@@ -217,13 +267,13 @@ class _ConfigHandlerMixin(object):
           # the ideea is to create a global func instance that wil be then loaded on the class (not instance)
           # as a descriptor object - ie a `property`. "many Bothans died to bring the plans of the Death Star..."
           fnc = partial(getter, key=k) # create the func
-          cls = type(self) # get the class
           fnc_prop = property(fget=fnc, doc="Get '{}' from config_data".format(k)) # create prop from func 
           setattr(cls, func_name, fnc_prop) # set the prop of the class
           res.append(func_name)
-      if len(res) > 0 and verbose > 1:
-        self.P("Created '{}' config_data handlers: {}".format(self.__class__.__name__, res), color='b')
-      self.__cfg_ready = True
+
+    if len(res) > 0 and verbose > 1:
+      self.P("Created '{}' config_data handlers: {}".format(self.__class__.__name__, res), color='b')
+    self.__cfg_ready = True
     return
   
   
@@ -480,12 +530,34 @@ class _ConfigHandlerMixin(object):
     for msg in fail_msgs:
       self.add_error(msg)
 
-    for method_name, func in self.log.get_class_methods(self.__class__, include_parent=True):
-      if method_name.startswith('validate_'):
+    cache_enabled = False
+    if hasattr(self, 'log') and hasattr(self.log, 'config_data'):
+      cache_enabled = self.log.config_data.get('BM_CACHE_VALIDATORS', False)
+
+    if cache_enabled:
+      cls = self.__class__
+      validators = getattr(cls, "_cfg_validators", None)
+      if validators is None:
+        validators = []
+        for method_name, func in self.log.get_class_methods(cls, include_parent=True):
+          if method_name.startswith('validate_'):
+            validators.append(func)
+        setattr(cls, "_cfg_validators", validators)
+
+      for func in validators:
         try:
           func(self)
         except:
-          self.add_error("Programming error in validation method '{}'.\n{}".format(method_name, traceback.format_exc()))
+          self.add_error("Programming error in validation method '{}'.\n{}".format(
+            func.__name__, traceback.format_exc()))
+    else:
+      for method_name, func in self.log.get_class_methods(self.__class__, include_parent=True):
+        if method_name.startswith('validate_'):
+          try:
+            func(self)
+          except:
+            self.add_error("Programming error in validation method '{}'.\n{}".format(
+              method_name, traceback.format_exc()))
 
     lst_errors = self.get_errors()
     lst_warnings = self.get_warnings()

{naeural_core-7.7.246 → naeural_core-7.7.247}/naeural_core/main/ver.py

@@ -1,4 +1,4 @@
-__VER__ = '7.7.246'
+__VER__ = '7.7.247'
 
 
 

{naeural_core-7.7.246 → naeural_core-7.7.247}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "naeural_core"
-version = "7.7.246"
+version = "7.7.247"
 authors = [
   { name="Andrei Ionut Damian", email="andrei.damian@me.com" },
   { name="Cristan Bleotiu", email="cristibleotiu@gmail.com" },