some fixes

Author: deeleeramone

cookiecutter/openbb_cookiecutter/template/{{cookiecutter.project_tag}}/pyproject.toml

@@ -31,3 +31,4 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry.plugins."openbb_obbject_extension"]
 to_string = "{{ cookiecutter.package_name }}.obbject.{{ cookiecutter.obbject_name }}:ext"
 {{ cookiecutter.obbject_name }} = "{{ cookiecutter.package_name }}.obbject.{{ cookiecutter.obbject_name }}:class_ext"
+nonblocking_plugin = "{{ cookiecutter.package_name }}.obbject.{{ cookiecutter.obbject_name }}:nonblocking_plugin"

cookiecutter/openbb_cookiecutter/template/{{cookiecutter.project_tag}}/{{cookiecutter.package_name}}/obbject/{{cookiecutter.obbject_name}}/__init__.py

@@ -2,7 +2,8 @@
 
 # pylint: disable=W0613,R0903
 
-import json
+import threading
+import time
 
 from openbb_core.app.model.extension import Extension
 from openbb_core.app.model.obbject import OBBject
@@ -40,3 +41,43 @@ def __init__(self, obbject: OBBject):
     def hello_world(self, **kwargs):
         """Say hello from the OBBject extension."""
         print(f"Hello from the OBBject instance! \n\n{repr(self._obbject)}")  # noqa
+
+
+nonblocking_plugin = Extension(
+    name="nonblocking_plugin",
+    description="An on-command-output plugin simulating an extensive task performed in a separate thread.",
+    on_command_output=True,  # Must be set as True
+    command_output_paths=["/{{cookiecutter.router_name}}/candles"],
+    immutable=True,  # Set to `True` for parallel processing.
+    results_only=False,  # Use this as a flag to return only the "results" portion of the OBBject.
+)
+
+
+def _expensive_operation_worker(serialized_obbject: dict):
+    """Simulate a long-running task without blocking the caller."""
+    working_copy = OBBject(**serialized_obbject)
+    print("\nThis is the deserialized OBBject in the non-blocking thread.")
+    print(working_copy.__repr__())
+    for i in range(10):
+        print(str(i) + " seconds remaining...")
+        time.sleep(1)
+    print("Expensive operation is now complete.")
+
+
+@nonblocking_plugin.obbject_accessor
+def empty_plugin_function(obbject):  # This can also be an async function.
+    """Simulated on_commnd_output function that executes an expensive task
+    in a non-blocking thread."""
+    print(
+        "Serializing the obbject and passing to a new thread.\n"
+        f"Command executed: {obbject.extra['metadata']}\n"
+    )
+    print(
+        "Simulating an expensive task that is non-blocking and allows the function to return."
+    )
+    threading.Thread(
+        target=_expensive_operation_worker,
+        args=(obbject.model_dump(),),
+        name="empty-plugin-expensive-operation",
+        daemon=False,
+    ).start()

openbb_platform/core/openbb_core/app/command_runner.py

@@ -1,7 +1,6 @@
 """Command runner module."""
 
 # pylint: disable=R0903
-
 from collections.abc import Callable
 from copy import deepcopy
 from dataclasses import asdict, is_dataclass
@@ -15,6 +14,7 @@
 from openbb_core.app.extension_loader import ExtensionLoader
 from openbb_core.app.model.abstract.error import OpenBBError
 from openbb_core.app.model.abstract.warning import OpenBBWarning, cast_warning
+from openbb_core.app.model.extension import CachedAccessor
 from openbb_core.app.model.metadata import Metadata
 from openbb_core.app.model.obbject import OBBject
 from openbb_core.app.provider_interface import ExtraParams
@@ -448,13 +448,13 @@ async def run(
                     raise OpenBBError(e) from e
                 warn(str(e), OpenBBWarning)
 
-        try:
-            cls._trigger_command_output_callbacks(route, obbject)
-
-        except Exception as e:
-            if Env().DEBUG_MODE:
-                raise OpenBBError(e) from e
-            warn(str(e), OpenBBWarning)
+        if isinstance(obbject, OBBject):
+            try:
+                cls._trigger_command_output_callbacks(route, obbject)
+            except Exception as e:
+                if Env().DEBUG_MODE:
+                    raise OpenBBError(e) from e
+                warn(str(e), OpenBBWarning)
 
         return obbject
 
@@ -463,7 +463,8 @@ def _trigger_command_output_callbacks(cls, route: str, obbject: OBBject) -> None
         """Trigger command output callbacks for extensions."""
         loader = ExtensionLoader()
         callbacks = loader.on_command_output_callbacks
-        results_only = False
+        if not callbacks:
+            return
 
         # For each extension registered for all routes or the specific route,
         # we call its accessor on the OBBject.
@@ -473,53 +474,93 @@ def _trigger_command_output_callbacks(cls, route: str, obbject: OBBject) -> None
         # mutates the OBBject so we can pass this information to the interface.
         # We also set the _results_only attribute to True if any extension
         # indicates that only results should be returned.
-        if "*" in callbacks:
-            for ext in callbacks["*"]:
-                if ext.results_only is True:
-                    results_only = True
-                if ext.immutable is True:
-                    if hasattr(obbject, ext.name):
-                        obbject_copy = deepcopy(obbject)
-                        accessor = getattr(obbject_copy, ext.name)
-                        if iscoroutinefunction(accessor):
-                            run_async(accessor)
-                        elif callable(accessor):
-                            accessor()
-                elif ext.immutable is False:
-                    if ext.results_only is True:
-                        results_only = True
-                    if hasattr(obbject, ext.name):
-                        accessor = getattr(obbject, ext.name)
-                        if iscoroutinefunction(accessor):
-                            run_async(accessor)
-                        elif callable(accessor):
-                            accessor()
-                        setattr(obbject, "_extension_modified", True)
-
-        if route in callbacks:
-            for ext in callbacks[route]:
+        results_only = False
+        executed_keys: set[str] = set()
+        ordered_extensions: list = []
+        all_on_command_output_exts: list = []
+
+        def _extension_key(ext) -> str:
+            if key := getattr(ext, "identifier", None):
+                return str(key)
+            if path := getattr(ext, "import_path", None):
+                return f"{path}:{getattr(ext, 'name', id(ext))}"
+            return str(getattr(ext, "name", id(ext)))
+
+        def _clone_for_immutable(source: OBBject) -> OBBject | None:
+            try:
+                new_source = source.model_copy()
+                new_source = OBBject.model_validate(source.model_dump())
+                return source.model_validate(new_source)
+            except Exception as e:
+                warn(
+                    "Skipped immutable callback because the OBBject "
+                    f"could not be duplicated. {e}",
+                    OpenBBWarning,
+                )
+                return None
+
+        for ext_list in callbacks.values():
+            all_on_command_output_exts.extend(ext_list)
+
+        for ext in callbacks.get("*", []):
+            key = _extension_key(ext)
+            if key not in executed_keys:
+                executed_keys.add(key)
+                ordered_extensions.append(ext)
+
+        for ext in callbacks.get(route, []):
+            key = _extension_key(ext)
+            if key not in executed_keys:
+                executed_keys.add(key)
+                ordered_extensions.append(ext)
+
+        try:
+            for ext in ordered_extensions:
                 if ext.results_only is True:
                     results_only = True
 
-                if ext.immutable is True:
-                    if hasattr(obbject, ext.name):
-                        obbject_copy = deepcopy(obbject)
-                        accessor = getattr(obbject_copy, ext.name)
-                        if iscoroutinefunction(accessor):
-                            run_async(accessor)
-                        elif callable(accessor):
-                            accessor()
-                elif ext.immutable is False and hasattr(obbject, ext.name):
-                    accessor = getattr(obbject, ext.name)
-                    if iscoroutinefunction(accessor):
-                        run_async(accessor)
-                    elif callable(accessor):
-                        accessor()
-                    setattr(obbject, "_extension_modified", True)
-
-        if results_only is True:
-            setattr(obbject, "_results_only", True)
-            setattr(obbject, "_extension_modified", True)
+                if ext.command_output_paths and route not in ext.command_output_paths:
+                    continue
+
+                accessors = getattr(type(obbject), "accessors", set())
+                if ext.name not in accessors:
+                    continue
+
+                descriptor = type(obbject).__dict__.get(ext.name)
+                if not isinstance(descriptor, CachedAccessor):
+                    continue
+
+                factory = descriptor._accessor  # type: ignore[attr-defined]
+
+                target = _clone_for_immutable(obbject) if ext.immutable else obbject
+
+                if target is None:
+                    continue
+
+                if iscoroutinefunction(factory):
+                    run_async(factory, target)
+                else:
+                    result = factory(target)
+                    if callable(result):
+                        result()
+
+                if ext.immutable is False:
+                    object.__setattr__(obbject, "_extension_modified", True)
+
+            if results_only is True:
+                object.__setattr__(obbject, "_results_only", True)
+                object.__setattr__(obbject, "_extension_modified", True)
+
+        except Exception as e:
+            raise OpenBBError(e) from e
+
+        for ext in all_on_command_output_exts:
+            if ext.name in type(obbject).__dict__:
+                object.__setattr__(
+                    obbject,
+                    ext.name,
+                    "Accessor is not callable outside of function execution.",
+                )
 
 
 class CommandRunner:

openbb_platform/core/openbb_core/app/model/credentials.py

@@ -164,6 +164,7 @@ def load(self) -> BaseModel:
             **self.format_credentials(additional),  # type: ignore
         )
         model._env_defaults = env_overrides  # type: ignore # pylint: disable=W0212
+        model.origins = self.credentials
 
         return model
 

openbb_platform/core/tests/app/test_command_runner.py

@@ -16,7 +16,7 @@
 )
 from openbb_core.app.model.abstract.warning import OpenBBWarning
 from openbb_core.app.model.command_context import CommandContext
-from openbb_core.app.model.extension import Extension
+from openbb_core.app.model.extension import CachedAccessor, Extension
 from openbb_core.app.model.obbject import OBBject
 from openbb_core.app.model.system_settings import SystemSettings
 from openbb_core.app.model.user_settings import UserSettings
@@ -495,7 +495,13 @@ def mut_accessor(self):
         if isinstance(getattr(self, "results", None), list):
             self.results.append("modified_by_mut")
 
-    monkeypatch.setattr(OBBject, ext.name, mut_accessor, raising=False)
+    monkeypatch.setattr(
+        "openbb_core.app.model.obbject.OBBject.accessors",
+        OBBject.accessors | {ext.name},
+    )
+    monkeypatch.setattr(
+        OBBject, ext.name, CachedAccessor(ext.name, mut_accessor), raising=False
+    )
 
     # register the extension only for "mock/route"
     fake_loader = SimpleNamespace(on_command_output_callbacks={"mock/route": [ext]})
@@ -535,7 +541,13 @@ def test_results_only_flag_sets_attribute_and_accessor_runs(monkeypatch):
     def ro_accessor(self):
         called["hit"] = True
 
-    monkeypatch.setattr(OBBject, ext.name, ro_accessor, raising=False)
+    monkeypatch.setattr(
+        "openbb_core.app.model.obbject.OBBject.accessors",
+        OBBject.accessors | {ext.name},
+    )
+    monkeypatch.setattr(
+        OBBject, ext.name, CachedAccessor(ext.name, ro_accessor), raising=False
+    )
 
     fake_loader = SimpleNamespace(on_command_output_callbacks={"*": [ext]})
     monkeypatch.setattr(

openbb_platform/obbject_extensions/charting/openbb_charting/core/openbb_figure.py

@@ -87,7 +87,9 @@ def __init__(self, fig: go.Figure | None = None, **kwargs) -> None:
 
         super().__init__()
         if fig:
-            self.__dict__ = fig.__dict__
+            self.__dict__ = (
+                go.Figure(fig).__dict__ if isinstance(fig, dict) else fig.__dict__
+            )
 
         self._charting_settings: ChartingSettings | None = kwargs.pop(
             "charting_settings", None