openbb-platform-api 1.0.0__tar.gz

openbb_platform_api-1.0.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: openbb-platform-api
+Version: 1.0.0
+Summary: OpenBB Platform API: Launch script and widgets builder for the OpenBB Platform API and Terminal Pro Connector.
+Home-page: https://openbb.co
+License: AGPL-3.0-only
+Author: OpenBB
+Author-email: hello@openbb.co
+Requires-Python: >=3.9,<3.13
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: black
+Requires-Dist: deepdiff
+Requires-Dist: openbb-core
+Requires-Dist: poetry (>=1.8,<2.0)
+Requires-Dist: ruff
+Requires-Dist: setuptools
+Project-URL: Documentation, https://docs.openbb.co
+Project-URL: Repository, https://github.com/openbb-finance/openbb
+Description-Content-Type: text/markdown
+
+# OpenBB Platform API Meta Package
+
+This is a meta package entry point for the OpenBB Platform API, and the OpenBB Terminal Pro data connector widgets build script.
+
+## Installation
+
+Install this package locally by navigating into the directory and entering:
+
+```sh
+pip install -e .
+```
+

openbb_platform_api-1.0.0/README.md

@@ -0,0 +1,11 @@
+# OpenBB Platform API Meta Package
+
+This is a meta package entry point for the OpenBB Platform API, and the OpenBB Terminal Pro data connector widgets build script.
+
+## Installation
+
+Install this package locally by navigating into the directory and entering:
+
+```sh
+pip install -e .
+```

openbb_platform_api-1.0.0/openbb_platform_api/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Platform API Meta Package."""

openbb_platform_api-1.0.0/openbb_platform_api/main.py

@@ -0,0 +1,133 @@
+"""OpenBB Platform API.
+
+Launch script and widgets builder for the OpenBB Terminal Custom Backend.
+"""
+
+import json
+import os
+
+import uvicorn
+from fastapi.responses import JSONResponse
+from openbb_core.api.rest_api import app
+
+from .utils.api import check_port, get_user_settings, get_widgets_json, parse_args
+
+FIRST_RUN = True
+
+HOME = os.environ.get("HOME") or os.environ.get("USERPROFILE")
+
+if not HOME:
+    raise ValueError("HOME or USERPROFILE environment variable not set.")
+
+CURRENT_USER_SETTINGS = os.path.join(HOME, ".openbb_platform", "user_settings.json")
+USER_SETTINGS_COPY = os.path.join(HOME, ".openbb_platform", "user_settings_backup.json")
+
+# Widget filtering is optional and can be used to exclude widgets from the widgets.json file
+# You can generate this filter on OpenBB Hub: https://my.openbb.co/app/platform/widgets
+WIDGET_SETTINGS = os.path.join(HOME, ".openbb_platform", "widget_settings.json")
+
+kwargs = parse_args()
+build = kwargs.pop("build", True)
+build = False if kwargs.pop("no-build", None) else build
+login = kwargs.pop("login", False)
+dont_filter = kwargs.pop("no-filter", False)
+
+if not dont_filter and os.path.exists(WIDGET_SETTINGS):
+    with open(WIDGET_SETTINGS) as f:
+        try:
+            widget_exclude_filter = json.load(f)["exclude"]
+        except json.JSONDecodeError:
+            widget_exclude_filter = []
+else:
+    widget_exclude_filter = []
+
+openapi = app.openapi()
+
+# We don't need the current settings,
+# but we need to call the function to update, login, and/or identify the settings file.
+current_settings = get_user_settings(login, CURRENT_USER_SETTINGS, USER_SETTINGS_COPY)
+
+widgets_json = get_widgets_json(build, openapi, widget_exclude_filter)
+
+
+@app.get("/")
+async def get_root():
+    """Root response and welcome message."""
+    return JSONResponse(
+        content="Welcome to the OpenBB Platform API."
+        + " Learn how to connect to Pro in docs.openbb.co/pro/data-connectors,"
+        + " or see the API documentation here: /docs"
+    )
+
+
+@app.get("/widgets.json")
+async def get_widgets():
+    """Widgets configuration file for the OpenBB Terminal Pro."""
+    # This allows us to serve an edited widgets.json file without reloading the server.
+    global FIRST_RUN  # noqa PLW0603  # pylint: disable=global-statement
+    if FIRST_RUN is True:
+        FIRST_RUN = False
+        return JSONResponse(content=widgets_json)
+    return JSONResponse(content=get_widgets_json(False, openapi, widget_exclude_filter))
+
+
+def launch_api(**_kwargs):  # noqa PRL0912
+    """Main function."""
+    host = _kwargs.pop("host", os.getenv("OPENBB_API_HOST", "127.0.0.1"))
+    if not host:
+        print(  # noqa: T201
+            "\n\nOPENBB_API_HOST is set incorrectly. It should be an IP address or hostname."
+        )
+        host = input("Enter the host IP address or hostname: ")
+        if not host:
+            host = "127.0.0.1"
+
+    port = _kwargs.pop("port", os.getenv("OPENBB_API_PORT", "6900"))
+
+    try:
+        port = int(port)
+    except ValueError:
+        print(  # noqa: T201
+            "\n\nOPENBB_API_PORT is set incorrectly. It should be an port number."
+        )
+        port = input("Enter the port number: ")
+        try:
+            port = int(port)
+        except ValueError:
+            print("\n\nInvalid port number. Defaulting to 6900.")  # noqa: T201
+            port = 6900
+    if port < 1025:
+        port = 6900
+        print(  # noqa: T201
+            "\n\nInvalid port number, must be above 1024. Defaulting to 6900."
+        )
+
+    free_port = check_port(host, port)
+
+    if free_port != port:
+        print(  # noqa: T201
+            f"\n\nPort {port} is already in use. Using port {free_port}.\n"
+        )
+        port = free_port
+
+    try:
+        package_name = __package__
+        uvicorn.run(f"{package_name}.main:app", host=host, port=port, **_kwargs)
+    finally:
+        # If user_settings_copy.json exists, then restore the original settings.
+        if os.path.exists(USER_SETTINGS_COPY):
+            print("\n\nRestoring the original settings.\n")  # noqa: T201
+            os.replace(USER_SETTINGS_COPY, CURRENT_USER_SETTINGS)
+
+
+def main():
+    """Launch the API."""
+    launch_api(**kwargs)
+
+
+if __name__ == "__main__":
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("Restoring the original settings.")  # noqa: T201

openbb_platform_api-1.0.0/openbb_platform_api/utils/__init__.py

@@ -0,0 +1 @@
+"""OpenBB Platform API Utils."""

openbb_platform_api-1.0.0/openbb_platform_api/utils/api.py

@@ -0,0 +1,244 @@
+"""API Utils."""
+
+import json
+import os
+import socket
+import sys
+from pathlib import Path
+from typing import Dict
+
+from deepdiff import DeepDiff
+
+from .widgets import build_json
+
+LAUNCH_SCRIPT_DESCRIPTION = """
+Serve the OpenBB Platform API.
+
+
+Launcher specific arguments:
+
+    --build                         Build the widgets.json file.
+    --no-build                      Do not build the widgets.json file.
+    --login                         Login to the OpenBB Platform.
+    --no-filter                     Do not filter the widgets.json file.
+
+
+All other arguments will be passed to uvicorn. Here are the most common ones:
+
+    --host TEXT                     Host IP address or hostname.
+                                      [default: 127.0.0.1]
+    --port INTEGER                  Port number.
+                                      [default: 6900]
+    --ssl-keyfile TEXT              SSL key file.
+    --ssl-certfile TEXT             SSL certificate file.
+    --ssl-keyfile-password TEXT     SSL keyfile password.
+    --ssl-version INTEGER           SSL version to use.
+                                      (see stdlib ssl module's)
+                                      [default: 17]
+    --ssl-cert-reqs INTEGER         Whether client certificate is required.
+                                      (see stdlib ssl module's)
+                                      [default: 0]
+    --ssl-ca-certs TEXT             CA certificates file.
+    --ssl-ciphers TEXT              Ciphers to use.
+                                      (see stdlib ssl module's)
+                                      [default: TLSv1]
+
+Run `uvicorn --help` to get the full list of arguments.
+"""
+
+
+def check_port(host, port):
+    """Check if the port number is free."""
+    port = int(port)
+    not_free = True
+    while not_free:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            res = sock.connect_ex((host, port))
+            if res != 0:
+                not_free = False
+            else:
+                port += 1
+    return port
+
+
+def get_user_settings(
+    _login: bool, current_user_settings: str, user_settings_copy: str
+):
+    """Login to the OpenBB Platform."""
+    # pylint: disable=import-outside-toplevel
+    import getpass
+
+    if Path(current_user_settings).exists():
+        with open(current_user_settings, encoding="utf-8") as f:
+            _current_settings = json.load(f)
+    else:
+        _current_settings = {
+            "credentials": {},
+            "preferences": {},
+            "defaults": {"commands": {}},
+        }
+    if (isinstance(_login, str) and _login.lower() == "false") or not _login:
+        return _current_settings
+
+    pat = getpass.getpass(
+        "\n\nEnter your personal access token (PAT) to authorize the API and update your local settings."
+        + "\nSkip to use a pre-configured 'user_settings.json' file."
+        + "\nPress Enter to skip or copy (entered values are not displayed on screen) your PAT to the command line: "
+    )
+
+    if pat:
+        from openbb_core.app.service.hub_service import HubService
+
+        hub_credentials: Dict = {}
+        hub_preferences: Dict = {}
+        hub_defaults: Dict = {}
+        try:
+            Hub = HubService()
+            _ = Hub.connect(pat=pat)
+            hub_settings = Hub.pull()
+            hub_credentials = json.loads(
+                hub_settings.credentials.model_dump_json()  # pylint: disable=no-member
+            )
+            hub_preferences = json.loads(
+                hub_settings.preferences.model_dump_json()  # pylint: disable=no-member
+            )
+            hub_defaults = json.loads(
+                hub_settings.defaults.model_dump_json()  # pylint: disable=no-member
+            )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            print(  # noqa: T201
+                f"\n\nError connecting with Hub:\n{e}\n\nUsing the local settings.\n"
+            )
+
+        if hub_credentials:
+            # Prompt the user to ask if they want to persist the new settings
+            persist_input = (
+                input(
+                    "\n\nDo you want to persist the new settings?"
+                    + " Not recommended for public machines. (yes/no): "
+                )
+                .strip()
+                .lower()
+            )
+
+            if persist_input in ["yes", "y"]:
+                PERSIST = True
+            elif persist_input in ["no", "n"]:
+                PERSIST = False
+            else:
+                print(  # noqa: T201
+                    "\n\nInvalid input. Defaulting to not persisting the new settings."
+                )
+                PERSIST = False
+
+            # Save the current settings to restore at the end of the session.
+            if PERSIST is False:
+                with open(user_settings_copy, "w", encoding="utf-8") as f:
+                    json.dump(_current_settings, f, indent=4)
+
+        new_settings = _current_settings.copy()
+        new_settings.setdefault("credentials", {})
+        new_settings.setdefault("preferences", {})
+        new_settings.setdefault("defaults", {"commands": {}})
+
+        # Update the current settings with the new settings
+        if hub_credentials:
+            for k, v in hub_credentials.items():
+                if v:
+                    new_settings["credentials"][k] = v.strip('"').strip("'")
+
+        if hub_preferences:
+            for k, v in hub_preferences.items():
+                if v:
+                    new_settings["preferences"][k] = v
+
+        if hub_defaults:
+            for k, v in hub_defaults.items():
+                if k == "commands":
+                    for key, value in hub_defaults["commands"].items():
+                        if value:
+                            new_settings["defaults"]["commands"][key] = value
+                elif v:
+                    new_settings["defaults"][k] = v
+                else:
+                    continue
+
+        # Write the new settings to the user_settings.json file
+        with open(current_user_settings, "w", encoding="utf-8") as f:
+            json.dump(new_settings, f, indent=4)
+
+        _current_settings = new_settings
+
+    return _current_settings
+
+
+def get_widgets_json(_build: bool, _openapi, widget_exclude_filter: list):
+    """Generate and serve the widgets.json for the OpenBB Platform API."""
+    python_path = Path(sys.executable)
+    parent_path = python_path.parent if os.name == "nt" else python_path.parents[1]
+    widgets_json_path = parent_path.joinpath("assets", "widgets.json").resolve()
+    json_exists = widgets_json_path.exists()
+
+    if not json_exists:
+        widgets_json_path.parent.mkdir(parents=True, exist_ok=True)
+        _build = True
+
+    existing_widgets_json: Dict = {}
+
+    if json_exists:
+        with open(widgets_json_path, encoding="utf-8") as f:
+            existing_widgets_json = json.load(f)
+
+    _widgets_json = (
+        existing_widgets_json
+        if _build is False
+        else build_json(_openapi, widget_exclude_filter)
+    )
+
+    if _build:
+        diff = DeepDiff(existing_widgets_json, _widgets_json, ignore_order=True)
+        merge_prompt = None
+        if diff and json_exists:
+            print("Differences found:", diff)  # noqa: T201
+            merge_prompt = input(
+                "\nDo you want to overwrite the existing widgets.json configuration?"
+                "\nEnter 'n' to append existing with only new entries, or 'i' to ignore all changes. (y/n/i): "
+            )
+            if merge_prompt.lower().startswith("n"):
+                _widgets_json.update(existing_widgets_json)
+            elif merge_prompt.lower().startswith("i"):
+                _widgets_json = existing_widgets_json
+
+        if merge_prompt is None or not merge_prompt.lower().startswith("i"):
+            try:
+                with open(widgets_json_path, "w", encoding="utf-8") as f:
+                    json.dump(_widgets_json, f, ensure_ascii=False, indent=4)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                print(  # noqa: T201
+                    f"Error writing widgets.json: {e}.  Loading from memory instead."
+                )
+                _widgets_json = (
+                    existing_widgets_json
+                    if existing_widgets_json
+                    else build_json(_openapi, widget_exclude_filter)
+                )
+
+    return _widgets_json
+
+
+def parse_args():
+    """Parse the launch script command line arguments."""
+    args = sys.argv[1:].copy()
+    _kwargs: Dict = {}
+    for i, arg in enumerate(args):
+        if arg == "--help":
+            print(LAUNCH_SCRIPT_DESCRIPTION)  # noqa: T201
+            sys.exit(0)
+        if arg.startswith("--"):
+            key = arg[2:]
+            if i + 1 < len(args) and not args[i + 1].startswith("--"):
+                value = args[i + 1]
+                _kwargs[key] = value
+            else:
+                _kwargs[key] = True
+    return _kwargs

openbb_platform_api-1.0.0/openbb_platform_api/utils/openapi.py

@@ -0,0 +1,454 @@
+"""OpenAPI parsing Utils."""
+
+from openbb_core.provider.utils.helpers import to_snake_case
+
+
+def extract_providers(params: list[dict]) -> list[str]:
+    """
+    Extract provider options from parameters.
+
+    Parameters
+    ----------
+    params : List[Dict]
+        List of parameter dictionaries.
+
+    Returns
+    -------
+    List[str]
+        List of provider options.
+    """
+    provider_params = [p for p in params if p["name"] == "provider"]
+    if provider_params:
+        return provider_params[0].get("schema", {}).get("enum", [])
+    return []
+
+
+def set_parameter_type(p: dict, p_schema: dict):
+    """
+    Determine and set the type for the parameter.
+
+    Parameters
+    ----------
+    p : Dict
+        Processed parameter dictionary.
+    p_schema : Dict
+        Schema dictionary for the parameter.
+    """
+    p_type = p_schema.get("type") if not p.get("type") else p.get("type")
+
+    if p_type == "string":
+        p["type"] = "text"
+
+    if p_type in ("float", "integer") or (
+        not isinstance(p["value"], bool) and isinstance(p["value"], (int, float))
+    ):
+        p["type"] = "number"
+
+    if (
+        p_type == "boolean"
+        or p_schema.get("type") == "boolean"
+        or ("anyOf" in p_schema and p_schema["anyOf"][0].get("type") == "boolean")
+    ):
+        p["type"] = "boolean"
+
+    if "date" in p["parameter_name"]:
+        p["type"] = "date"
+
+    if "timeframe" in p["parameter_name"]:
+        p["type"] = "text"
+
+    if p["parameter_name"] == "limit":
+        p["type"] = "number"
+
+    if p.get("type") in ("array", "list") or isinstance(p.get("type"), list):
+        p["type"] = "text"
+
+    return p
+
+
+def set_parameter_options(p: dict, p_schema: dict, providers: list[str]) -> dict:
+    """
+    Set options for the parameter based on the schema.
+
+    Parameters
+    ----------
+    p : Dict
+        Processed parameter dictionary.
+    p_schema : Dict
+        Schema dictionary for the parameter.
+    providers : List[str]
+        List of provider options.
+
+    Returns
+    -------
+    Dict
+        Updated parameter dictionary with options.
+    """
+    choices: dict[str, list[dict[str, str]]] = {}
+    multiple_items_allowed_dict: dict = {}
+    is_provider_specific = False
+    available_providers: set = set()
+    unique_general_choices: list = []
+
+    # Handle provider-specific choices
+    for provider in providers:
+        if (provider in p_schema) or (len(providers) == 1):
+            is_provider_specific = True
+            provider_choices: list = []
+            if provider not in available_providers:
+                available_providers.add(provider)
+            if provider in p_schema:
+                provider_choices = p_schema[provider].get("choices", [])
+            elif len(providers) == 1 and "enum" in p_schema:
+                provider_choices = p_schema["enum"]
+                p_schema.pop("enum")
+            if provider_choices:
+                choices[provider] = [
+                    {"label": str(c), "value": c} for c in provider_choices
+                ]
+            if provider in p_schema and p_schema[provider].get(
+                "multiple_items_allowed", False
+            ):
+                multiple_items_allowed_dict[provider] = True
+
+    # Check title for provider-specific information
+    if "title" in p_schema:
+        title_providers = set(p_schema["title"].split(","))
+        if title_providers.intersection(providers):
+            is_provider_specific = True
+            available_providers.update(title_providers)
+
+    # Handle general choices
+    general_choices: list = []
+    if "enum" in p_schema:
+        general_choices.extend(
+            [
+                {"label": str(c), "value": c}
+                for c in p_schema["enum"]
+                if c not in ["null", None]
+            ]
+        )
+    elif "anyOf" in p_schema:
+        for sub_schema in p_schema["anyOf"]:
+            if "enum" in sub_schema:
+                general_choices.extend(
+                    [
+                        {"label": str(c), "value": c}
+                        for c in sub_schema["enum"]
+                        if c not in ["null", None]
+                    ]
+                )
+
+    if general_choices:
+        # Remove duplicates by converting list of dicts to a set of tuples and back to list of dicts
+        unique_general_choices = [
+            dict(t) for t in {tuple(d.items()) for d in general_choices}
+        ]
+        if not is_provider_specific:
+            if len(providers) == 1:
+                choices[providers[0]] = unique_general_choices
+                multiple_items_allowed_dict[providers[0]] = p_schema.get(
+                    "multiple_items_allowed", False
+                )
+            else:
+                choices["other"] = unique_general_choices
+                multiple_items_allowed_dict["other"] = p_schema.get(
+                    "multiple_items_allowed", False
+                )
+
+    # Use general choices as fallback for providers without specific options
+    for provider in available_providers:
+        if provider not in choices:
+            if "anyOf" in p_schema and p_schema["anyOf"]:
+                fallback_choices = p_schema["anyOf"][0].get("enum", [])
+                choices[provider] = [
+                    {"label": str(c), "value": c}
+                    for c in fallback_choices
+                    if c not in ["null", None]
+                ]
+            else:
+                choices[provider] = unique_general_choices
+
+    p["options"] = choices
+    p["multiple_items_allowed"] = multiple_items_allowed_dict
+
+    if is_provider_specific:
+        p["available_providers"] = list(available_providers)
+
+    return p
+
+
+def process_parameter(param: dict, providers: list[str]) -> dict:
+    """
+    Process a single parameter and return the processed dictionary.
+
+    Parameters
+    ----------
+    param : Dict
+        Parameter dictionary.
+    providers : List[str]
+        List of provider options.
+
+    Returns
+    -------
+    Dict
+        Processed parameter dictionary.
+    """
+    p: dict = {}
+    param_name = param["name"]
+    p["parameter_name"] = param_name
+    p["label"] = (
+        param_name.replace("_", " ").replace("fixedincome", "fixed income").title()
+    )
+    p["description"] = (
+        (param.get("description", param_name).split(" (provider:")[0].strip())
+        .split("Multiple comma separated items allowed")[0]
+        .strip()
+    )
+    p["optional"] = param.get("required", False) is False
+
+    if param_name == "provider":
+        p["type"] = "text"
+        p["label"] = "Provider"
+        p["description"] = "Source of the data."
+        p["available_providers"] = providers
+        return p
+
+    if param_name in ["symbol", "series_id", "release_id"]:
+        p["type"] = "text"
+        p["label"] = param_name.title().replace("_", " ").replace("Id", "ID")
+        p["description"] = (
+            p["description"]
+            .split("Multiple comma separated items allowed for provider(s)")[0]
+            .strip()
+        )
+        multiple_items_allowed_dict: dict = {}
+        for _provider in providers:
+            if _provider in param["schema"] and param["schema"][_provider].get(
+                "multiple_items_allowed", False
+            ):
+                multiple_items_allowed_dict[_provider] = True
+        p["multiple_items_allowed"] = multiple_items_allowed_dict
+        if "Multiple comma separated items allowed" in p["description"]:
+            p["description"] = (
+                p["description"]
+                .split("Multiple comma separated items allowed")[0]
+                .strip()
+            )
+        return p
+
+    p_schema = param.get("schema", {})
+    p["value"] = p_schema.get("default", None)
+    p = set_parameter_options(p, p_schema, providers)
+    p = set_parameter_type(p, p_schema)
+
+    return p
+
+
+def get_query_schema_for_widget(
+    openapi_json: dict, command_route: str
+) -> tuple[list[dict], bool]:
+    """
+    Extract the query schema for a widget.
+
+    Parameters
+    ----------
+    openapi_json : dict
+        The OpenAPI specification as a dictionary.
+    command_route : str
+        The route of the command in the OpenAPI specification.
+
+    Returns
+    -------
+    Tuple[List[Dict], bool]
+        A tuple containing the list of processed parameters and a boolean indicating if a chart is present.
+    """
+    has_chart = False
+    command = openapi_json["paths"][command_route]
+    schema_method = list(command)[0]
+    command = command[schema_method]
+    params = command.get("parameters", [])
+    route_params: list[dict] = []
+    providers: list[str] = extract_providers(params)
+
+    for param in params:
+        if param["name"] in ["sort", "order"]:
+            continue
+        if param["name"] == "chart":
+            has_chart = True
+            continue
+
+        p = process_parameter(param, providers)
+        p["show"] = True
+        route_params.append(p)
+
+    return route_params, has_chart
+
+
+def get_data_schema_for_widget(openapi_json, operation_id):
+    """
+    Get the data schema for a widget based on its operationId.
+
+    Args:
+        openapi (dict): The OpenAPI specification as a dictionary.
+        operation_id (str): The operationId of the widget.
+
+    Returns:
+        dict: The schema dictionary for the widget's data.
+    """
+    # Find the route and method for the given operationId
+    for _, methods in openapi_json["paths"].items():
+        for _, details in methods.items():
+            if details.get("operationId") == operation_id:
+                # Get the reference to the schema from the successful response
+                response_ref = details["responses"]["200"]["content"][
+                    "application/json"
+                ]["schema"]["$ref"]
+                # Extract the schema name from the reference
+                schema_name = response_ref.split("/")[-1]
+                # Fetch and return the schema from components
+                return (
+                    openapi_json["components"]["schemas"][schema_name]
+                    .get("properties", {})
+                    .get("results", {})
+                )
+
+    # Return None if the schema is not found
+    return None
+
+
+def data_schema_to_columns_defs(openapi_json, operation_id, provider):
+    """Convert data schema to column definitions for the widget."""
+    # Initialize an empty list to hold the schema references
+    schema_refs: list = []
+
+    result_schema_ref = get_data_schema_for_widget(openapi_json, operation_id)
+    # Check if 'anyOf' is in the result_schema_ref and handle the nested structure
+    if "anyOf" in result_schema_ref:
+        for item in result_schema_ref["anyOf"]:
+            # When there are multiple providers a 'oneOf' is used
+            if "items" in item and "oneOf" in item["items"]:
+                # Extract the $ref values
+                schema_refs.extend(
+                    [
+                        oneOf_item["$ref"].split("/")[-1]
+                        for oneOf_item in item["items"]["oneOf"]
+                        if "$ref" in oneOf_item
+                    ]
+                )
+            # When there's only one model there is no oneOf
+            elif "items" in item and "$ref" in item["items"]:
+                schema_refs.append(item["items"]["$ref"].split("/")[-1])
+
+    # Fetch the schemas using the extracted references
+    schemas = [
+        openapi_json["components"]["schemas"][ref]
+        for ref in schema_refs
+        if ref in openapi_json["components"]["schemas"]
+    ]
+
+    # Proceed with finding common keys and generating column definitions
+    if not schemas:
+        return []
+
+    target_schema: dict = {}
+
+    if len(schemas) == 1:
+        target_schema = schemas[0]
+    else:
+        for schema in schemas:
+            if (
+                schema.get("description", "")
+                .lower()
+                .startswith(provider.lower().replace("tradingeconomics", "te"))
+            ) or (schema.get("description", "").lower().startswith("us government")):
+                target_schema = schema
+                break
+
+    keys = list(target_schema.get("properties", {}))
+
+    column_defs: list = []
+    for key in keys:
+        cell_data_type = None
+        formatterFn = None
+        prop = target_schema.get("properties", {}).get(key)
+        # Handle prop types for both when there's a single prop type or multiple
+        if "anyOf" in prop:
+            types = [
+                sub_prop.get("type") for sub_prop in prop["anyOf"] if "type" in sub_prop
+            ]
+            if "number" in types or "integer" in types or "float" in types:
+                cell_data_type = "number"
+            elif "string" in types and any(
+                sub_prop.get("format") in ["date", "date-time"]
+                for sub_prop in prop["anyOf"]
+                if "format" in sub_prop
+            ):
+                cell_data_type = "date"
+            else:
+                cell_data_type = "text"
+        else:
+            prop_type = prop.get("type", None)
+            if prop_type in ["number", "integer", "float"]:
+                cell_data_type = "number"
+                if prop_type == "integer":
+                    formatterFn = "int"
+            elif "format" in prop and prop["format"] in ["date", "date-time"]:
+                cell_data_type = "date"
+            else:
+                cell_data_type = "text"
+
+        column_def: dict = {}
+        # OpenAPI changes some of the field names.
+        k = to_snake_case(key)
+        column_def["field"] = k
+        if k in [
+            "symbol",
+            "symbol_root",
+            "series_id",
+            "date",
+            "published",
+            "fiscal_year",
+            "period_ending",
+            "period_beginning",
+            "order",
+            "name",
+            "title",
+            "cusip",
+            "isin",
+        ]:
+            column_def["pinned"] = "left"
+
+        column_def["formatterFn"] = formatterFn
+        column_def["headerName"] = prop.get("title", key.title())
+        column_def["description"] = prop.get(
+            "description", prop.get("title", key.title())
+        )
+        column_def["cellDataType"] = cell_data_type
+        column_def["chartDataType"] = (
+            "series"
+            if cell_data_type in ["number", "integer", "float"]
+            and column_def.get("pinned") != "left"
+            else "category"
+        )
+        measurement = prop.get("x-unit_measurement")
+
+        if measurement == "percent":
+            column_def["formatterFn"] = (
+                "normalizedPercent"
+                if prop.get("x-frontend_multiply") == 100
+                else "percent"
+            )
+            column_def["renderFn"] = "greenRed"
+        elif cell_data_type == "number":
+            del column_def["formatterFn"]
+
+        if k in ["cik", "isin", "figi", "cusip", "sedol", "symbol"]:
+            column_def["cellDataType"] = "text"
+            column_def["headerName"] = (
+                column_def["headerName"].upper() if k != "symbol" else "Symbol"
+            )
+
+        column_defs.append(column_def)
+
+    return column_defs

openbb_platform_api-1.0.0/openbb_platform_api/utils/widgets.py

@@ -0,0 +1,240 @@
+"""Utils for building the widgets.json file."""
+
+from copy import deepcopy
+
+TO_CAPS_STRINGS = [
+    "Pe",
+    "Sloos",
+    "Eps",
+    "Ebitda",
+    "Otc",
+    "Cpi",
+    "Pce",
+    "Gdp",
+    "Lbma",
+    "Ipo",
+    "Nbbo",
+    "Ameribor",
+    "Sonia",
+    "Effr",
+    "Sofr",
+    "Iorb",
+    "Estr",
+    "Ecb",
+    "Dpcredit",
+    "Tcm",
+    "Us",
+    "Ice",
+    "Bofa",
+    "Hqm",
+    "Sp500",
+    "Sec",
+    "Cftc",
+    "Cot",
+    "Etf",
+    "Eu",
+    "Tips",
+    "Rss",
+    "Sic",
+    "Cik",
+    "Bls",
+    "Fred",
+    "Cusip",
+]
+
+
+def modify_query_schema(query_schema: list[dict], provider_value: str):
+    """Modify query_schema and the description for the current provider."""
+    modified_query_schema: list = []
+    for item in query_schema:
+        # copy the item
+        _item = deepcopy(item)
+        provider_value_options: dict = {}
+
+        # Exclude provider parameter. Those will be added last.
+        if "parameter_name" in _item and _item["parameter_name"] == "provider":
+            continue
+
+        # Exclude parameters that are not available for the current provider.
+        if (
+            "available_providers" in _item
+            and provider_value not in _item["available_providers"]
+        ):
+            continue
+
+        if provider_value in _item["multiple_items_allowed"] and _item[
+            "multiple_items_allowed"
+        ].get(provider_value, False):
+            _item["description"] = (
+                _item["description"] + " Multiple comma separated items allowed."
+            )
+            _item["type"] = "text"
+            _item["multiSelect"] = True
+
+        if "options" in _item:
+            provider_value_options = _item.pop("options")
+
+        if provider_value in provider_value_options and bool(
+            provider_value_options[provider_value]
+        ):
+            _item["options"] = provider_value_options[provider_value]
+            _item["type"] = "text"
+        elif len(provider_value_options) == 1 and "other" in provider_value_options:
+            _item["options"] = provider_value_options["other"]
+            _item["type"] = "text"
+
+        _item.pop("multiple_items_allowed")
+
+        if "available_providers" in _item:
+            _item.pop("available_providers")
+
+        _item["paramName"] = _item.pop("parameter_name")
+
+        modified_query_schema.append(_item)
+
+    if provider_value != "custom":
+        modified_query_schema.append(
+            {"paramName": "provider", "value": provider_value, "show": False}
+        )
+
+    return modified_query_schema
+
+
+def build_json(openapi: dict, widget_exclude_filter: list):
+    """Build the widgets.json file."""
+    # pylint: disable=import-outside-toplevel
+    from .openapi import data_schema_to_columns_defs, get_query_schema_for_widget
+
+    if not openapi:
+        return {}
+
+    widgets_json: dict = {}
+    routes = [
+        p
+        for p in openapi["paths"]
+        if p.startswith("/api") and "get" in openapi["paths"][p]
+    ]
+    for route in routes:
+        route_api = openapi["paths"][route]
+        method = list(route_api)[0]
+        widget_id = route_api[method]["operationId"]
+
+        # Prepare the query schema of the widget
+        query_schema, has_chart = get_query_schema_for_widget(openapi, route)
+
+        # Extract providers from the query schema
+        providers: list = []
+        for item in query_schema:
+            if item["parameter_name"] == "provider":
+                providers = item["available_providers"]
+
+        if not providers:
+            providers = ["custom"]
+
+        for provider in providers:
+            columns_defs = data_schema_to_columns_defs(openapi, widget_id, provider)
+            _cat = route.split("v1/")[-1]
+            _cats = _cat.split("/")
+            category = _cats[0].title()
+            category = category.replace("Fixedincome", "Fixed Income")
+            subcat = _cats[1].title().replace("_", " ") if len(_cats) > 2 else None
+            name = (
+                widget_id.replace("fixedincome", "fixed income")
+                .replace("_", " ")
+                .title()
+            )
+
+            name = " ".join(
+                [
+                    (word.upper() if word in TO_CAPS_STRINGS else word)
+                    for word in name.split()
+                ]
+            )
+
+            modified_query_schema = modify_query_schema(query_schema, provider)
+
+            provider_map = {
+                "tmx": "TMX",
+                "ecb": "ECB",
+                "econdb": "EconDB",
+                "fmp": "FMP",
+                "oecd": "OECD",
+                "finra": "FINRA",
+                "fred": "FRED",
+                "imf": "IMF",
+                "bls": "BLS",
+                "yfinance": "yFinance",
+                "sec": "SEC",
+                "cftc": "CFTC",
+                "tradingeconomics": "Trading Economics",
+                "wsj": "WSJ",
+            }
+            provider_name = provider_map.get(
+                provider.lower(), provider.replace("_", " ").title()
+            )
+
+            widget_config = {
+                "name": f"{name} ({provider_name})",
+                "description": route_api["get"]["description"],
+                "category": category,
+                "searchCategory": category,
+                "widgetId": f"{widget_id}_{provider}_obb",
+                "params": modified_query_schema,
+                "endpoint": route.replace("/api", "api"),
+                "gridData": {"w": 45, "h": 15},
+                "data": {
+                    "dataKey": "results",
+                    "table": {
+                        "showAll": True,
+                    },
+                },
+                "source": [provider_name],
+            }
+
+            if subcat:
+                subcat = " ".join(
+                    [
+                        (word.upper() if word in TO_CAPS_STRINGS else word)
+                        for word in subcat.split()
+                    ]
+                )
+                subcat = (
+                    subcat.replace("Estimates", "Analyst Estimates")
+                    .replace("Fundamental", "Fundamental Analysis")
+                    .replace("Compare", "Comparison Analysis")
+                )
+                widget_config["subCategory"] = subcat
+
+            if columns_defs:
+                widget_config["data"]["table"]["columnsDefs"] = columns_defs
+
+            # Add the widget configuration to the widgets.json
+            if widget_config["widgetId"] not in widget_exclude_filter:
+                widgets_json[widget_config["widgetId"]] = widget_config
+
+            if has_chart:
+                widget_config_chart = deepcopy(widget_config)
+                widget_config_chart["name"] = widget_config_chart["name"] + " (Chart)"
+                widget_config_chart["widgetId"] = (
+                    f"{widget_config_chart['widgetId']}_chart"
+                )
+                widget_config_chart["params"].append(
+                    {
+                        "paramName": "chart",
+                        "label": "Chart",
+                        "description": "Returns chart",
+                        "optional": True,
+                        "value": True,
+                        "type": "boolean",
+                        "show": False,
+                    },
+                )
+                widget_config_chart["searchCategory"] = "chart"
+                widget_config_chart["gridData"]["h"] = 20
+                widget_config_chart["gridData"]["w"] = 50
+                widget_config_chart["defaultViz"] = "chart"
+                widget_config_chart["data"]["dataKey"] = "chart.content"
+                if widget_config_chart["widgetId"] not in widget_exclude_filter:
+                    widgets_json[widget_config_chart["widgetId"]] = widget_config_chart
+
+    return widgets_json

openbb_platform_api-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "openbb-platform-api"
+version = "1.0.0"
+description = "OpenBB Platform API: Launch script and widgets builder for the OpenBB Platform API and Terminal Pro Connector."
+authors = ["OpenBB <hello@openbb.co>"]
+license = "AGPL-3.0-only"
+readme = "README.md"
+homepage = "https://openbb.co"
+repository = "https://github.com/openbb-finance/openbb"
+documentation = "https://docs.openbb.co"
+packages = [{ include = "openbb_platform_api" }]
+
+[tool.poetry.scripts]
+openbb-api = "openbb_platform_api.main:main"
+
+[tool.poetry.dependencies]
+python = ">=3.9,<3.13"
+poetry = "^1.8"
+setuptools = "*"
+openbb-core = "*"
+deepdiff = "*"
+ruff = "*"
+black = "*"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"