Merge branch 'develop' of https://github.com/OpenBB-finance/OpenBB into feature/openbb-cookiecutter

Author: deeleeramone

openbb_platform/core/openbb_core/api/router/commands.py

@@ -7,8 +7,11 @@
 from typing import Annotated, Any, TypeVar
 
 from fastapi import APIRouter, Depends, Header
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
 from fastapi.routing import APIRoute
 from openbb_core.app.command_runner import CommandRunner
+from openbb_core.app.model.abstract.error import OpenBBError
 from openbb_core.app.model.command_context import CommandContext
 from openbb_core.app.model.obbject import OBBject
 from openbb_core.app.model.user_settings import UserSettings
@@ -140,7 +143,7 @@ def is_model(type_):
 
     def exclude_fields_from_api(key: str, value: Any):
         type_ = type(value)
-        field = c_out.model_fields.get(key, None)
+        field = getattr(type(c_out), "model_fields", {}).get(key, None)
         json_schema_extra = field.json_schema_extra if field else None
 
         # case where 1st layer field needs to be excluded
@@ -198,7 +201,9 @@ def build_api_wrapper(
         route.response_model = None
 
     @wraps(wrapped=func)
-    async def wrapper(*args: tuple[Any], **kwargs: dict[str, Any]) -> OBBject:
+    async def wrapper(
+        *args: tuple[Any], **kwargs: dict[str, Any]
+    ) -> OBBject | JSONResponse:
         user_settings: UserSettings = UserSettings.model_validate(
             kwargs.pop(
                 "__authenticated_user_settings",
@@ -213,7 +218,7 @@ async def wrapper(*args: tuple[Any], **kwargs: dict[str, Any]) -> OBBject:
         )
 
         if defaults:
-            _provider = defaults.pop("provider", None)
+            _ = defaults.pop("provider", None)
             standard_params = getattr(
                 kwargs.pop("standard_params", None), "__dict__", {}
             )
@@ -243,6 +248,23 @@ async def wrapper(*args: tuple[Any], **kwargs: dict[str, Any]) -> OBBject:
         execute = partial(command_runner.run, path, user_settings)
         output = await execute(*args, **kwargs)
 
+        # This is where we check for `on_command_output` extensions
+        mutated_output = getattr(output, "_extension_modified", False)
+        results_only = getattr(output, "_results_only", False)
+        try:
+            if results_only is True:
+                content = output.model_dump(exclude_unset=True).get("results", [])
+                return JSONResponse(content=jsonable_encoder(content), status_code=200)
+
+            if (mutated_output and isinstance(output, OBBject)) or (
+                isinstance(output, OBBject) and no_validate
+            ):
+                return JSONResponse(content=jsonable_encoder(output), status_code=200)
+        except Exception as exc:  # pylint: disable=W0703
+            raise OpenBBError(
+                f"Error serializing output for an extension-modified endpoint {path}: {exc}",
+            ) from exc
+
         if isinstance(output, OBBject) and not no_validate:
             return validate_output(output)
 

openbb_platform/core/openbb_core/app/command_runner.py

@@ -6,12 +6,13 @@
 from copy import deepcopy
 from dataclasses import asdict, is_dataclass
 from datetime import datetime
-from inspect import Parameter, signature
+from inspect import Parameter, iscoroutinefunction, signature
 from sys import exc_info
 from time import perf_counter_ns
 from typing import TYPE_CHECKING, Any, Optional
 from warnings import catch_warnings, showwarning, warn
 
+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.metadata import Metadata
@@ -272,6 +273,7 @@ def _chart(
 
             if chart_params:
                 kwargs.update(chart_params)
+
             obbject.charting.show(render=False, **kwargs)  # type: ignore[attr-defined]
         except Exception as e:  # pylint: disable=broad-exception-caught
             if Env().DEBUG_MODE:
@@ -311,6 +313,9 @@ async def _execute_func(  # pylint: disable=too-many-positional-arguments
                 # in the charting extension then we add it there. This way we can remove
                 # the chart parameter from the commands.py and package_builder, it will be
                 # added to the function signature in the router decorator
+                # If the ProviderInterface is not in use, we need to pass a copy of the
+                # kwargs dictionary before it is validated, otherwise we lose those items.
+                kwargs_copy = deepcopy(kwargs)
                 chart = kwargs.pop("chart", False)
 
                 kwargs = ParametersBuilder.build(
@@ -348,7 +353,21 @@ async def _execute_func(  # pylint: disable=too-many-positional-arguments
                         extra_params
                     )
                     if chart and obbject.results:
-                        cls._chart(obbject, **kwargs)
+                        if "extra_params" not in kwargs_copy:
+                            kwargs_copy["extra_params"] = {}
+                        # Restore any kwargs passed that were removed by the ParametersBuilder
+                        for k in kwargs_copy.copy():
+                            if k == "chart":
+                                kwargs_copy.pop("chart", None)
+                                continue
+                            if (
+                                not extra_params or k not in extra_params
+                            ) and k != "extra_params":
+                                kwargs_copy["extra_params"][k] = kwargs_copy.pop(
+                                    k, None
+                                )
+
+                        cls._chart(obbject, **kwargs_copy)
 
                 raised_warnings = warning_list if warning_list else []
         finally:
@@ -429,8 +448,79 @@ 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)
+
         return obbject
 
+    @classmethod
+    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
+
+        # For each extension registered for all routes or the specific route,
+        # we call its accessor on the OBBject.
+        # We check if the accessor is immutable or not to decide whether to pass
+        # a copy of the OBBject or the original one.
+        # We set the _extension_modified attribute to True if any extension
+        # 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]:
+                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)
+
 
 class CommandRunner:
     """Command runner."""

openbb_platform/core/openbb_core/app/extension_loader.py

@@ -49,6 +49,23 @@ def __init__(
         self._obbject_objects: dict[str, Extension] = {}
         self._core_objects: dict[str, Router] = {}
         self._provider_objects: dict[str, Provider] = {}
+        self._on_command_output_callbacks: dict[str, list[Extension]] = {}
+        self._register_command_output_callbacks()
+
+    @property
+    def on_command_output_callbacks(self) -> dict[str, list[Extension]]:
+        """Return the on command output callbacks."""
+        return self._on_command_output_callbacks
+
+    def _register_command_output_callbacks(self) -> None:
+        """Register extensions that act on command output."""
+        for ext in self.obbject_objects.values():
+            if ext.on_command_output:
+                paths = ext.command_output_paths or ["*"]
+                for path in paths:
+                    if path not in self._on_command_output_callbacks:
+                        self._on_command_output_callbacks[path] = []
+                    self._on_command_output_callbacks[path].append(ext)
 
     @property
     def obbject_entry_points(self) -> EntryPoints:

openbb_platform/core/openbb_core/app/model/abstract/tagged.py

@@ -1,10 +1,10 @@
 """OpenBB Core App Abstract Model Tagged."""
 
 from pydantic import BaseModel, Field
-from uuid_extensions import uuid7str  # type: ignore
+from uuid_extensions import uuid7str
 
 
 class Tagged(BaseModel):
     """Model for Tagged."""
 
-    id: str = Field(default_factory=uuid7str, alias="_id")
+    id: str = Field(default_factory=uuid7str)

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

@@ -8,35 +8,96 @@ class Extension:
     """
     Serves as OBBject extension entry point and must be created by each extension package.
 
-    See https://docs.openbb.co/platform/development/developer-guidelines/obbject_extensions.
+    See https://docs.openbb.co/developer/extension_types/obbject for more information.
     """
 
+    # pylint: disable=R0917
     def __init__(
         self,
         name: str,
         credentials: list[str] | None = None,
         description: str | None = None,
+        on_command_output: bool = False,
+        command_output_paths: list[str] | None = None,
+        immutable: bool = True,
+        results_only: bool = False,
     ) -> None:
         """Initialize the extension.
 
         Parameters
         ----------
         name : str
             Name of the extension.
-        credentials : Optional[List[str]], optional
+        credentials : list[str], optional
             List of required credentials, by default None
         description: Optional[str]
             Extension description.
+        on_command_output : bool, optional
+            Whether the extension acts on command output, by default False
+        command_output_paths : list[str], optional
+            List of endpoint paths the extension acts on, where None means all, by default None.
+        immutable : bool, optional
+            Whether the function output is immutable, by default True.
+        results_only : bool, optional
+            Whether the extension returns only the results instead of the OBBject, by default False.
         """
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.service.system_service import SystemService
+
         self.name = name
         self.credentials = credentials or []
         self.description = description
+        self.on_command_output = on_command_output
+        self.command_output_paths = command_output_paths or []
+        self.immutable = immutable
+        self.results_only = results_only
+
+        # This must be explicitly enabled.
+        if self.on_command_output is False and (
+            self.command_output_paths
+            or self.results_only is True
+            or self.immutable is False
+        ):
+            raise ValueError(
+                "OBBject Extension Error -> 'on_command_output' must be set as True when"
+                + " 'command_output_paths', 'results_only' or 'immutable' is set.",
+            )
+
+        # The user must explicitly enable OBBject extensions that act on command output.
+        if (
+            self.on_command_output
+            and not SystemService().system_settings.allow_on_command_output
+        ):
+            raise RuntimeError(
+                "OBBject Extension Error -> \n\n"
+                + "An OBBject extension that acts on command output is installed "
+                + "but has not been enabled in `system_settings.json`.\n\n"
+                + "Set `allow_on_command_output` to True to enable it.\n"
+                + "Or, set the environment variable `OPENBB_ALLOW_ON_COMMAND_OUTPUT` to True."
+                + "\n\nProceed with caution as this may have security implications.\n\n"
+                + "Ensure the extension is installed from a trusted source.\n\n",
+            )
+
+        # The user must explicitly enable OBBject extensions that modify output.
+        if (
+            self.on_command_output
+            and self.immutable is False
+            and not SystemService().system_settings.allow_mutable_extensions
+        ):
+            raise RuntimeError(
+                "OBBject Extension Error -> \n\n"
+                + "An OBBject extension that modifies the output is installed "
+                + "but has not been enabled in `system_settings.json`.\n\n"
+                + "Set `allow_mutable_extensions` to True to enable it.\n"
+                + "Or, set the environment variable `OPENBB_ALLOW_MUTABLE_EXTENSIONS` to True."
+                + "\n\nProceed with caution as this may have security implications.\n\n"
+                + "Ensure the extension is installed from a trusted source.\n\n",
+            )
 
     @property
     def obbject_accessor(self) -> Callable:
         """Extend an OBBject, inspired by pandas."""
         # pylint: disable=import-outside-toplevel
-        # Avoid circular imports
 
         from openbb_core.app.model.obbject import OBBject
 
@@ -55,8 +116,8 @@ def decorator(accessor):
                     UserWarning,
                 )
             setattr(cls, name, CachedAccessor(name, accessor))
-            # pylint: disable=protected-access
             cls.accessors.add(name)
+
             return accessor
 
         return decorator

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

@@ -60,7 +60,7 @@ class OBBject(Tagged, Generic[T]):
         default_factory=dict,
         description="Extra info.",
     )
-    _route: str = PrivateAttr(
+    _route: str | None = PrivateAttr(
         default=None,
     )
     _standard_params: dict[str, Any] | None = PrivateAttr(
@@ -178,9 +178,9 @@ def is_list_of_basemodel(items: list[T] | T) -> bool:
 
             # BaseModel
             if isinstance(res, BaseModel):
-                res_dict = res.model_dump(
+                res_dict = res.model_dump(  # pylint: disable=no-member
                     exclude_unset=True, exclude_none=True
-                )  # pylint: disable=no-member
+                )
                 # Model is serialized as a dict[str, list] or list[dict]
                 if (
                     (
@@ -322,13 +322,16 @@ def to_dict(
             orient == "list"
             and isinstance(self.results, dict)
             and all(
-                isinstance(value, dict) for value in self.results.values()
-            )  # pylint: disable=no-member
+                isinstance(value, dict)
+                for value in self.results.values()  # pylint: disable=no-member
+            )
         ):
             df = df.T
-        results = df.to_dict(orient=orient)
+        results: dict | list = df.to_dict(orient=orient)
+
         if isinstance(results, dict) and orient == "list" and "index" in results:
             del results["index"]
+
         return results
 
     def to_llm(self) -> dict[Hashable, Any] | list[dict[Hashable, Any]]: