Upload 70 files

.gitattributes

@@ -35,3 +35,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 build/conda/installer/assets/dmg_volume.icns filter=lfs diff=lfs merge=lfs -text
 build/conda/installer/assets/Installer_vertical2.bmp filter=lfs diff=lfs merge=lfs -text
+cli/openbb_cli/assets/styles/default/Consolas.ttf filter=lfs diff=lfs merge=lfs -text

cli/README.md

@@ -0,0 +1,67 @@
+# OpenBB Platform CLI
+
+[![Downloads](https://static.pepy.tech/badge/openbb)](https://pepy.tech/project/openbb)
+[![LatestRelease](https://badge.fury.io/py/openbb.svg)](https://github.com/OpenBB-finance/OpenBB)
+
+| OpenBB is committed to build the future of investment research by focusing on an open source infrastructure accessible to everyone, everywhere. |
+| :---------------------------------------------------------------------------------------------------------------------------------------------: |
+|              ![OpenBBLogo](https://user-images.githubusercontent.com/25267873/218899768-1f0964b8-326c-4f35-af6f-ea0946ac970b.png)               |
+|                                                 Check our website at [openbb.co](www.openbb.co)                                                 |
+
+## Overview
+
+The OpenBB Platform CLI is a command line interface that wraps [OpenBB Platform](https://docs.openbb.co/platform).
+
+It offers a convenient way to interact with the OpenBB Platform and its extensions, as well as automated data collection via OpenBB Routine Scripts.
+
+Find the most complete documentation, examples, and usage guides for the OpenBB Platform CLI [here](https://docs.openbb.co/cli).
+
+## Installation
+
+The command below provides access to all the available OpenBB extensions behind the OpenBB Platform, find the complete list [here](https://my.openbb.co/app/platform/extensions).
+
+```bash
+pip install openbb-cli
+```
+
+> Note: Find the most complete installation hints and tips [here](https://docs.openbb.co/cli/installation).
+
+After the installation is complete, you can deploy the OpenBB Platform CLI by running the following command:
+
+```bash
+openbb
+```
+
+Which should result in the following output:
+
+![image](https://github.com/OpenBB-finance/OpenBB/assets/48914296/f606bb6e-fa00-4fc8-bad2-8269bb4fc38e)
+
+## API keys
+
+To fully leverage the OpenBB Platform you need to get some API keys to connect with data providers. Here are the 3 options on where to set them:
+
+1. OpenBB Hub
+2. Local file
+
+### 1. OpenBB Hub
+
+Set your keys at [OpenBB Hub](https://my.openbb.co/app/platform/credentials) and get your personal access token from <https://my.openbb.co/app/platform/pat> to connect with your account.
+
+> Once you log in, on the Platform CLI (through the `/account` menu, all your credentials will be in sync with the OpenBB Hub.)
+
+### 2. Local file
+
+You can specify the keys directly in the `~/.openbb_platform/user_settings.json` file.
+
+Populate this file with the following template and replace the values with your keys:
+
+```json
+{
+  "credentials": {
+    "fmp_api_key": "REPLACE_ME",
+    "polygon_api_key": "REPLACE_ME",
+    "benzinga_api_key": "REPLACE_ME",
+    "fred_api_key": "REPLACE_ME"
+  }
+}
+```

cli/integration/test_commands.py

@@ -0,0 +1,29 @@
+import io
+
+import pytest
+from openbb_cli.cli import main
+
+
+@pytest.mark.parametrize(
+    "input_values",
+    [
+        "/equity/price/historical --symbol aapl --provider fmp",
+        "/equity/price/historical --symbol msft --provider yfinance",
+        "/equity/price/historical --symbol goog --provider polygon",
+        "/crypto/price/historical --symbol btc --provider fmp",
+        "/currency/price/historical --symbol eur --provider fmp",
+        "/derivatives/futures/historical --symbol cl --provider fmp",
+        "/etf/price/historical --symbol spy --provider fmp",
+        "/economy",
+    ],
+)
+@pytest.mark.integration
+def test_launch_with_cli_input(monkeypatch, input_values):
+    """Test launching the CLI and providing input via stdin with multiple parameters."""
+    stdin = io.StringIO(input_values)
+    monkeypatch.setattr("sys.stdin", stdin)
+
+    try:
+        main()
+    except Exception as e:
+        pytest.fail(f"Main function raised an exception: {e}")

cli/integration/test_integration_base_controller.py

@@ -0,0 +1,89 @@
+"""Integration tests for the base_controller module."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+from openbb_cli.controllers.base_controller import BaseController
+from openbb_cli.session import Session
+
+# pylint: disable=unused-variable, redefined-outer-name
+
+
+class TestController(BaseController):
+    """Test controller for the BaseController."""
+
+    PATH = "/test/"
+
+    def print_help(self):
+        """Print help message."""
+
+
+@pytest.fixture
+def base_controller():
+    """Set up the environment for each test function."""
+    session = Session()  # noqa: F841
+    controller = TestController()
+    return controller
+
+
+@pytest.mark.integration
+def test_check_path_valid(base_controller):
+    """Test that check_path does not raise an error for a valid path."""
+    base_controller.PATH = "/equity/"
+    try:
+        base_controller.check_path()
+    except ValueError:
+        pytest.fail("check_path raised ValueError unexpectedly!")
+
+
+@pytest.mark.integration
+def test_check_path_invalid(base_controller):
+    """Test that check_path raises an error for an invalid path."""
+    with pytest.raises(ValueError):
+        base_controller.PATH = "invalid_path"  # Missing leading '/'
+        base_controller.check_path()
+
+    with pytest.raises(ValueError):
+        base_controller.PATH = "/invalid_path"  # Missing trailing '/'
+        base_controller.check_path()
+
+
+@pytest.mark.integration
+def test_parse_input(base_controller):
+    """Test the parse_input method."""
+    input_str = "/equity/price/help"
+    expected_output = ["", "equity", "price", "help"]
+    assert (
+        base_controller.parse_input(input_str) == expected_output
+    ), "Input parsing failed"
+
+
+@pytest.mark.integration
+def test_switch_command_execution(base_controller):
+    """Test the switch method."""
+    base_controller.queue = []
+    base_controller.switch("/home/../reset/")
+    assert base_controller.queue == [
+        "home",
+        "..",
+        "reset",
+    ], "Switch did not update the queue correctly"
+
+
+@patch("openbb_cli.controllers.base_controller.BaseController.call_help")
+@pytest.mark.integration
+def test_command_routing(mock_call_help, base_controller):
+    """Test the command routing."""
+    base_controller.switch("help")
+    mock_call_help.assert_called_once()
+
+
+@pytest.mark.integration
+def test_custom_reset(base_controller):
+    """Test the custom reset method."""
+    base_controller.custom_reset = Mock(return_value=["custom", "reset"])
+    base_controller.call_reset(None)
+    expected_queue = ["quit", "reset", "custom", "reset"]
+    assert (
+        base_controller.queue == expected_queue
+    ), f"Expected queue to be {expected_queue}, but was {base_controller.queue}"

cli/integration/test_integration_base_platform_controller.py

@@ -0,0 +1,81 @@
+"""Test the base platform controller."""
+
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+from openbb_cli.controllers.base_platform_controller import (
+    PlatformController,
+    Session,
+)
+
+# pylint: disable=protected-access, unused-variable, redefined-outer-name
+
+
+@pytest.fixture
+def platform_controller():
+    """Return a platform controller."""
+    session = Session()  # noqa: F841
+    translators = {"test_command": MagicMock(), "test_menu": MagicMock()}  # noqa: F841
+    translators["test_command"]._parser = Mock(
+        _actions=[Mock(dest="data", choices=[], type=str, nargs=None)]
+    )
+    translators["test_command"].execute_func = Mock(return_value=Mock())
+    translators["test_menu"]._parser = Mock(
+        _actions=[Mock(dest="data", choices=[], type=str, nargs=None)]
+    )
+    translators["test_menu"].execute_func = Mock(return_value=Mock())
+
+    controller = PlatformController(
+        name="test", parent_path=["platform"], translators=translators
+    )
+    return controller
+
+
+@pytest.mark.integration
+def test_platform_controller_initialization(platform_controller):
+    """Test the initialization of the platform controller."""
+    expected_path = "/platform/test/"
+    assert (
+        expected_path == platform_controller.PATH
+    ), "Controller path was not set correctly"
+
+
+@pytest.mark.integration
+def test_command_generation(platform_controller):
+    """Test the generation of commands."""
+    command_name = "test_command"
+    mock_execute_func = Mock(return_value=(Mock(), None))
+    platform_controller.translators[command_name].execute_func = mock_execute_func
+
+    platform_controller._generate_command_call(
+        name=command_name, translator=platform_controller.translators[command_name]
+    )
+    command_method_name = f"call_{command_name}"
+    assert hasattr(
+        platform_controller, command_method_name
+    ), "Command method was not created"
+
+
+@patch(
+    "openbb_cli.controllers.base_platform_controller.PlatformController._link_obbject_to_data_processing_commands"
+)
+@patch(
+    "openbb_cli.controllers.base_platform_controller.PlatformController._generate_commands"
+)
+@patch(
+    "openbb_cli.controllers.base_platform_controller.PlatformController._generate_sub_controllers"
+)
+@pytest.mark.integration
+def test_platform_controller_calls(
+    mock_sub_controllers, mock_commands, mock_link_commands
+):
+    """Test the calls of the platform controller."""
+    translators = {"test_command": Mock()}
+    translators["test_command"].parser = Mock()
+    translators["test_command"].execute_func = Mock()
+    _ = PlatformController(
+        name="test", parent_path=["platform"], translators=translators
+    )
+    mock_sub_controllers.assert_called_once()
+    mock_commands.assert_called_once()
+    mock_link_commands.assert_called_once()

cli/integration/test_integration_cli_controller.py

@@ -0,0 +1,26 @@
+"""Test the CLI controller integration."""
+
+from openbb_cli.controllers.cli_controller import (
+    CLIController,
+)
+
+
+def test_parse_input_valid_commands():
+    """Test parse_input method."""
+    controller = CLIController()
+    input_string = "exe --file test.openbb"
+    expected_output = [
+        "exe --file test.openbb"
+    ]  # Adjust based on actual expected behavior
+    assert controller.parse_input(input_string) == expected_output
+
+
+def test_parse_input_invalid_commands():
+    """Test parse_input method."""
+    controller = CLIController()
+    input_string = "nonexistentcommand args"
+    expected_output = ["nonexistentcommand args"]
+    actual_output = controller.parse_input(input_string)
+    assert (
+        actual_output == expected_output
+    ), f"Expected {expected_output}, got {actual_output}"

cli/integration/test_integration_hub_service.py

@@ -0,0 +1,62 @@
+"""Integration tests for the hub_service module."""
+
+from unittest.mock import create_autospec, patch
+
+import pytest
+import requests
+from openbb_cli.controllers.hub_service import upload_routine
+from openbb_core.app.model.hub.hub_session import HubSession
+
+# pylint: disable=unused-argument, redefined-outer-name, unused-variable
+
+
+@pytest.fixture
+def auth_header():
+    """Return a fake auth header."""
+    return "Bearer fake_token"
+
+
+@pytest.fixture
+def hub_session_mock():
+    """Return a mock HubSession."""
+    mock = create_autospec(HubSession, instance=True)
+    mock.username = "TestUser"
+    return mock
+
+
+# Fixture for routine data
+@pytest.fixture
+def routine_data():
+    """Return a dictionary with routine data."""
+    return {
+        "name": "Test Routine",
+        "description": "A test routine",
+        "routine": "print('Hello World')",
+        "override": False,
+        "tags": "test",
+        "public": True,
+    }
+
+
+@pytest.mark.integration
+def test_upload_routine_timeout(auth_header, routine_data):
+    """Test upload_routine with a timeout exception."""
+    with patch(
+        "requests.post", side_effect=requests.exceptions.Timeout
+    ) as mocked_post:  # noqa: F841
+
+        response = upload_routine(auth_header, **routine_data)
+
+        assert response is None
+
+
+@pytest.mark.integration
+def test_upload_routine_connection_error(auth_header, routine_data):
+    """Test upload_routine with a connection error."""
+    with patch(
+        "requests.post", side_effect=requests.exceptions.ConnectionError
+    ) as mocked_post:  # noqa: F841
+
+        response = upload_routine(auth_header, **routine_data)
+
+        assert response is None

cli/integration/test_integration_obbject_registry.py

@@ -0,0 +1,54 @@
+"""Test the obbject registry."""
+
+from openbb_cli.argparse_translator.obbject_registry import Registry
+from openbb_core.app.model.obbject import OBBject
+
+# pylint: disable=unused-variable
+# ruff: noqa: disable=F841
+
+
+def test_registry_operations():
+    """Test the registry operations."""
+    registry = Registry()
+    obbject1 = OBBject(
+        id="1", results=True, extra={"register_key": "key1", "command": "cmd1"}
+    )
+    obbject2 = OBBject(
+        id="2", results=True, extra={"register_key": "key2", "command": "cmd2"}
+    )
+    obbject3 = OBBject(  # noqa: F841
+        id="3", results=True, extra={"register_key": "key3", "command": "cmd3"}
+    )
+
+    # Add obbjects to the registry
+    assert registry.register(obbject1) is True
+    assert registry.register(obbject2) is True
+    # Attempt to add the same object again
+    assert registry.register(obbject1) is False
+    # Ensure the registry size is correct
+    assert len(registry.obbjects) == 2
+
+    # Get by index
+    assert registry.get(0) == obbject2
+    assert registry.get(1) == obbject1
+    # Get by key
+    assert registry.get("key1") == obbject1
+    assert registry.get("key2") == obbject2
+    # Invalid index/key
+    assert registry.get(2) is None
+    assert registry.get("invalid_key") is None
+
+    # Remove an object
+    registry.remove(0)
+    assert len(registry.obbjects) == 1
+    assert registry.get("key2") is None
+
+    # Validate the 'all' property
+    all_obbjects = registry.all
+    assert "command" in all_obbjects[0]
+    assert all_obbjects[0]["command"] == "cmd1"
+
+    # Clean up by removing all objects
+    registry.remove()
+    assert len(registry.obbjects) == 0
+    assert registry.get("key1") is None

cli/openbb_cli/__init__.py

@@ -0,0 +1 @@
+"""Package init"""

cli/openbb_cli/argparse_translator/argparse_argument.py

@@ -0,0 +1,63 @@
+"""Pydantic models for argparse arguments and argument groups."""
+
+from typing import (
+    Any,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+)
+
+from pydantic import BaseModel, model_validator
+
+SEP = "__"
+
+
+class ArgparseArgumentModel(BaseModel):
+    """Pydantic model for an argparse argument."""
+
+    name: str
+    type: Any
+    dest: str
+    default: Any
+    required: bool
+    action: Literal["store_true", "store"]
+    help: Optional[str]
+    nargs: Optional[Literal["+"]]
+    choices: Optional[Tuple]
+
+    @model_validator(mode="after")  # type: ignore
+    @classmethod
+    def validate_action(cls, values: "ArgparseArgumentModel"):
+        """Validate the action based on the type."""
+        if values.type is bool and values.action != "store_true":
+            raise ValueError('If type is bool, action must be "store_true"')
+        return values
+
+    @model_validator(mode="after")  # type: ignore
+    @classmethod
+    def remove_props_on_store_true(cls, values: "ArgparseArgumentModel"):
+        """Remove type, nargs, and choices if action is store_true."""
+        if values.action == "store_true":
+            values.type = None
+            values.nargs = None
+            values.choices = None
+        return values
+
+    # override
+    def model_dump(self, **kwargs):
+        """Override the model_dump method to remove empty choices."""
+        res = super().model_dump(**kwargs)
+
+        # Check if choices is present and if it's an empty tuple remove it
+        if "choices" in res and not res["choices"]:
+            del res["choices"]
+
+        return res
+
+
+class ArgparseArgumentGroupModel(BaseModel):
+    """Pydantic model for a custom argument group."""
+
+    name: str
+    arguments: List[ArgparseArgumentModel]

cli/openbb_cli/argparse_translator/argparse_class_processor.py

@@ -0,0 +1,147 @@
+"""Module for the ArgparseClassProcessor class."""
+
+import inspect
+from typing import Any, Dict, Optional, Type
+
+# TODO: this needs to be done differently
+from openbb_core.app.static.container import Container
+
+from openbb_cli.argparse_translator.argparse_translator import ArgparseTranslator
+from openbb_cli.argparse_translator.reference_processor import (
+    ReferenceToArgumentsProcessor,
+)
+
+
+class ArgparseClassProcessor:
+    """Process a target class to create ArgparseTranslators for its methods."""
+
+    # reference variable used to create custom groups for the ArgpaseTranslators
+    _reference: Dict[str, Any] = {}
+
+    def __init__(
+        self,
+        target_class: Type,
+        add_help: bool = False,
+        reference: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize the ArgparseClassProcessor.
+
+        Parameters
+        ----------
+        target_class : Type
+            The target class whose methods will be processed.
+        add_help : Optional[bool]
+            Whether to add help to the ArgparseTranslators.
+        """
+        self._target_class: Type = target_class
+        self._add_help: bool = add_help
+        self._translators: Dict[str, ArgparseTranslator] = {}
+        self._paths: Dict[str, str] = {}
+
+        ArgparseClassProcessor._reference = reference or {}
+
+        self._translators = self._process_class(
+            target=self._target_class, add_help=self._add_help
+        )
+        self._paths[self._get_class_name(self._target_class)] = "path"
+        self._build_paths(target=self._target_class)
+
+    @property
+    def translators(self) -> Dict[str, ArgparseTranslator]:
+        """
+        Get the ArgparseTranslators associated with the target class.
+
+        Returns
+        -------
+        Dict[str, ArgparseTranslator]
+            The ArgparseTranslators associated with the target class.
+        """
+        return self._translators
+
+    @property
+    def paths(self) -> Dict[str, str]:
+        """
+        Get the paths associated with the target class.
+
+        Returns
+        -------
+        Dict[str, str]
+            The paths associated with the target class.
+        """
+        return self._paths
+
+    @classmethod
+    def _custom_groups_from_reference(cls, class_name: str, function_name: str) -> Dict:
+        route = f"/{class_name.replace('_', '/')}/{function_name}"
+        reference = {route: cls._reference[route]} if route in cls._reference else {}
+        if not reference:
+            return {}
+        rp = ReferenceToArgumentsProcessor(reference)
+        return rp.custom_groups.get(route, {})  # type: ignore
+
+    @classmethod
+    def _process_class(
+        cls,
+        target: type,
+        add_help: bool = False,
+    ) -> Dict[str, ArgparseTranslator]:
+        methods = {}
+
+        for name, member in inspect.getmembers(target):
+            if name.startswith("__") or name.startswith("_"):
+                continue
+            if inspect.ismethod(member):
+                class_name = cls._get_class_name(target)
+                methods[f"{class_name}_{name}"] = ArgparseTranslator(
+                    func=member,
+                    add_help=add_help,
+                    custom_argument_groups=cls._custom_groups_from_reference(  # type: ignore
+                        class_name=class_name, function_name=name
+                    ),
+                )
+            elif isinstance(member, Container):
+                methods = {
+                    **methods,
+                    **cls._process_class(
+                        target=getattr(target, name), add_help=add_help
+                    ),
+                }
+
+        return methods
+
+    @staticmethod
+    def _get_class_name(target: type) -> str:
+        return (
+            str(type(target))
+            .rsplit(".", maxsplit=1)[-1]
+            .replace("'>", "")
+            .replace("ROUTER_", "")
+            .lower()
+        )
+
+    def get_translator(self, command: str) -> ArgparseTranslator:
+        """
+        Retrieve the ArgparseTranslator object associated with a specific menu and command.
+
+        Parameters
+        ----------
+        command : str
+            The command associated with the ArgparseTranslator.
+
+        Returns
+        -------
+        ArgparseTranslator
+            The ArgparseTranslator associated with the specified menu and command.
+        """
+        return self._translators[command]
+
+    def _build_paths(self, target: type, depth: int = 1):
+        for name, member in inspect.getmembers(target):
+            if name.startswith("__") or name.startswith("_"):
+                continue
+            if inspect.ismethod(member):
+                pass
+            elif isinstance(member, Container):
+                self._build_paths(target=getattr(target, name), depth=depth + 1)
+                self._paths[f"{name}"] = "sub" * depth + "path"

cli/openbb_cli/argparse_translator/argparse_translator.py

@@ -0,0 +1,490 @@
+"""Module for translating a function into an argparse program."""
+
+import argparse
+import inspect
+import re
+from copy import deepcopy
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from openbb_core.app.model.field import OpenBBField
+from pydantic import BaseModel
+from typing_extensions import Annotated
+
+from openbb_cli.argparse_translator.argparse_argument import (
+    ArgparseArgumentGroupModel,
+    ArgparseArgumentModel,
+)
+from openbb_cli.argparse_translator.utils import (
+    get_argument_choices,
+    get_argument_optional_choices,
+    in_group,
+    remove_argument,
+    set_optional_choices,
+)
+
+# pylint: disable=protected-access
+
+SEP = "__"
+
+
+class ArgparseTranslator:
+    """Class to translate a function into an argparse program."""
+
+    def __init__(
+        self,
+        func: Callable,
+        custom_argument_groups: Optional[List[ArgparseArgumentGroupModel]] = None,
+        add_help: Optional[bool] = True,
+    ):
+        """
+        Initialize the ArgparseTranslator.
+
+        Args:
+            func (Callable): The function to translate into an argparse program.
+            add_help (Optional[bool], optional): Whether to add the help argument. Defaults to False.
+        """
+        self.func = func
+        self.signature = inspect.signature(func)
+        self.type_hints = get_type_hints(func)
+        self.provider_parameters: Dict[str, List[str]] = {}
+
+        self._parser = argparse.ArgumentParser(
+            prog=func.__name__,
+            description=self._build_description(func.__doc__),  # type: ignore
+            formatter_class=argparse.RawTextHelpFormatter,
+            add_help=add_help if add_help else False,
+        )
+        self._required = self._parser.add_argument_group("required arguments")
+
+        if any(param in self.type_hints for param in self.signature.parameters):
+            self._generate_argparse_arguments(self.signature.parameters)
+
+        if custom_argument_groups:
+            for group in custom_argument_groups:
+                self.provider_parameters[group.name] = []
+                argparse_group = self._parser.add_argument_group(group.name)
+                for argument in group.arguments:
+                    self._handle_argument_in_groups(argument, argparse_group)
+
+    def _handle_argument_in_groups(self, argument, group):
+        """Handle the argument and add it to the parser."""
+
+        def _update_providers(
+            input_string: str, new_provider: List[Optional[str]]
+        ) -> str:
+            pattern = r"\(provider:\s*(.*?)\)"
+            providers = re.findall(pattern, input_string)
+            providers.extend(new_provider)
+            # remove pattern from help and add with new providers
+            input_string = re.sub(pattern, "", input_string).strip()
+            return f"{input_string} (provider: {', '.join(providers)})"
+
+        # check if the argument is already in use, if not, add it
+        if f"--{argument.name}" not in self._parser._option_string_actions:
+            kwargs = argument.model_dump(exclude={"name"}, exclude_none=True)
+            group.add_argument(f"--{argument.name}", **kwargs)
+            if group.title in self.provider_parameters:
+                self.provider_parameters[group.title].append(argument.name)
+
+        else:
+            kwargs = argument.model_dump(exclude={"name"}, exclude_none=True)
+            model_choices = kwargs.get("choices", ()) or ()
+            # extend choices
+            existing_choices = get_argument_choices(self._parser, argument.name)
+            choices = tuple(set(existing_choices + model_choices))
+            optional_choices = bool(existing_choices and not model_choices)
+
+            # check if the argument is in the required arguments
+            if in_group(self._parser, argument.name, group_title="required arguments"):
+                for action in self._required._group_actions:
+                    if action.dest == argument.name and choices:
+                        # update choices
+                        action.choices = choices
+                        set_optional_choices(action, optional_choices)
+                return
+
+            # check if the argument is in the optional arguments
+            if in_group(self._parser, argument.name, group_title="optional arguments"):
+                for action in self._parser._actions:
+                    if action.dest == argument.name:
+                        # update choices
+                        if choices:
+                            action.choices = choices
+                            set_optional_choices(action, optional_choices)
+                        if argument.name not in self.signature.parameters:
+                            # update help
+                            action.help = _update_providers(
+                                action.help or "", [group.title]
+                            )
+                return
+
+            # we need to check if the optional choices were set in other group
+            # before we remove the argument from the group, otherwise we will lose info
+            if not optional_choices:
+                optional_choices = get_argument_optional_choices(
+                    self._parser, argument.name
+                )
+
+            # if the argument is in use, remove it from all groups
+            # and return the groups that had the argument
+            groups_w_arg = remove_argument(self._parser, argument.name)
+            groups_w_arg.append(group.title)  # add current group
+
+            # add it to the optional arguments group instead
+            if choices:
+                kwargs["choices"] = choices  # update choices
+            # add provider info to the help
+            kwargs["help"] = _update_providers(argument.help or "", groups_w_arg)
+            action = self._parser.add_argument(f"--{argument.name}", **kwargs)
+            set_optional_choices(action, optional_choices)
+
+    @property
+    def parser(self) -> argparse.ArgumentParser:
+        """Get the argparse parser."""
+        return deepcopy(self._parser)
+
+    @staticmethod
+    def _build_description(func_doc: str) -> str:
+        """Build the description of the argparse program from the function docstring."""
+        patterns = ["openbb\n        ======", "Parameters\n        ----------"]
+
+        if func_doc:
+            for pattern in patterns:
+                if pattern in func_doc:
+                    func_doc = func_doc[: func_doc.index(pattern)].strip()
+                    break
+
+        return func_doc
+
+    @staticmethod
+    def _param_is_default(param: inspect.Parameter) -> bool:
+        """Return True if the parameter has a default value."""
+        return param.default != inspect.Parameter.empty
+
+    def _get_action_type(self, param: inspect.Parameter) -> str:
+        """Return the argparse action type for the given parameter."""
+        param_type = self.type_hints[param.name]
+        type_origin = get_origin(param_type)
+        if param_type is bool or (
+            type_origin is Union and bool in get_args(param_type)
+        ):
+            return "store_true"
+        return "store"
+
+    def _get_type_and_choices(  # noqa: PLR0912 # pylint: disable=too-many-return-statements, too-many-branches, too-many-statements
+        self, param: inspect.Parameter
+    ) -> Tuple[Type[Any], Tuple[Any, ...]]:
+        """Return the type and choices for the given parameter."""
+        param_type = self.type_hints[param.name]
+        type_origin = get_origin(param_type)
+
+        choices: tuple[Any, ...] = ()
+
+        if type_origin is Literal:
+            choices = get_args(param_type)
+            # Special handling for boolean literals
+            if all(isinstance(choice, bool) for choice in choices):
+                return bool, ()
+            param_type = type(choices[0])  # type: ignore
+
+        if type_origin is list:
+            param_type = get_args(param_type)[0]
+
+            if get_origin(param_type) is Literal:
+                choices = get_args(param_type)
+                # Special handling for boolean literals in lists
+                if all(isinstance(choice, bool) for choice in choices):
+                    return bool, ()
+                param_type = type(choices[0])  # type: ignore
+
+        if type_origin is Union:
+            union_args = get_args(param_type)
+            # Check if Union contains bool type
+            if bool in union_args and (str in union_args or len(union_args) == 2):
+                return bool, ()
+
+            # Check if Union contains Literal types and extract all choices
+            literal_choices: list = []
+            for arg in union_args:
+                if get_origin(arg) is Literal:
+                    literal_choices.extend(get_args(arg))
+
+            if literal_choices:
+                # Check if all choices are boolean
+                if all(isinstance(choice, bool) for choice in literal_choices):
+                    return bool, ()
+                # We have Literal types in the Union, use their choices
+                choices = tuple(literal_choices)
+                param_type = type(choices[0])  # type: ignore
+            elif str in union_args:
+                param_type = str
+
+            # check if it's an Optional, which would be a Union with NoneType
+            if type(None) in get_args(param_type):
+                # remove NoneType from the args
+                args = [arg for arg in get_args(param_type) if arg is not None]
+                # if there is only one arg left, use it
+                if len(args) == 1:
+                    param_type = args[0]
+
+                    if get_origin(param_type) is Literal:
+                        choices = get_args(param_type)
+                        # Special handling for boolean literals
+                        if all(isinstance(choice, bool) for choice in choices):
+                            return bool, ()
+                        param_type = type(choices[0])  # type: ignore
+                elif len(args) > 1:
+                    # Handle Union with multiple types (not just Optional)
+                    # Try to extract Literal types again from the filtered args
+                    literal_choices = []
+                    for arg in args:
+                        if get_origin(arg) is Literal:
+                            literal_choices.extend(get_args(arg))
+
+                    if literal_choices:
+                        # Check if all choices are boolean
+                        if all(isinstance(choice, bool) for choice in literal_choices):
+                            return bool, ()
+                        choices = tuple(set(literal_choices))
+                        param_type = type(choices[0])  # type: ignore
+
+        # if there are custom choices, override
+        custom_choices = self._get_argument_custom_choices(param)
+        if custom_choices and param_type is not bool:
+            choices = tuple(custom_choices)
+
+        return param_type, choices
+
+    @staticmethod
+    def _split_annotation(
+        base_annotation: Type[Any], custom_annotation_type: Type
+    ) -> Tuple[Type[Any], List[Any]]:
+        """Find the base annotation and the custom annotations, namely the OpenBBField."""
+        if get_origin(base_annotation) is not Annotated:
+            return base_annotation, []
+        base_annotation, *maybe_custom_annotations = get_args(base_annotation)
+        return base_annotation, [
+            annotation
+            for annotation in maybe_custom_annotations
+            if isinstance(annotation, custom_annotation_type)
+        ]
+
+    @classmethod
+    def _get_argument_custom_help(cls, param: inspect.Parameter) -> Optional[str]:
+        """Return the help annotation for the given parameter."""
+        base_annotation = param.annotation
+        _, custom_annotations = cls._split_annotation(base_annotation, OpenBBField)
+        help_annotation = (
+            custom_annotations[0].description if custom_annotations else None
+        )
+        return help_annotation
+
+    @classmethod
+    def _get_argument_custom_choices(cls, param: inspect.Parameter) -> Optional[str]:
+        """Return the help annotation for the given parameter."""
+        base_annotation = param.annotation
+        _, custom_annotations = cls._split_annotation(base_annotation, OpenBBField)
+        choices_annotation = (
+            custom_annotations[0].choices if custom_annotations else None
+        )
+        return choices_annotation
+
+    def _get_nargs(self, param: inspect.Parameter) -> Optional[str]:
+        """Return the nargs annotation for the given parameter."""
+        param_type = self.type_hints[param.name]
+        origin = get_origin(param_type)
+
+        if origin is list:
+            return "+"
+
+        if origin is Union and any(
+            get_origin(arg) is list for arg in get_args(param_type)
+        ):
+            return "+"
+
+        return None
+
+    def _generate_argparse_arguments(self, parameters) -> None:
+        """Generate the argparse arguments from the function parameters."""
+        for param in parameters.values():
+            if param.name == "kwargs":
+                continue
+
+            param_type, choices = self._get_type_and_choices(param)
+
+            # if the param is a custom type, we need to flatten it
+            if inspect.isclass(param_type) and issubclass(param_type, BaseModel):
+                # update type hints with the custom type fields
+                type_hints = get_type_hints(param_type)
+                # prefix the type hints keys with the param name
+                type_hints = {
+                    f"{param.name}{SEP}{key}": value
+                    for key, value in type_hints.items()
+                }
+                self.type_hints.update(type_hints)
+                # create a signature from the custom type
+                sig = inspect.signature(param_type)
+
+                # add help to the annotation
+                annotated_parameters: List[inspect.Parameter] = []
+                for child_param in sig.parameters.values():
+                    new_child_param = child_param.replace(
+                        name=f"{param.name}{SEP}{child_param.name}",
+                        annotation=Annotated[
+                            child_param.annotation,
+                            OpenBBField(
+                                description=param_type.model_json_schema()[
+                                    "properties"
+                                ][child_param.name].get("description", None)
+                            ),
+                        ],
+                        kind=inspect.Parameter.KEYWORD_ONLY,
+                    )
+                    annotated_parameters.append(new_child_param)
+
+                # replacing with the annotated parameters
+                new_signature = inspect.Signature(
+                    parameters=annotated_parameters,
+                    return_annotation=sig.return_annotation,
+                )
+                self._generate_argparse_arguments(new_signature.parameters)
+
+                # the custom type itself should not be added as an argument
+                continue
+
+            required = not self._param_is_default(param)
+
+            # Get the appropriate action based on the parameter type
+            action = self._get_action_type(param)
+
+            # For boolean parameters with action="store_true", we should not use any choices
+            if param_type is bool:
+                choices = ()
+                action = "store_true"
+
+            argument = ArgparseArgumentModel(
+                name=param.name,
+                type=param_type,
+                dest=param.name,
+                default=param.default,
+                required=required,
+                action=action,
+                help=self._get_argument_custom_help(param),
+                nargs=self._get_nargs(param),
+                choices=choices,
+            )
+            kwargs = argument.model_dump(exclude={"name"}, exclude_none=True)
+
+            if required:
+                self._required.add_argument(
+                    f"--{argument.name}",
+                    **kwargs,
+                )
+            else:
+                self._parser.add_argument(
+                    f"--{argument.name}",
+                    **kwargs,
+                )
+
+    @staticmethod
+    def _unflatten_args(args: dict) -> Dict[str, Any]:
+        """Unflatten the args that were flattened by the custom types."""
+        result: Dict[str, Any] = {}
+        for key, value in args.items():
+            if SEP in key:
+                parts = key.split(SEP)
+                nested_dict = result
+                for part in parts[:-1]:
+                    if part not in nested_dict:
+                        nested_dict[part] = {}
+                    nested_dict = nested_dict[part]
+                nested_dict[parts[-1]] = value
+            else:
+                result[key] = value
+        return result
+
+    def _update_with_custom_types(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """Update the kwargs with the custom types."""
+        # for each argument in the signature that is a custom type, we need to
+        # update the kwargs with the custom type kwargs
+        for param in self.signature.parameters.values():
+            if param.name == "kwargs":
+                continue
+            param_type, _ = self._get_type_and_choices(param)
+            if inspect.isclass(param_type) and issubclass(param_type, BaseModel):
+                custom_type_kwargs = kwargs[param.name]
+                kwargs[param.name] = param_type(**custom_type_kwargs)
+
+        return kwargs
+
+    def execute_func(
+        self,
+        parsed_args: Optional[argparse.Namespace] = None,
+    ) -> Any:
+        """
+        Execute the original function with the parsed arguments.
+
+        Args:
+            parsed_args (Optional[argparse.Namespace], optional): The parsed arguments. Defaults to None.
+
+        Returns:
+            Any: The return value of the original function.
+
+        """
+        kwargs = self._unflatten_args(vars(parsed_args))
+        kwargs = self._update_with_custom_types(kwargs)
+        provider = kwargs.get("provider")
+        provider_args: List = []
+        if provider and provider in self.provider_parameters:
+            provider_args = self.provider_parameters[provider]
+        else:
+            for args in self.provider_parameters.values():
+                provider_args.extend(args)
+
+        # remove kwargs not matching the signature, provider parameters, or are empty.
+        kwargs = {
+            key: value
+            for key, value in kwargs.items()
+            if (
+                (key in self.signature.parameters or key in provider_args)
+                and (value or value is False)
+            )
+        }
+        return self.func(**kwargs)
+
+    def parse_args_and_execute(self) -> Any:
+        """
+        Parse the arguments and executes the original function.
+
+        Returns:
+            Any: The return value of the original function.
+        """
+        parsed_args = self._parser.parse_args()
+
+        return self.execute_func(parsed_args)
+
+    def translate(self) -> Callable:
+        """
+        Wrap the original function with an argparse program.
+
+        Returns:
+            Callable: The original function wrapped with an argparse program.
+        """
+
+        def wrapper_func():
+            return self.parse_args_and_execute()
+
+        return wrapper_func

cli/openbb_cli/argparse_translator/obbject_registry.py

@@ -0,0 +1,129 @@
+"""Registry for OBBjects."""
+
+import json
+from typing import Dict, List, Optional, Union
+
+from openbb_core.app.model.obbject import OBBject
+
+
+class Registry:
+    """Registry for OBBjects."""
+
+    def __init__(self):
+        """Initialize the registry."""
+        self._obbjects: List[OBBject] = []
+
+    @staticmethod
+    def _contains_obbject(uuid: str, obbjects: List[OBBject]) -> bool:
+        """Check if obbject with uuid is in the registry."""
+        return any(obbject.id == uuid for obbject in obbjects)
+
+    def register(self, obbject: OBBject) -> bool:
+        """Designed to add an OBBject instance to the registry."""
+        if (
+            isinstance(obbject, OBBject)
+            and not self._contains_obbject(obbject.id, self._obbjects)
+            and obbject.results
+        ):
+            self._obbjects.append(obbject)
+            return True
+        return False
+
+    def get(self, arg: Union[int, str]) -> Optional[OBBject]:
+        """Return the obbject with index or key."""
+        if isinstance(arg, int):
+            return self._get_by_index(arg)
+        if isinstance(arg, str):
+            return self._get_by_key(arg)
+
+        raise ValueError("Couldn't get the `OBBject` with the provided argument.")
+
+    def _get_by_key(self, key: str) -> Optional[OBBject]:
+        """Return the obbject with key."""
+        for obbject in self._obbjects:
+            if obbject.extra.get("register_key", "") == key:
+                return obbject
+        return None
+
+    def _get_by_index(self, idx: int) -> Optional[OBBject]:
+        """Return the obbject at index idx."""
+        # the list should work as a stack
+        # i.e., the last element needs to be accessed by idx=0 and so on
+        reversed_list = list(reversed(self._obbjects))
+
+        # check if the index is out of bounds
+        if idx >= len(reversed_list):
+            return None
+
+        return reversed_list[idx]
+
+    def remove(self, idx: int = -1):
+        """Remove the obbject at index idx, default is the last element."""
+        # the list should work as a stack
+        # i.e., the last element needs to be accessed by idx=0 and so on
+        reversed_list = list(reversed(self._obbjects))
+        del reversed_list[idx]
+        self._obbjects = list(reversed(reversed_list))
+
+    @property
+    def all(self) -> Dict[int, Dict]:
+        """Return all obbjects in the registry."""
+
+        def _handle_standard_params(obbject: OBBject) -> str:
+            """Handle standard params for obbjects."""
+            standard_params_json = ""
+            std_params = getattr(
+                obbject, "_standard_params", {}
+            )  # pylint: disable=protected-access
+            if std_params:
+                standard_params = {
+                    k: str(v)[:30] for k, v in std_params.items() if v and k != "data"
+                }
+                standard_params_json = json.dumps(standard_params)
+
+            return standard_params_json
+
+        def _handle_data_repr(obbject: OBBject) -> str:
+            """Handle data representation for obbjects."""
+            data_repr = ""
+            if hasattr(obbject, "results") and obbject.results:
+                data_schema = (
+                    obbject.results[0].model_json_schema()
+                    if obbject.results
+                    and isinstance(obbject.results, list)
+                    and hasattr(obbject.results[0], "model_json_schema")
+                    else ""
+                )
+                if data_schema and "title" in data_schema:
+                    data_repr = f"{data_schema['title']}"  # type: ignore
+                if data_schema and "description" in data_schema:
+                    data_repr += f" - {data_schema['description'].split('.')[0]}"  # type: ignore
+
+            return data_repr
+
+        obbjects = {}
+        for i, obbject in enumerate(list(reversed(self._obbjects))):
+            obbjects[i] = {
+                "route": obbject._route,  # pylint: disable=protected-access
+                "provider": obbject.provider,
+                "standard params": _handle_standard_params(obbject),
+                "data": _handle_data_repr(obbject),
+                "command": obbject.extra.get("command", ""),
+                "key": obbject.extra.get("register_key", ""),
+            }
+
+        return obbjects
+
+    @property
+    def obbjects(self) -> List[OBBject]:
+        """Return all obbjects in the registry."""
+        return self._obbjects
+
+    @property
+    def obbject_keys(self) -> List[str]:
+        """Return all obbject keys in the registry."""
+        return [
+            obbject.extra["register_key"]
+            for obbject in self._obbjects
+            if "register_key" in obbject.extra
+        ]

cli/openbb_cli/argparse_translator/reference_processor.py

@@ -0,0 +1,142 @@
+"""Module for the ReferenceToArgumentsProcessor class."""
+
+# `ForwardRef`needs to be imported because the usage of `eval()`,
+# which creates a ForwardRef
+# which would raise a not defined error if it's not imported here.
+# pylint: disable=unused-import
+from typing import (
+    Any,
+    Dict,
+    ForwardRef,  # noqa: F401
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+)
+
+from openbb_cli.argparse_translator.argparse_argument import (
+    ArgparseArgumentGroupModel,
+    ArgparseArgumentModel,
+)
+
+
+class ReferenceToArgumentsProcessor:
+    """Class to process the reference and build custom argument groups."""
+
+    def __init__(self, reference: Dict[str, Dict]):
+        """Initialize the ReferenceToArgumentsProcessor."""
+        self._reference = reference
+        self._custom_groups: Dict[str, List[ArgparseArgumentGroupModel]] = {}
+
+        self._build_custom_groups()
+
+    @property
+    def custom_groups(self) -> Dict[str, List[ArgparseArgumentGroupModel]]:
+        """Get the custom groups."""
+        return self._custom_groups
+
+    @staticmethod
+    def _make_type_parsable(type_: str) -> type:
+        """Make the type parsable by removing the annotations."""
+        if "Union" in type_ and "str" in type_:
+            return str
+        if "Union" in type_ and "int" in type_:
+            return int
+        if type_ in ["date", "datetime.time", "time"]:
+            return str
+
+        if any(x in type_ for x in ["gt=", "ge=", "lt=", "le="]):
+            if "Annotated" in type_:
+                type_ = type_.replace("Annotated[", "").replace("]", "")
+            type_ = type_.split(",")[0]
+
+        return eval(type_)  # noqa: S307, E501 pylint: disable=eval-used
+
+    def _parse_type(self, type_: str) -> type:
+        """Parse the type from the string representation."""
+        type_ = self._make_type_parsable(type_)  # type: ignore
+
+        if get_origin(type_) is Literal:
+            type_ = type(get_args(type_)[0])  # type: ignore
+
+        return type_  # type: ignore
+
+    def _get_nargs(self, type_: type) -> Optional[Union[int, str]]:
+        """Get the nargs for the given type."""
+        if get_origin(type_) is list:
+            return "+"
+        return None
+
+    def _get_choices(self, type_: str, custom_choices: Any) -> Tuple:
+        """Get the choices for the given type."""
+        type_ = self._make_type_parsable(type_)  # type: ignore
+        type_origin = get_origin(type_)
+
+        choices: tuple[Any, ...] = ()
+
+        if type_origin is Literal:
+            choices = get_args(type_)
+
+        if type_origin is list:
+            type_ = get_args(type_)[0]
+
+            if get_origin(type_) is Literal:
+                choices = get_args(type_)
+
+        if type_origin is Union and type(None) in get_args(type_):
+            # remove NoneType from the args
+            args = [arg for arg in get_args(type_) if arg != type(None)]
+            # if there is only one arg left, use it
+            if len(args) > 1:
+                raise ValueError("Union with NoneType should have only one type left")
+            type_ = args[0]
+
+            if get_origin(type_) is Literal:
+                choices = get_args(type_)
+
+        if custom_choices:
+            return tuple(custom_choices)
+
+        return choices
+
+    def _build_custom_groups(self):
+        """Build the custom groups from the reference."""
+        for route, v in self._reference.items():
+            for provider, args in v["parameters"].items():
+                if provider == "standard":
+                    continue
+
+                custom_arguments = []
+                for arg in args:
+                    if arg.get("standard"):
+                        continue
+
+                    type_ = self._parse_type(arg["type"])
+
+                    custom_arguments.append(
+                        ArgparseArgumentModel(
+                            name=arg["name"],
+                            type=type_,
+                            dest=arg["name"],
+                            default=arg["default"],
+                            required=not (arg["optional"]),
+                            action="store" if type_ != bool else "store_true",
+                            help=arg["description"],
+                            nargs=self._get_nargs(type_),  # type: ignore
+                            choices=self._get_choices(
+                                arg["type"], custom_choices=arg["choices"]
+                            ),
+                        )
+                    )
+
+                group = ArgparseArgumentGroupModel(
+                    name=provider, arguments=custom_arguments
+                )
+
+                if route not in self._custom_groups:
+                    self._custom_groups[route] = []
+
+                self._custom_groups[route].append(group)

cli/openbb_cli/argparse_translator/utils.py

@@ -0,0 +1,76 @@
+"""Utilities for argparse_translator module."""
+
+from argparse import Action, ArgumentParser
+from typing import List, Optional, Tuple
+
+
+def in_group(parser: ArgumentParser, argument_name: str, group_title: str) -> bool:
+    """Check if an argument is in a group of an ArgumentParser."""
+    for action_group in parser._action_groups:  # pylint: disable=protected-access
+        if action_group.title == group_title:
+            for (
+                action
+            ) in action_group._group_actions:  # pylint: disable=protected-access
+                opts = action.option_strings
+                if (opts and opts[0] == argument_name) or action.dest == argument_name:
+                    return True
+    return False
+
+
+def remove_argument(parser: ArgumentParser, argument_name: str) -> List[Optional[str]]:
+    """Remove an argument from an ArgumentParser."""
+    groups_w_arg = []
+
+    # remove the argument from the parser
+    for action in parser._actions:  # pylint: disable=protected-access
+        opts = action.option_strings
+        if (opts and opts[0] == argument_name) or action.dest == argument_name:
+            parser._remove_action(action)  # pylint: disable=protected-access
+            break
+
+    # remove from all groups
+    for action_group in parser._action_groups:  # pylint: disable=protected-access
+        for action in action_group._group_actions:  # pylint: disable=protected-access
+            opts = action.option_strings
+            if (opts and opts[0] == argument_name) or action.dest == argument_name:
+                action_group._group_actions.remove(  # pylint: disable=protected-access
+                    action
+                )
+                groups_w_arg.append(action_group.title)
+
+    # remove from _action_groups dict
+    parser._option_string_actions.pop(  # pylint: disable=protected-access
+        f"--{argument_name}", None
+    )
+
+    return groups_w_arg
+
+
+def get_argument_choices(parser: ArgumentParser, argument_name: str) -> Tuple:
+    """Get the choices of an argument from an ArgumentParser."""
+    for action in parser._actions:  # pylint: disable=protected-access
+        opts = action.option_strings
+        if (opts and opts[0] == argument_name) or action.dest == argument_name:
+            return tuple(action.choices or ())
+    return ()
+
+
+def get_argument_optional_choices(parser: ArgumentParser, argument_name: str) -> bool:
+    """Get the optional_choices attribute of an argument from an ArgumentParser."""
+    for action in parser._actions:  # pylint: disable=protected-access
+        opts = action.option_strings
+        if (
+            (opts and opts[0] == argument_name)
+            or action.dest == argument_name
+            and hasattr(action, "optional_choices")
+        ):
+            return (
+                action.optional_choices  # type: ignore[attr-defined] # this is a custom attribute
+            )
+    return False
+
+
+def set_optional_choices(action: Action, optional_choices: bool):
+    """Set the optional_choices attribute of an action."""
+    if not hasattr(action, "optional_choices") and optional_choices:
+        setattr(action, "optional_choices", optional_choices)

cli/openbb_cli/assets/routines/routine_example.openbb

@@ -0,0 +1,21 @@
+# Go into the equity context
+equity
+
+# Get the company's profile
+profile --symbol aapl
+
+# Get company's statements
+fundamental
+balance --symbol aapl
+cash --symbol aapl
+transcript --symbol aapl --year 2023
+
+# Load company's historical data
+../price
+historical --symbol aapl
+
+# Get its performance
+performance --symbol aapl
+
+# Export the candle as an image and the historical data into a csv
+historical --symbol aapl --chart --export csv,jpg

cli/openbb_cli/assets/styles/default/Consolas.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:423504695a3de1f80c618e3e6ead215a6b891be06c179bf048bb5a80d5d0eda3
+size 358460

cli/openbb_cli/assets/styles/default/dark.mpfstyle.json

@@ -0,0 +1,47 @@
+{
+    "style_name": "dark",
+    "base_mpf_style": null,
+    "marketcolors": {
+        "candle": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "edge": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "wick": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "ohlc": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "volume": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "vcedge": {
+            "up": "#219E4F",
+            "down": "#9E1711"
+        },
+        "vcdopcod": true,
+        "alpha": 1
+    },
+    "mavcolors": [
+        "#EB3DBC",
+        "#31EBEA",
+        "#EB8C54",
+        "#EB5549"
+    ],
+    "y_on_right": true,
+    "gridcolor": "#A3A0A2",
+    "gridstyle": ":",
+    "facecolor": "black",
+    "edgecolor": null,
+    "figcolor": null,
+    "gridaxis": null,
+    "rc": null,
+    "legacy_rc": null
+}

cli/openbb_cli/assets/styles/default/dark.mplrc.json

@@ -0,0 +1,7 @@
+{
+    "xticks_rotation": 10,
+    "tight_layout_padding": 2,
+    "pie_wedgeprops": {"linewidth": 0.5, "edgecolor": "#FFFFFF"},
+    "pie_startangle": 90,
+    "volume_bar_width": 0.5
+}

cli/openbb_cli/assets/styles/default/dark.mplstyle

@@ -0,0 +1,96 @@
+# The cool hackerman style
+
+# LINES
+# http://matplotlib.org/api/artist_api.html#module-matplotlib.lines
+lines.linewidth: 1.5
+lines.color: F5EFF3
+lines.linestyle: -
+lines.marker: None
+lines.markeredgewidth: 0.5
+lines.markersize: 4
+lines.dash_joinstyle: miter
+lines.dash_capstyle: butt
+lines.solid_joinstyle: miter
+lines.solid_capstyle: projecting
+lines.antialiased: True
+
+patch.edgecolor: F5EFF3
+patch.facecolor: 00aaff
+patch.linewidth: 1
+
+# TEXT
+# http://matplotlib.org/api/font_manager_api.html
+font.family: sans-serif
+font.sans-serif: Consolas, Deja Vu Sans, Arial, Helvetica
+font.style: normal
+font.variant: normal
+font.weight: medium
+font.stretch: normal
+font.size: 16
+
+text.color: F5EFF3
+
+axes.spines.left: true
+axes.spines.bottom: true
+axes.spines.top: true
+axes.spines.right: true
+axes.linewidth: 0.4
+
+axes.labelsize: small
+axes.titlelocation: left
+
+axes.facecolor: black
+axes.edgecolor: F5EFF3
+axes.labelcolor: F5EFF3
+axes.grid: true
+axes.grid.which: major
+
+axes.prop_cycle: cycler('color', ['ffed00', 'ef7d00', 'e4003a', 'c13246', '822661', '48277c', '005ca9', '00aaff', '9b30d9', 'af005f', '5f00af', 'af87ff'])
+
+xtick.color: F5EFF3
+ytick.color: F5EFF3
+
+xtick.major.size: 2
+xtick.minor.size: 1
+xtick.labelsize: small
+xtick.alignment: center
+xtick.major.width: 0.2
+
+ytick.major.size: 2
+ytick.minor.size: 1
+ytick.labelsize: small
+
+ytick.left: False
+ytick.labelleft: False
+ytick.right: True
+ytick.labelright: True
+ytick.major.width: 0.2
+
+grid.color: F5EFF3
+grid.linewidth: 0.4
+grid.linestyle: :
+
+legend.framealpha: 0.6
+legend.frameon: true
+legend.facecolor: black
+legend.edgecolor: black
+legend.scatterpoints: 3
+legend.fontsize: small
+legend.loc: upper left
+
+figure.facecolor: black
+figure.edgecolor: black
+figure.subplot.hspace: 0.2
+
+savefig.facecolor: black
+savefig.edgecolor: black
+
+### Boxplots
+boxplot.boxprops.color: F5EFF3
+boxplot.capprops.color: F5EFF3
+boxplot.flierprops.color: F5EFF3
+boxplot.flierprops.markeredgecolor: F5EFF3
+boxplot.whiskerprops.color: F5EFF3
+boxplot.medianprops.color: F5EFF3
+boxplot.meanprops.markeredgecolor: F5EFF3
+boxplot.meanprops.color: F5EFF3

cli/openbb_cli/assets/styles/default/dark.pltstyle.json

@@ -0,0 +1,132 @@
+{
+    "line": {
+        "up_color": "#00ACFF",
+        "down_color": "#e4003a",
+        "color": "#ffed00",
+        "width": 1.5
+    },
+    "data": {
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#e4003a",
+                    "line": {
+                        "color": "#e4003a"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#00ACFF",
+                    "line": {
+                        "color": "#00ACFF"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "colorway": [
+            "#ffed00",
+            "#ef7d00",
+            "#e4003a",
+            "#c13246",
+            "#822661",
+            "#48277c",
+            "#005ca9",
+            "#00aaff",
+            "#9b30d9",
+            "#af005f",
+            "#5f00af",
+            "#af87ff"
+        ],
+        "dragmode": "pan",
+        "font": {
+            "family": "Fira Code",
+            "size": 18
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "mapbox": {
+            "style": "dark"
+        },
+        "hovermode": "x",
+        "legend": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "x": 0.01,
+            "xanchor": "left",
+            "y": 0.99,
+            "yanchor": "top",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend2": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend3": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend4": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "legend5": {
+            "bgcolor": "rgba(0, 0, 0, 0.5)",
+            "font": {
+                "size": 15
+            }
+        },
+        "paper_bgcolor": "#000000",
+        "plot_bgcolor": "#000000",
+        "xaxis": {
+            "automargin": true,
+            "autorange": true,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 14
+            },
+            "zeroline": false,
+            "tick0": 1,
+            "title": {
+                "standoff": 20
+            },
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        },
+        "yaxis": {
+            "anchor": "x",
+            "automargin": true,
+            "fixedrange": false,
+            "zeroline": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "tick0": 0.5,
+            "title": {
+                "standoff": 20
+            },
+            "gridcolor": "#283442",
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        }
+    }
+}

cli/openbb_cli/assets/styles/default/dark.richstyle.json

@@ -0,0 +1,9 @@
+{
+    "info": "rgb(224,131,48)",
+    "cmds": "rgb(102,203,228)",
+    "param": "rgb(247,206,70)",
+    "menu": "rgb(50,115,185)",
+    "src": "rgb(216,90,64)",
+    "unvl": "grey30",
+    "help": "#FAC900"
+}

cli/openbb_cli/assets/styles/default/light.mpfstyle.json

@@ -0,0 +1,47 @@
+{
+    "style_name": "light",
+    "base_mpf_style": null,
+    "marketcolors": {
+        "candle": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "edge": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "wick": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "ohlc": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "volume": {
+            "up": "#00ACFF",
+            "down": "#e4003a"
+        },
+        "vcedge": {
+            "up": "#219E4F",
+            "down": "#9E1711"
+        },
+        "vcdopcod": true,
+        "alpha": 1
+    },
+    "mavcolors": [
+        "#EB3DBC",
+        "#31EBEA",
+        "#EB8C54",
+        "#EB5549"
+    ],
+    "y_on_right": true,
+    "gridcolor": "grey",
+    "gridstyle": ":",
+    "facecolor": "white",
+    "edgecolor": null,
+    "figcolor": null,
+    "gridaxis": null,
+    "rc": null,
+    "legacy_rc": null
+}

cli/openbb_cli/assets/styles/default/light.mplrc.json

@@ -0,0 +1,7 @@
+{
+    "xticks_rotation": 10,
+    "tight_layout_padding": 2,
+    "pie_wedgeprops": {"linewidth": 0.5, "edgecolor": "#000000"},
+    "pie_startangle": 90,
+    "volume_bar_width": 0.5
+}

cli/openbb_cli/assets/styles/default/light.mplstyle

@@ -0,0 +1,95 @@
+# The cool hackerman style
+
+# LINES
+# http://matplotlib.org/api/artist_api.html#module-matplotlib.lines
+lines.linewidth: 1.1
+lines.color: 0F0F0F
+lines.linestyle: -
+lines.marker: None
+lines.markeredgewidth: 0.5
+lines.markersize: 4
+lines.dash_joinstyle: miter
+lines.dash_capstyle: butt
+lines.solid_joinstyle: miter
+lines.solid_capstyle: projecting
+lines.antialiased: True
+
+patch.edgecolor: 000000
+patch.facecolor: 822661
+patch.linewidth: 1
+
+# TEXT
+# http://matplotlib.org/api/font_manager_api.html
+font.family: sans-serif
+font.sans-serif: Consolas, Deja Vu Sans, Arial, Helvetica
+font.style: normal
+font.variant: normal
+font.weight: medium
+font.stretch: normal
+font.size: 13
+
+text.color: 0F0F0F
+
+axes.spines.left: true
+axes.spines.bottom: true
+axes.spines.top: true
+axes.spines.right: true
+axes.linewidth: 0.2
+
+axes.labelsize: small
+axes.titlelocation: left
+
+axes.facecolor: white
+axes.edgecolor: 0F0F0F
+axes.labelcolor: 0F0F0F
+axes.grid: true
+axes.grid.which: major
+
+axes.prop_cycle: cycler('color', ['254495', 'c13246', '48277c', 'e4003a', 'ef7d00', '822661', 'ffed00', '00aaff', '9b30d9', 'af005f', '5f00af', 'af87ff'])
+
+xtick.color: 0F0F0F
+ytick.color: 0F0F0F
+
+xtick.major.size: 2
+xtick.minor.size: 1
+xtick.labelsize: small
+
+ytick.major.size: 2
+ytick.minor.size: 1
+ytick.labelsize: small
+xtick.alignment: center
+
+ytick.left: False
+ytick.labelleft: False
+ytick.right: True
+ytick.labelright: True
+
+
+grid.color: 0F0F0F
+grid.linewidth: 0.4
+grid.linestyle: :
+
+legend.framealpha: 0.6
+legend.frameon: true
+legend.facecolor: white
+legend.edgecolor: white
+legend.scatterpoints: 3
+legend.fontsize: small
+legend.loc: best
+
+figure.facecolor: white
+figure.edgecolor: white
+figure.subplot.hspace: 0.2
+
+savefig.facecolor: white
+savefig.edgecolor: white
+
+### Boxplots
+boxplot.boxprops.color: 0F0F0F
+boxplot.capprops.color: 0F0F0F
+boxplot.flierprops.color: 0F0F0F
+boxplot.flierprops.markeredgecolor: 0F0F0F
+boxplot.whiskerprops.color: 0F0F0F
+boxplot.medianprops.color: 0F0F0F
+boxplot.meanprops.markeredgecolor: 0F0F0F
+boxplot.meanprops.color: 0F0F0F

cli/openbb_cli/assets/styles/default/light.pltstyle.json

@@ -0,0 +1,871 @@
+{
+    "line": {
+        "up_color": "#009600",
+        "down_color": "#c80000",
+        "color": "#0d0887",
+        "width": 1.5,
+        "down_color_transparent": "rgba(200, 0, 0, 0.4)",
+        "up_color_transparent": "rgba(0, 150, 0, 0.4)"
+    },
+    "data": {
+        "barpolar": [
+            {
+                "marker": {
+                    "line": {
+                        "color": "white",
+                        "width": 0.5
+                    },
+                    "pattern": {
+                        "fillmode": "overlay",
+                        "size": 10,
+                        "solidity": 0.2
+                    }
+                },
+                "type": "barpolar"
+            }
+        ],
+        "bar": [
+            {
+                "error_x": {
+                    "color": "#2a3f5f"
+                },
+                "error_y": {
+                    "color": "#2a3f5f"
+                },
+                "marker": {
+                    "line": {
+                        "color": "white",
+                        "width": 0.5
+                    },
+                    "pattern": {
+                        "fillmode": "overlay",
+                        "size": 10,
+                        "solidity": 0.2
+                    }
+                },
+                "type": "bar"
+            }
+        ],
+        "carpet": [
+            {
+                "aaxis": {
+                    "endlinecolor": "#2a3f5f",
+                    "gridcolor": "#C8D4E3",
+                    "linecolor": "#C8D4E3",
+                    "minorgridcolor": "#C8D4E3",
+                    "startlinecolor": "#2a3f5f"
+                },
+                "baxis": {
+                    "endlinecolor": "#2a3f5f",
+                    "gridcolor": "#C8D4E3",
+                    "linecolor": "#C8D4E3",
+                    "minorgridcolor": "#C8D4E3",
+                    "startlinecolor": "#2a3f5f"
+                },
+                "type": "carpet"
+            }
+        ],
+        "choropleth": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "type": "choropleth"
+            }
+        ],
+        "contourcarpet": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "type": "contourcarpet"
+            }
+        ],
+        "contour": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "contour"
+            }
+        ],
+        "heatmapgl": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "heatmapgl"
+            }
+        ],
+        "heatmap": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "heatmap"
+            }
+        ],
+        "histogram2dcontour": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "histogram2dcontour"
+            }
+        ],
+        "histogram2d": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "histogram2d"
+            }
+        ],
+        "histogram": [
+            {
+                "marker": {
+                    "pattern": {
+                        "fillmode": "overlay",
+                        "size": 10,
+                        "solidity": 0.2
+                    }
+                },
+                "type": "histogram"
+            }
+        ],
+        "mesh3d": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "type": "mesh3d"
+            }
+        ],
+        "parcoords": [
+            {
+                "line": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "parcoords"
+            }
+        ],
+        "pie": [
+            {
+                "automargin": true,
+                "type": "pie"
+            }
+        ],
+        "scatter3d": [
+            {
+                "line": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scatter3d"
+            }
+        ],
+        "scattercarpet": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scattercarpet"
+            }
+        ],
+        "scattergeo": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scattergeo"
+            }
+        ],
+        "scattergl": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scattergl"
+            }
+        ],
+        "scattermapbox": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scattermapbox"
+            }
+        ],
+        "scatterpolargl": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scatterpolargl"
+            }
+        ],
+        "scatterpolar": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scatterpolar"
+            }
+        ],
+        "scatter": [
+            {
+                "fillpattern": {
+                    "fillmode": "overlay",
+                    "size": 10,
+                    "solidity": 0.2
+                },
+                "type": "scatter"
+            }
+        ],
+        "scatterternary": [
+            {
+                "marker": {
+                    "colorbar": {
+                        "outlinewidth": 0,
+                        "ticks": ""
+                    }
+                },
+                "type": "scatterternary"
+            }
+        ],
+        "surface": [
+            {
+                "colorbar": {
+                    "outlinewidth": 0,
+                    "ticks": ""
+                },
+                "colorscale": [
+                    [
+                        0.0,
+                        "#0d0887"
+                    ],
+                    [
+                        0.1111111111111111,
+                        "#46039f"
+                    ],
+                    [
+                        0.2222222222222222,
+                        "#7201a8"
+                    ],
+                    [
+                        0.3333333333333333,
+                        "#9c179e"
+                    ],
+                    [
+                        0.4444444444444444,
+                        "#bd3786"
+                    ],
+                    [
+                        0.5555555555555556,
+                        "#d8576b"
+                    ],
+                    [
+                        0.6666666666666666,
+                        "#ed7953"
+                    ],
+                    [
+                        0.7777777777777778,
+                        "#fb9f3a"
+                    ],
+                    [
+                        0.8888888888888888,
+                        "#fdca26"
+                    ],
+                    [
+                        1.0,
+                        "#f0f921"
+                    ]
+                ],
+                "type": "surface"
+            }
+        ],
+        "table": [
+            {
+                "cells": {
+                    "fill": {
+                        "color": "#EBF0F8"
+                    },
+                    "line": {
+                        "color": "white"
+                    }
+                },
+                "header": {
+                    "fill": {
+                        "color": "#C8D4E3"
+                    },
+                    "line": {
+                        "color": "white"
+                    }
+                },
+                "type": "table"
+            }
+        ],
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#c80000",
+                    "line": {
+                        "color": "#990000"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#009600",
+                    "line": {
+                        "color": "#007500"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "arrowcolor": "#2a3f5f",
+            "arrowhead": 0,
+            "arrowwidth": 1,
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "coloraxis": {
+            "colorbar": {
+                "outlinewidth": 0,
+                "ticks": ""
+            }
+        },
+        "colorscale": {
+            "diverging": [
+                [
+                    0,
+                    "#8e0152"
+                ],
+                [
+                    0.1,
+                    "#c51b7d"
+                ],
+                [
+                    0.2,
+                    "#de77ae"
+                ],
+                [
+                    0.3,
+                    "#f1b6da"
+                ],
+                [
+                    0.4,
+                    "#fde0ef"
+                ],
+                [
+                    0.5,
+                    "#f7f7f7"
+                ],
+                [
+                    0.6,
+                    "#e6f5d0"
+                ],
+                [
+                    0.7,
+                    "#b8e186"
+                ],
+                [
+                    0.8,
+                    "#7fbc41"
+                ],
+                [
+                    0.9,
+                    "#4d9221"
+                ],
+                [
+                    1,
+                    "#276419"
+                ]
+            ],
+            "sequential": [
+                [
+                    0.0,
+                    "#0d0887"
+                ],
+                [
+                    0.1111111111111111,
+                    "#46039f"
+                ],
+                [
+                    0.2222222222222222,
+                    "#7201a8"
+                ],
+                [
+                    0.3333333333333333,
+                    "#9c179e"
+                ],
+                [
+                    0.4444444444444444,
+                    "#bd3786"
+                ],
+                [
+                    0.5555555555555556,
+                    "#d8576b"
+                ],
+                [
+                    0.6666666666666666,
+                    "#ed7953"
+                ],
+                [
+                    0.7777777777777778,
+                    "#fb9f3a"
+                ],
+                [
+                    0.8888888888888888,
+                    "#fdca26"
+                ],
+                [
+                    1.0,
+                    "#f0f921"
+                ]
+            ],
+            "sequentialminus": [
+                [
+                    0.0,
+                    "#0d0887"
+                ],
+                [
+                    0.1111111111111111,
+                    "#46039f"
+                ],
+                [
+                    0.2222222222222222,
+                    "#7201a8"
+                ],
+                [
+                    0.3333333333333333,
+                    "#9c179e"
+                ],
+                [
+                    0.4444444444444444,
+                    "#bd3786"
+                ],
+                [
+                    0.5555555555555556,
+                    "#d8576b"
+                ],
+                [
+                    0.6666666666666666,
+                    "#ed7953"
+                ],
+                [
+                    0.7777777777777778,
+                    "#fb9f3a"
+                ],
+                [
+                    0.8888888888888888,
+                    "#fdca26"
+                ],
+                [
+                    1.0,
+                    "#f0f921"
+                ]
+            ]
+        },
+        "colorway": [
+            "#254495",
+            "#c13246",
+            "#48277c",
+            "#e4003a",
+            "#ef7d00",
+            "#822661",
+            "#ffed00",
+            "#00aaff",
+            "#9b30d9",
+            "#af005f",
+            "#5f00af",
+            "#af87ff"
+        ],
+        "font": {
+            "color": "#2a3f5f"
+        },
+        "geo": {
+            "bgcolor": "white",
+            "lakecolor": "white",
+            "landcolor": "white",
+            "showlakes": true,
+            "showland": true,
+            "subunitcolor": "#C8D4E3"
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "hovermode": "x",
+        "mapbox": {
+            "style": "light"
+        },
+        "paper_bgcolor": "white",
+        "plot_bgcolor": "white",
+        "polar": {
+            "angularaxis": {
+                "gridcolor": "#EBF0F8",
+                "linecolor": "#EBF0F8",
+                "ticks": ""
+            },
+            "bgcolor": "white",
+            "radialaxis": {
+                "gridcolor": "#EBF0F8",
+                "linecolor": "#EBF0F8",
+                "ticks": ""
+            }
+        },
+        "scene": {
+            "xaxis": {
+                "backgroundcolor": "white",
+                "gridcolor": "#DFE8F3",
+                "gridwidth": 2,
+                "linecolor": "#EBF0F8",
+                "showbackground": true,
+                "ticks": "",
+                "zerolinecolor": "#EBF0F8"
+            },
+            "yaxis": {
+                "backgroundcolor": "white",
+                "gridcolor": "#DFE8F3",
+                "gridwidth": 2,
+                "linecolor": "#EBF0F8",
+                "showbackground": true,
+                "ticks": "",
+                "zerolinecolor": "#EBF0F8"
+            },
+            "zaxis": {
+                "backgroundcolor": "white",
+                "gridcolor": "#DFE8F3",
+                "gridwidth": 2,
+                "linecolor": "#EBF0F8",
+                "showbackground": true,
+                "ticks": "",
+                "zerolinecolor": "#EBF0F8"
+            }
+        },
+        "shapedefaults": {
+            "line": {
+                "color": "#2a3f5f"
+            }
+        },
+        "ternary": {
+            "aaxis": {
+                "gridcolor": "#DFE8F3",
+                "linecolor": "#A2B1C6",
+                "ticks": ""
+            },
+            "baxis": {
+                "gridcolor": "#DFE8F3",
+                "linecolor": "#A2B1C6",
+                "ticks": ""
+            },
+            "bgcolor": "white",
+            "caxis": {
+                "gridcolor": "#DFE8F3",
+                "linecolor": "#A2B1C6",
+                "ticks": ""
+            }
+        },
+        "title": {
+            "x": 0.05
+        },
+        "xaxis": {
+            "automargin": true,
+            "ticks": "",
+            "zerolinewidth": 2,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 15
+            },
+            "mirror": true,
+            "zeroline": false
+        },
+        "yaxis": {
+            "automargin": true,
+            "ticks": "",
+            "tickfont": {
+                "size": 15
+            },
+            "zerolinewidth": 2,
+            "fixedrange": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "mirror": true,
+            "zeroline": false
+        },
+        "dragmode": "pan",
+        "legend": {
+            "bgcolor": "rgba(0, 0, 0, 0)",
+            "x": 1.1,
+            "xanchor": "left",
+            "y": 0.99,
+            "yanchor": "top"
+        },
+        "legend2": {
+            "bgcolor": "rgba(0, 0, 0, 0)"
+        },
+        "legend3": {
+            "bgcolor": "rgba(0, 0, 0, 0)"
+        },
+        "legend4": {
+            "bgcolor": "rgba(0, 0, 0, 0)"
+        },
+        "legend5": {
+            "bgcolor": "rgba(0, 0, 0, 0)"
+        }
+    }
+}

cli/openbb_cli/assets/styles/default/light.richstyle.json

@@ -0,0 +1,9 @@
+{
+    "info": "rgb(224,131,48)",
+    "cmds": "rgb(70,156,222)",
+    "param": "rgb(247,206,70)",
+    "menu": "rgb(50,115,185)",
+    "src": "rgb(216,90,64)",
+    "unvl": "grey30",
+    "help": "#FAC900"
+}

cli/openbb_cli/assets/styles/default/tables.pltstyle.json

@@ -0,0 +1,102 @@
+{
+    "data": {
+        "candlestick": [
+            {
+                "decreasing": {
+                    "fillcolor": "#e4003a",
+                    "line": {
+                        "color": "#e4003a"
+                    }
+                },
+                "increasing": {
+                    "fillcolor": "#00ACFF",
+                    "line": {
+                        "color": "#00ACFF"
+                    }
+                },
+                "type": "candlestick"
+            }
+        ]
+    },
+    "layout": {
+        "annotationdefaults": {
+            "showarrow": false
+        },
+        "autotypenumbers": "strict",
+        "colorway": [
+            "#ffed00",
+            "#ef7d00",
+            "#e4003a",
+            "#c13246",
+            "#822661",
+            "#48277c",
+            "#005ca9",
+            "#00aaff",
+            "#9b30d9",
+            "#af005f",
+            "#5f00af",
+            "#af87ff"
+        ],
+        "dragmode": "pan",
+        "font": {
+            "family": "Fira Code",
+            "size": 18
+        },
+        "hoverlabel": {
+            "align": "left"
+        },
+        "mapbox": {
+            "style": "light"
+        },
+        "hovermode": "x",
+        "legend": {
+            "bgcolor": "rgba(0, 0, 0, 0)",
+            "x": 0.01,
+            "xanchor": "left",
+            "y": 0.99,
+            "yanchor": "top",
+            "font": {
+                "size": 15
+            }
+        },
+        "paper_bgcolor": "white",
+        "plot_bgcolor": "white",
+        "xaxis": {
+            "automargin": true,
+            "autorange": true,
+            "rangeslider": {
+                "visible": false
+            },
+            "showgrid": true,
+            "showline": true,
+            "tickfont": {
+                "size": 14
+            },
+            "zeroline": false,
+            "tick0": 1,
+            "title": {
+                "standoff": 20
+            },
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        },
+        "yaxis": {
+            "anchor": "x",
+            "automargin": true,
+            "fixedrange": false,
+            "zeroline": false,
+            "showgrid": true,
+            "showline": true,
+            "side": "right",
+            "tick0": 0.5,
+            "title": {
+                "standoff": 20
+            },
+            "gridcolor": "#283442",
+            "linecolor": "#F5EFF3",
+            "mirror": true,
+            "ticks": "outside"
+        }
+    }
+}

cli/openbb_cli/assets/styles/user/openbb.richstyle.json

@@ -0,0 +1,9 @@
+{
+    "info": "rgb(224,131,48)",
+    "cmds": "#2A7C6E",
+    "param": "rgb(247,206,70)",
+    "menu": "#427A2E",
+    "src": "rgb(216,90,64)",
+    "unvl": "grey30",
+    "help": "#FAC900"
+}

cli/openbb_cli/cli.py

@@ -0,0 +1,31 @@
+"""OpenBB Platform CLI entry point."""
+
+import sys
+
+from openbb_cli.utils.utils import change_logging_sub_app, reset_logging_sub_app
+
+
+def main():
+    """Use the main entry point for the OpenBB Platform CLI."""
+    print("Loading...\n")  # noqa: T201
+
+    # pylint: disable=import-outside-toplevel
+    from openbb_cli.config.setup import bootstrap
+    from openbb_cli.controllers.cli_controller import launch
+
+    bootstrap()
+
+    dev = "--dev" in sys.argv[1:]
+    debug = "--debug" in sys.argv[1:]
+
+    launch(dev, debug)
+
+
+if __name__ == "__main__":
+    initial_logging_sub_app = change_logging_sub_app()
+    try:
+        main()
+    except Exception:
+        pass
+    finally:
+        reset_logging_sub_app(initial_logging_sub_app)

cli/openbb_cli/config/__init__.py

@@ -0,0 +1 @@
+"""Core config init."""

cli/openbb_cli/config/completer.py

@@ -0,0 +1,427 @@
+"""Nested completer for completion of OpenBB hierarchical data structures."""
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Pattern,
+    Set,
+    Union,
+)
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import AnyFormattedText
+from prompt_toolkit.history import FileHistory
+
+NestedDict = Mapping[str, Union[Any, Set[str], None, Completer]]
+
+# pylint: disable=too-many-arguments,global-statement,too-many-branches,global-variable-not-assigned
+
+
+class WordCompleter(Completer):
+    """Simple autocompletion on a list of words.
+
+    :param words: List of words or callable that returns a list of words.
+    :param ignore_case: If True, case-insensitive completion.
+    :param meta_dict: Optional dict mapping words to their meta-text. (This
+        should map strings to strings or formatted text.)
+    :param WORD: When True, use WORD characters.
+    :param sentence: When True, don't complete by comparing the word before the
+        cursor, but by comparing all the text before the cursor. In this case,
+        the list of words is just a list of strings, where each string can
+        contain spaces. (Can not be used together with the WORD option.)
+    :param match_middle: When True, match not only the start, but also in the
+                         middle of the word.
+    :param pattern: Optional compiled regex for finding the word before
+        the cursor to complete. When given, use this regex pattern instead of
+        default one (see document._FIND_WORD_RE)
+    """
+
+    def __init__(
+        self,
+        words: Union[List[str], Callable[[], List[str]]],
+        ignore_case: bool = False,
+        display_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        meta_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        WORD: bool = True,
+        sentence: bool = False,
+        match_middle: bool = False,
+        pattern: Optional[Pattern[str]] = None,
+    ) -> None:
+        """Initialize the WordCompleter."""
+        assert not (WORD and sentence)  # noqa: S101
+
+        self.words = words
+        self.ignore_case = ignore_case
+        self.display_dict = display_dict or {}
+        self.meta_dict = meta_dict or {}
+        self.WORD = WORD
+        self.sentence = sentence
+        self.match_middle = match_middle
+        self.pattern = pattern
+
+    def get_completions(
+        self,
+        document: Document,
+        _complete_event: CompleteEvent,
+    ) -> Iterable[Completion]:
+        """Get completions."""
+        # Get list of words.
+        words = self.words
+        if callable(words):
+            words = words()
+
+        # Get word/text before cursor.
+        if self.sentence:
+            word_before_cursor = document.text_before_cursor
+        else:
+            word_before_cursor = document.get_word_before_cursor(
+                WORD=self.WORD, pattern=self.pattern
+            )
+            if (
+                "--" in document.text_before_cursor
+                and document.text_before_cursor.rfind(" --")
+                >= document.text_before_cursor.rfind(" -")
+            ):
+                word_before_cursor = f'--{document.text_before_cursor.split("--")[-1]}'
+            elif f"--{word_before_cursor}" == document.text_before_cursor:
+                word_before_cursor = document.text_before_cursor
+
+        if self.ignore_case:
+            word_before_cursor = word_before_cursor.lower()
+
+        def word_matches(word: str) -> bool:
+            """Set True when the word before the cursor matches."""
+            if self.ignore_case:
+                word = word.lower()
+
+            if self.match_middle:
+                return word_before_cursor in word
+            return word.startswith(word_before_cursor)
+
+        for a in words:
+            if word_matches(a):
+                display = self.display_dict.get(a, a)
+                display_meta = self.meta_dict.get(a, "")
+                yield Completion(
+                    text=a,
+                    start_position=-len(word_before_cursor),
+                    display=display,
+                    display_meta=display_meta,
+                )
+
+
+class NestedCompleter(Completer):
+    """Completer which wraps around several other completers, and calls any the
+    one that corresponds with the first word of the input.
+
+    By combining multiple `NestedCompleter` instances, we can achieve multiple
+    hierarchical levels of autocompletion. This is useful when `WordCompleter`
+    is not sufficient.
+
+    If you need multiple levels, check out the `from_nested_dict` classmethod.
+    """
+
+    complementary: List = list()
+
+    def __init__(
+        self, options: Dict[str, Optional[Completer]], ignore_case: bool = True
+    ) -> None:
+        """Initialize the NestedCompleter."""
+        self.flags_processed: List = list()
+        self.original_options = options
+        self.options = options
+        self.ignore_case = ignore_case
+        self.complementary = list()
+
+    def __repr__(self) -> str:
+        """Return string representation of NestedCompleter."""
+        return f"NestedCompleter({self.options!r}, ignore_case={self.ignore_case!r})"
+
+    @classmethod
+    def from_nested_dict(cls, data: dict) -> "NestedCompleter":
+        """Create a `NestedCompleter`.
+
+        It starts from a nested dictionary data structure, like this:
+
+        .. code::
+
+            data = {
+                'show': {
+                    'version': None,
+                    'interfaces': None,
+                    'clock': None,
+                    'ip': {'interface': {'brief'}}
+                },
+                'exit': None
+                'enable': None
+            }
+
+        The value should be `None` if there is no further completion at some
+        point. If all values in the dictionary are None, it is also possible to
+        use a set instead.
+
+        Values in this data structure can be a completers as well.
+        """
+        options: Dict[str, Any] = {}
+        for key, value in data.items():
+            if isinstance(value, Completer):
+                options[key] = value
+            elif isinstance(value, dict):
+                options[key] = cls.from_nested_dict(value)
+            elif isinstance(value, set):
+                options[key] = cls.from_nested_dict({item: None for item in value})
+            elif isinstance(key, str) and isinstance(value, str):
+                options[key] = options[value]
+            else:
+                assert value is None  # noqa: S101
+                options[key] = None
+
+        for items in cls.complementary:
+            if items[0] in options:
+                options[items[1]] = options[items[0]]
+            elif items[1] in options:
+                options[items[0]] = options[items[1]]
+
+        return cls(options)
+
+    def get_completions(  # noqa: PLR0912
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        """Get completions."""
+        # Split document.
+        cmd = ""
+        text = document.text_before_cursor.lstrip()
+        if " " in text:
+            cmd = text.split(" ")[0]
+        if "-" in text:
+            if text.rfind("--") == -1 or text.rfind("-") - 1 > text.rfind("--"):
+                unprocessed_text = "-" + text.split("-")[-1]
+            else:
+                unprocessed_text = "--" + text.split("--")[-1]
+        else:
+            unprocessed_text = text
+        stripped_len = len(document.text_before_cursor) - len(text)
+
+        # Check if there are multiple flags for the same command
+        if self.complementary:
+            for same_flags in self.complementary:
+                if (
+                    same_flags[0] in self.flags_processed
+                    and same_flags[1] not in self.flags_processed
+                ) or (
+                    same_flags[1] in self.flags_processed
+                    and same_flags[0] not in self.flags_processed
+                ):
+                    if same_flags[0] in self.flags_processed:
+                        self.flags_processed.append(same_flags[1])
+                    elif same_flags[1] in self.flags_processed:
+                        self.flags_processed.append(same_flags[0])
+
+                    if cmd:
+                        self.options = {
+                            k: self.original_options.get(cmd).options[k]  # type: ignore
+                            for k in self.original_options.get(cmd).options  # type: ignore
+                            if k not in self.flags_processed
+                        }
+                    else:
+                        self.options = {
+                            k: self.original_options[k]
+                            for k in self.original_options
+                            if k not in self.flags_processed
+                        }
+
+        # If there is a space, check for the first term, and use a subcompleter.
+        if " " in unprocessed_text:
+            first_term = unprocessed_text.split()[0]
+
+            # user is updating one of the values
+            if unprocessed_text[-1] != " ":
+                self.flags_processed = [
+                    flag for flag in self.flags_processed if flag != first_term
+                ]
+
+                if self.complementary:
+                    for same_flags in self.complementary:
+                        if (
+                            same_flags[0] in self.flags_processed
+                            and same_flags[1] not in self.flags_processed
+                        ) or (
+                            same_flags[1] in self.flags_processed
+                            and same_flags[0] not in self.flags_processed
+                        ):
+                            if same_flags[0] in self.flags_processed:
+                                self.flags_processed.remove(same_flags[0])
+                            elif same_flags[1] in self.flags_processed:
+                                self.flags_processed.remove(same_flags[1])
+
+                if cmd and self.original_options.get(cmd):
+                    self.options = self.original_options
+                else:
+                    self.options = {
+                        k: self.original_options[k]
+                        for k in self.original_options
+                        if k not in self.flags_processed
+                    }
+
+            if "-" not in text:
+                completer = self.options.get(first_term)
+            elif cmd in self.options and self.options.get(cmd):
+                completer = self.options.get(cmd).options.get(first_term)  # type: ignore
+            else:
+                completer = self.options.get(first_term)
+
+            # If we have a sub completer, use this for the completions.
+            if completer is not None:
+                remaining_text = unprocessed_text[len(first_term) :].lstrip()
+                move_cursor = len(text) - len(remaining_text) + stripped_len
+
+                new_document = Document(
+                    remaining_text,
+                    cursor_position=document.cursor_position - move_cursor,
+                )
+
+                # Provides auto-completion but if user doesn't take it still keep going
+                if " " in new_document.text:
+                    if (
+                        new_document.text in [f"{opt} " for opt in self.options]
+                        or unprocessed_text[-1] == " "
+                    ):
+                        self.flags_processed.append(first_term)
+                        if cmd:
+                            self.options = {
+                                k: self.original_options.get(cmd).options[k]  # type: ignore
+                                for k in self.original_options.get(cmd).options  # type: ignore
+                                if k not in self.flags_processed
+                            }
+                        else:
+                            self.options = {
+                                k: self.original_options[k]
+                                for k in self.original_options
+                                if k not in self.flags_processed
+                            }
+
+                # In case the users inputs a single boolean flag
+                elif not completer.options:  # type: ignore
+                    self.flags_processed.append(first_term)
+
+                    if self.complementary:
+                        for same_flags in self.complementary:
+                            if (
+                                same_flags[0] in self.flags_processed
+                                and same_flags[1] not in self.flags_processed
+                            ) or (
+                                same_flags[1] in self.flags_processed
+                                and same_flags[0] not in self.flags_processed
+                            ):
+                                if same_flags[0] in self.flags_processed:
+                                    self.flags_processed.append(same_flags[1])
+                                elif same_flags[1] in self.flags_processed:
+                                    self.flags_processed.append(same_flags[0])
+
+                    if cmd:
+                        self.options = {
+                            k: self.original_options.get(cmd).options[k]  # type: ignore
+                            for k in self.original_options.get(cmd).options  # type: ignore
+                            if k not in self.flags_processed
+                        }
+                    else:
+                        self.options = {
+                            k: self.original_options[k]
+                            for k in self.original_options
+                            if k not in self.flags_processed
+                        }
+
+                else:
+                    # This is a NestedCompleter
+                    yield from completer.get_completions(new_document, complete_event)
+
+        # No space in the input: behave exactly like `WordCompleter`.
+        else:
+            # check if the prompt has been updated in the meantime
+            if " " in text or "-" in text:
+                actual_flags_processed = [
+                    flag for flag in self.flags_processed if flag in text
+                ]
+
+                if self.complementary:
+                    for same_flags in self.complementary:
+                        if (
+                            same_flags[0] in actual_flags_processed
+                            and same_flags[1] not in actual_flags_processed
+                        ) or (
+                            same_flags[1] in actual_flags_processed
+                            and same_flags[0] not in actual_flags_processed
+                        ):
+                            if same_flags[0] in actual_flags_processed:
+                                actual_flags_processed.append(same_flags[1])
+                            elif same_flags[1] in actual_flags_processed:
+                                actual_flags_processed.append(same_flags[0])
+
+                if len(actual_flags_processed) < len(self.flags_processed):
+                    self.flags_processed = actual_flags_processed
+                    if cmd:
+                        self.options = {
+                            k: self.original_options.get(cmd).options[k]  # type: ignore
+                            for k in self.original_options.get(cmd).options  # type: ignore
+                            if k not in self.flags_processed
+                        }
+                    else:
+                        self.options = {
+                            k: self.original_options[k]
+                            for k in self.original_options
+                            if k not in self.flags_processed
+                        }
+
+            command = self.options.get(cmd)
+            options = command.options if command else {}  # type: ignore
+            command_options = [f"{cmd} {opt}" for opt in options]
+            text_list = [text in val for val in command_options]
+            if cmd and cmd in self.options and text_list:
+                completer = WordCompleter(
+                    list(self.options.get(cmd).options.keys()),  # type: ignore
+                    ignore_case=self.ignore_case,
+                )
+            elif bool([val for val in self.options if text in val]):
+                completer = WordCompleter(
+                    list(self.options.keys()), ignore_case=self.ignore_case
+                )
+            else:
+                # The user has delete part of the first command and we need to reset options
+                if bool([val for val in self.original_options if text in val]):
+                    self.options = self.original_options
+                    self.flags_processed = list()
+                completer = WordCompleter(
+                    list(self.options.keys()), ignore_case=self.ignore_case
+                )
+
+            # This is a WordCompleter
+            yield from completer.get_completions(document, complete_event)
+
+
+class CustomFileHistory(FileHistory):
+    """Filtered file history."""
+
+    def sanitize_input(self, string: str) -> str:
+        """Sanitize sensitive information from the input string by parsing arguments."""
+        keywords = ["--password", "--email", "--pat"]
+        string_list = string.split(" ")
+
+        for kw in keywords:
+            if kw in string_list:
+                index = string_list.index(kw)
+                if len(string_list) > index + 1:
+                    string_list[index + 1] = "********"
+
+        result = " ".join(string_list)
+        return result
+
+    def store_string(self, string: str) -> None:
+        """Store string in history."""
+        string = self.sanitize_input(string)
+        super().store_string(string)

cli/openbb_cli/config/console.py

@@ -0,0 +1,93 @@
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
+
+from rich import panel
+from rich.console import (
+    Console as RichConsole,
+    Theme,
+)
+from rich.text import Text
+
+from openbb_cli.config.menu_text import RICH_TAGS
+
+if TYPE_CHECKING:
+    from openbb_cli.models.settings import Settings
+
+
+class Console:
+    """Create a rich console to wrap the console print with a Panel."""
+
+    def __init__(
+        self,
+        settings: "Settings",
+        style: Optional[Dict[str, Any]] = None,
+    ):
+        """Initialize the ConsoleAndPanel class."""
+        self._console = RichConsole(
+            theme=Theme(style),
+            highlight=False,
+            soft_wrap=True,
+        )
+        self._settings = settings
+        self.menu_text = ""
+        self.menu_path = ""
+
+    @staticmethod
+    def _filter_rich_tags(text):
+        """Filter out rich tags from text."""
+        for val in RICH_TAGS:
+            text = text.replace(val, "")
+
+        return text
+
+    @staticmethod
+    def _blend_text(
+        message: str, color1: Tuple[int, int, int], color2: Tuple[int, int, int]
+    ) -> Text:
+        """Blend text from one color to another."""
+        text = Text(message)
+        r1, g1, b1 = color1
+        r2, g2, b2 = color2
+        dr = r2 - r1
+        dg = g2 - g1
+        db = b2 - b1
+        size = len(text) + 5
+        for index in range(size):
+            blend = index / size
+            color = f"#{int(r1 + dr * blend):02X}{int(g1 + dg * blend):02X}{int(b1 + db * blend):02X}"
+            text.stylize(color, index, index + 1)
+        return text
+
+    def print(self, *args, **kwargs):
+        """Print the text to the console."""
+        if kwargs and "text" in list(kwargs) and "menu" in list(kwargs):
+            if not self._settings.TEST_MODE:
+                if self._settings.ENABLE_RICH_PANEL:
+                    if self._settings.SHOW_VERSION:
+                        version = self._settings.VERSION
+                        version = f"[param]OpenBB Platform CLI v{version}[/param] (https://openbb.co)"
+                    else:
+                        version = (
+                            "[param]OpenBB Platform CLI[/param] (https://openbb.co)"
+                        )
+                    self._console.print(
+                        panel.Panel(
+                            "\n" + kwargs["text"],
+                            title=kwargs["menu"],
+                            subtitle_align="right",
+                            subtitle=version,
+                        )
+                    )
+
+                else:
+                    self._console.print(kwargs["text"])
+            else:
+                print(self._filter_rich_tags(kwargs["text"]))  # noqa: T201
+        elif not self._settings.TEST_MODE:
+            self._console.print(*args, **kwargs)
+        else:
+            print(*args, **kwargs)  # noqa: T201
+
+    def input(self, *args, **kwargs):
+        """Get input from the user."""
+        self.print(*args, **kwargs, end="")
+        return input()

cli/openbb_cli/config/constants.py

@@ -0,0 +1,80 @@
+"""Constants module."""
+
+from pathlib import Path
+
+# Paths
+HOME_DIRECTORY = Path.home()
+REPOSITORY_DIRECTORY = Path(__file__).parent.parent.parent.parent
+SRC_DIRECTORY = Path(__file__).parent.parent
+SETTINGS_DIRECTORY = HOME_DIRECTORY / ".openbb_platform"
+ASSETS_DIRECTORY = SRC_DIRECTORY / "assets"
+STYLES_DIRECTORY = ASSETS_DIRECTORY / "styles"
+ENV_FILE_SETTINGS = SETTINGS_DIRECTORY / ".cli.env"
+HIST_FILE_PROMPT = SETTINGS_DIRECTORY / ".cli.his"
+
+
+DEFAULT_ROUTINES_URL = "https://openbb-cms.directus.app/items/Routines"
+TIMEOUT = 30
+CONNECTION_ERROR_MSG = "[red]Connection error.[/red]"
+CONNECTION_TIMEOUT_MSG = "[red]Connection timeout.[/red]"
+SCRIPT_TAGS = [
+    "stocks",
+    "crypto",
+    "etf",
+    "economy",
+    "forex",
+    "fixed income",
+    "alternative",
+    "funds",
+    "bonds",
+    "macro",
+    "mutual funds",
+    "equities",
+    "options",
+    "dark pool",
+    "shorts",
+    "insider",
+    "behavioral analysis",
+    "fundamental analysis",
+    "technical analysis",
+    "quantitative analysis",
+    "forecasting",
+    "government",
+    "comparison",
+    "nft",
+    "on chain",
+    "off chain",
+    "screener",
+    "report",
+    "overview",
+    "rates",
+    "econometrics",
+    "portfolio",
+    "real estate",
+]
+AVAILABLE_FLAIRS = {
+    ":openbb": "(🦋)",
+    ":bug": "(🐛)",
+    ":rocket": "(🚀)",
+    ":diamond": "(💎)",
+    ":stars": "(✨)",
+    ":baseball": "(⚾)",
+    ":boat": "(⛵)",
+    ":phone": "(☎)",
+    ":mercury": "(☿)",
+    ":hidden": "",
+    ":sun": "(☼)",
+    ":moon": "(🌕)",
+    ":nuke": "(☢)",
+    ":hazard": "(☣)",
+    ":tunder": "(☈)",
+    ":king": "(♔)",
+    ":queen": "(♕)",
+    ":knight": "(♘)",
+    ":recycle": "(♻)",
+    ":scales": "(⚖)",
+    ":ball": "(⚽)",
+    ":golf": "(⛳)",
+    ":peace": "(☮)",
+    ":yy": "(☯)",
+}

cli/openbb_cli/config/menu_text.py

@@ -0,0 +1,165 @@
+"""Rich Module."""
+
+__docformat__ = "numpy"
+
+from typing import Dict, List
+
+from openbb import obb
+
+# https://rich.readthedocs.io/en/stable/appendix/colors.html#appendix-colors
+# https://rich.readthedocs.io/en/latest/highlighting.html#custom-highlighters
+
+
+RICH_TAGS = [
+    "[menu]",
+    "[/menu]",
+    "[cmds]",
+    "[/cmds]",
+    "[info]",
+    "[/info]",
+    "[param]",
+    "[/param]",
+    "[src]",
+    "[/src]",
+    "[help]",
+    "[/help]",
+]
+
+
+class MenuText:
+    """Create menu text with rich colors to be displayed by CLI."""
+
+    CMD_NAME_LENGTH = 23
+    CMD_DESCRIPTION_LENGTH = 65
+    CMD_PROVIDERS_LENGTH = 23
+    SECTION_SPACING = 4
+
+    def __init__(self, path: str = ""):
+        """Initialize menu help."""
+        self.menu_text = ""
+        self.menu_path = path
+        self.warnings: List[Dict[str, str]] = []
+
+    @staticmethod
+    def _get_providers(command_path: str) -> List:
+        """Return the preferred provider for the given command.
+
+        Parameters
+        ----------
+        command_path: str
+            The command to find the provider for. E.g. "/equity/price/historical
+
+        Returns
+        -------
+        List
+            The list of providers for the given command.
+        """
+        command_reference = obb.reference.get("paths", {}).get(command_path, {})  # type: ignore
+        if command_reference:
+            providers = list(command_reference["parameters"].keys())
+            return [provider for provider in providers if provider != "standard"]
+        return []
+
+    def _format_cmd_name(self, name: str) -> str:
+        """Truncate command name length if it is too long."""
+        if len(name) > self.CMD_NAME_LENGTH:
+            new_name = name[: self.CMD_NAME_LENGTH]
+
+            if "_" in name:
+                name_split = name.split("_")
+
+                new_name = (
+                    "_".join(name_split[:2]) if len(name_split) > 2 else name_split[0]
+                )
+
+                if len(new_name) > self.CMD_NAME_LENGTH:
+                    new_name = new_name[: self.CMD_NAME_LENGTH]
+
+            if new_name != name:
+                self.warnings.append(
+                    {
+                        "warning": "Command name too long",
+                        "actual command": f"`{name}`",
+                        "displayed command": f"`{new_name}`",
+                    }
+                )
+                name = new_name
+
+        return name
+
+    def _format_cmd_description(
+        self, name: str, description: str, trim: bool = True
+    ) -> str:
+        """Truncate command description length if it is too long."""
+        if not description or description == f"{self.menu_path}{name}":
+            description = ""
+        return (
+            description[: self.CMD_DESCRIPTION_LENGTH - 3] + "..."
+            if len(description) > self.CMD_DESCRIPTION_LENGTH and trim
+            else description
+        )
+
+    def add_raw(self, text: str, left_spacing: bool = False):
+        """Append raw text (without translation)."""
+        if left_spacing:
+            self.menu_text += f"{self.SECTION_SPACING * ' '}{text}\n"
+        else:
+            self.menu_text += text
+
+    def add_info(self, text: str):
+        """Append information text (after translation)."""
+        self.menu_text += f"[info]{text}:[/info]\n"
+
+    def add_cmd(self, name: str, description: str = "", disable: bool = False):
+        """Append command text (after translation)."""
+        formatted_name = self._format_cmd_name(name)
+        name_padding = (self.CMD_NAME_LENGTH - len(formatted_name)) * " "
+        providers = self._get_providers(f"{self.menu_path}{name}")
+        formatted_description = self._format_cmd_description(
+            formatted_name,
+            description,
+            bool(providers),
+        )
+        description_padding = (
+            self.CMD_DESCRIPTION_LENGTH - len(formatted_description)
+        ) * " "
+        spacing = self.SECTION_SPACING * " "
+        description_padding = (
+            self.CMD_DESCRIPTION_LENGTH - len(formatted_description)
+        ) * " "
+        cmd = f"{spacing}{formatted_name + name_padding}{spacing}{formatted_description+description_padding}"
+        cmd = f"[unvl]{cmd}[/unvl]" if disable else f"[cmds]{cmd}[/cmds]"
+
+        if providers:
+            cmd += rf"{spacing}[src]\[{', '.join(providers)}][/src]"
+
+        self.menu_text += cmd + "\n"
+
+    def add_menu(
+        self,
+        name: str,
+        description: str = "",
+        disable: bool = False,
+    ):
+        """Append menu text (after translation)."""
+        spacing = (self.CMD_NAME_LENGTH - len(name) + self.SECTION_SPACING) * " "
+
+        if not description or description == f"{self.menu_path}{name}":
+            description = ""
+
+        if len(description) > self.CMD_DESCRIPTION_LENGTH:
+            description = description[: self.CMD_DESCRIPTION_LENGTH - 3] + "..."
+
+        menu = f"{name}{spacing}{description}"
+        tag = "unvl" if disable else "menu"
+        self.menu_text += f"[{tag}]>   {menu}[/{tag}]\n"
+
+    def add_setting(self, name: str, status: bool = True, description: str = ""):
+        """Append menu text (after translation)."""
+        spacing = (self.CMD_NAME_LENGTH - len(name) + self.SECTION_SPACING) * " "
+        indentation = self.SECTION_SPACING * " "
+        color = "green" if status else "red"
+
+        self.menu_text += (
+            f"[{color}]{indentation}{name}{spacing}{description}[/{color}]\n"
+        )

cli/openbb_cli/config/setup.py

@@ -0,0 +1,11 @@
+"""Configuration for the CLI."""
+
+from pathlib import Path
+
+from openbb_cli.config.constants import ENV_FILE_SETTINGS, SETTINGS_DIRECTORY
+
+
+def bootstrap():
+    """Setup pre-launch configurations for the CLI."""
+    SETTINGS_DIRECTORY.mkdir(parents=True, exist_ok=True)
+    Path(ENV_FILE_SETTINGS).touch(exist_ok=True)

cli/openbb_cli/config/style.py

@@ -0,0 +1,108 @@
+"""Chart and style helpers for Plotly."""
+
+# pylint: disable=C0302,R0902,W3301
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+
+from openbb_cli.config.constants import STYLES_DIRECTORY
+
+console = Console()
+
+
+class Style:
+    """The class that helps with handling of style configurations.
+
+    It serves styles for 2 libraries. For `Plotly` this class serves absolute paths
+    to the .pltstyle files. For `Plotly` and `Rich` this class serves custom
+    styles as python dictionaries.
+    """
+
+    STYLES_REPO = STYLES_DIRECTORY
+
+    console_styles_available: Dict[str, Path] = {}
+    console_style: Dict[str, Any] = {}
+
+    line_color: str = ""
+    up_color: str = ""
+    down_color: str = ""
+    up_colorway: List[str] = []
+    down_colorway: List[str] = []
+    up_color_transparent: str = ""
+    down_color_transparent: str = ""
+
+    line_width: float = 1.5
+
+    def __init__(
+        self,
+        style: Optional[str] = "",
+        directory: Optional[Path] = None,
+    ):
+        """Initialize the class."""
+        self._load(directory)
+        self.apply(style, directory)
+
+    def apply(
+        self, style: Optional[str] = None, directory: Optional[Path] = None
+    ) -> None:
+        """Apply the style to the console."""
+        if style:
+            if style in self.console_styles_available:
+                json_path: Optional[Path] = self.console_styles_available[style]
+            else:
+                self._load(directory)
+                if style in self.console_styles_available:
+                    json_path = self.console_styles_available[style]
+                else:
+                    console.print(f"\nInvalid console style '{style}', using default.")
+                    json_path = self.console_styles_available.get("dark", None)
+
+            if json_path:
+                self.console_style = self._from_json(json_path)
+            else:
+                console.print("Error loading default.")
+
+    def _from_directory(self, folder: Optional[Path]) -> None:
+        """Load custom styles from folder.
+
+        Parses the styles/default and styles/user folders and loads style files.
+        To be recognized files need to follow a naming convention:
+        *.pltstyle        - plotly stylesheets
+        *.richstyle.json  - rich stylesheets
+
+        Parameters
+        ----------
+        folder : str
+            Path to the folder containing the stylesheets
+        """
+        if not folder or not folder.exists():
+            return
+
+        for attr, ext in zip(
+            ["console_styles_available"],
+            [".richstyle.json"],
+        ):
+            for file in folder.rglob(f"*{ext}"):
+                getattr(self, attr)[file.name.replace(ext, "")] = file
+
+    def _load(self, directory: Optional[Path] = None) -> None:
+        """Load custom styles from default and user folders."""
+        self._from_directory(self.STYLES_REPO)
+        self._from_directory(directory)
+
+    def _from_json(self, file: Path) -> Dict[str, Any]:
+        """Load style from json file."""
+        with open(file) as f:
+            json_style: dict = json.load(f)
+            for key, value in json_style.items():
+                json_style[key] = value.replace(
+                    " ", ""
+                )  # remove whitespaces so Rich can parse it
+            return json_style
+
+    @property
+    def available_styles(self) -> List[str]:
+        """Return available styles."""
+        return list(self.console_styles_available.keys())

cli/openbb_cli/controllers/base_controller.py

@@ -0,0 +1,1032 @@
+"""Base controller for the CLI."""
+
+import argparse
+import difflib
+import os
+import re
+import shlex
+from abc import ABCMeta, abstractmethod
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+import pandas as pd
+from openbb_cli.config.completer import NestedCompleter
+from openbb_cli.config.constants import SCRIPT_TAGS
+from openbb_cli.controllers.choices import build_controller_choice_map
+from openbb_cli.controllers.hub_service import upload_routine
+from openbb_cli.controllers.utils import (
+    check_file_type_saved,
+    check_positive,
+    get_flair_and_username,
+    handle_obbject_display,
+    parse_and_split_input,
+    parse_unknown_args_to_dict,
+    print_guest_block_msg,
+    print_rich_table,
+    remove_file,
+    system_clear,
+    validate_register_key,
+)
+from openbb_cli.session import Session
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.styles import Style
+
+# pylint: disable=C0301,C0302,R0902,global-statement,too-many-boolean-expressions
+# pylint: disable=R0912
+
+controllers: Dict[str, Any] = {}
+session = Session()
+
+
+# TODO: We should try to avoid these global variables
+RECORD_SESSION = False
+RECORD_SESSION_LOCAL_ONLY = False
+SESSION_RECORDED = list()
+SESSION_RECORDED_NAME = ""
+SESSION_RECORDED_DESCRIPTION = ""
+SESSION_RECORDED_TAGS = ""
+SESSION_RECORDED_PUBLIC = False
+
+
+class BaseController(metaclass=ABCMeta):
+    """Base class for a cli controller."""
+
+    CHOICES_COMMON = [
+        "cls",
+        "home",
+        "h",
+        "?",
+        "help",
+        "q",
+        "quit",
+        "..",
+        "e",
+        "exit",
+        "r",
+        "reset",
+        "stop",
+        "whoami",
+        "results",
+    ]
+
+    CHOICES_COMMANDS: List[str] = []
+    CHOICES_MENUS: List[str] = []
+    NEWS_CHOICES: dict = {}
+    COMMAND_SEPARATOR = "/"
+    KEYS_MENU = "keys" + COMMAND_SEPARATOR
+    PATH: str = ""
+    FILE_PATH: str = ""
+    CHOICES_GENERATION = False
+
+    @property
+    def choices_default(self):
+        """Return the default choices."""
+        choices = (
+            build_controller_choice_map(controller=self)
+            if self.CHOICES_GENERATION
+            else {}
+        )
+
+        return choices
+
+    def __init__(self, queue: Optional[List[str]] = None) -> None:
+        """Create the base class for any controller in the codebase.
+
+        Used to simplify the creation of menus.
+
+        queue: List[str]
+            The current queue of jobs to process separated by "/"
+            E.g. /stocks/load gme/dps/sidtc/../exit
+        """
+        self.check_path()
+        self.path = [x for x in self.PATH.split("/") if x != ""]
+        self.queue = (
+            self.parse_input(an_input="/".join(queue))
+            if (queue and self.PATH != "/")
+            else list()
+        )
+
+        controller_choices = self.CHOICES_COMMANDS + self.CHOICES_MENUS
+        if controller_choices:
+            self.controller_choices = controller_choices + self.CHOICES_COMMON
+        else:
+            self.controller_choices = self.CHOICES_COMMON
+
+        self.completer: Union[None, NestedCompleter] = None
+
+        self.parser = argparse.ArgumentParser(
+            add_help=False,
+            prog=self.path[-1] if self.PATH != "/" else "cli",
+        )
+        self.parser.exit_on_error = False  # type: ignore
+        self.parser.add_argument("cmd", choices=self.controller_choices)
+
+    def update_completer(self, choices) -> None:
+        """Update the completer with new choices."""
+        if session.prompt_session and session.settings.USE_PROMPT_TOOLKIT:
+            self.completer = NestedCompleter.from_nested_dict(choices)
+
+    def check_path(self) -> None:
+        """Check if command path is valid."""
+        path = self.PATH
+        if path[0] != "/":
+            raise ValueError("Path must begin with a '/' character.")
+        if path[-1] != "/":
+            raise ValueError("Path must end with a '/' character.")
+        if not re.match("^[a-z/]*$", path):
+            raise ValueError(
+                "Path must only contain lowercase letters and '/' characters."
+            )
+
+    def load_class(self, class_ins, *args, **kwargs):
+        """Check for an existing instance of the controller before creating a new one."""
+        self.save_class()
+        arguments = len(args) + len(kwargs)
+
+        if class_ins.PATH in controllers and arguments == 1:
+            old_class = controllers[class_ins.PATH]
+            old_class.queue = self.queue
+            return old_class.menu()
+        return class_ins(*args, **kwargs).menu()
+
+    def save_class(self) -> None:
+        """Save the current instance of the class to be loaded later."""
+        controllers[self.PATH] = self
+
+    def custom_reset(self) -> List[str]:
+        """Implement custom reset.
+
+        This will be replaced by any children with custom_reset functions.
+        """
+        return []
+
+    @abstractmethod
+    def print_help(self) -> None:
+        """Print help placeholder."""
+        raise NotImplementedError("Must override print_help.")
+
+    def parse_input(self, an_input: str) -> list:
+        """Parse controller input.
+
+        Splits the command chain from user input into a list of individual commands
+        while respecting the forward slash in the command arguments.
+
+        In the default scenario only unix-like paths are handles by the parser.
+        Override this function in the controller classes that inherit from this one to
+        resolve edge cases specific to command arguments on those controllers.
+
+        When handling edge cases add additional regular expressions to the list.
+
+        Parameters
+        ----------
+        an_input : str
+            User input string
+
+        Returns
+        ----------
+        list
+            Command queue as list
+        """
+        custom_filters: list = []
+        commands = parse_and_split_input(
+            an_input=an_input, custom_filters=custom_filters
+        )
+        return commands
+
+    def switch(self, an_input: str) -> List[str]:
+        """Process and dispatch input.
+
+        Returns
+        ----------
+        List[str]
+            list of commands in the queue to execute
+        """
+        actions = self.parse_input(an_input)
+
+        if an_input and an_input != "reset":
+            session.console.print()
+
+        # Empty command
+        if len(actions) == 0:
+            pass
+
+        # Navigation slash is being used first split commands
+        elif len(actions) > 1:
+            # Absolute path is specified
+            if not actions[0]:
+                actions[0] = "home"
+
+            # Add all instructions to the queue
+            for cmd in actions[::-1]:
+                if cmd:
+                    self.queue.insert(0, cmd)
+
+        # Single command fed, process
+        else:
+            try:
+                (known_args, other_args) = self.parser.parse_known_args(
+                    shlex.split(an_input)
+                )
+            except Exception as exc:
+                raise SystemExit from exc
+
+            if RECORD_SESSION:
+                SESSION_RECORDED.append(an_input)
+
+            # Redirect commands to their correct functions
+            if known_args.cmd:
+                if known_args.cmd in ("..", "q"):
+                    known_args.cmd = "quit"
+                elif known_args.cmd in ("e"):
+                    known_args.cmd = "exit"
+                elif known_args.cmd in ("?", "h"):
+                    known_args.cmd = "help"
+                elif known_args.cmd == "r":
+                    known_args.cmd = "reset"
+
+            getattr(
+                self,
+                "call_" + known_args.cmd,
+                lambda _: "Command not recognized!",
+            )(other_args)
+
+        if (
+            an_input
+            and an_input != "reset"
+            and (
+                not self.queue or (self.queue and self.queue[0] not in ("quit", "help"))
+            )
+        ):
+            session.console.print()
+
+        return self.queue
+
+    def call_cls(self, _) -> None:
+        """Process cls command."""
+        system_clear()
+
+    def call_home(self, _) -> None:
+        """Process home command."""
+        self.save_class()
+        if self.PATH.count("/") == 1 and session.settings.ENABLE_EXIT_AUTO_HELP:
+            self.print_help()
+        for _ in range(self.PATH.count("/") - 1):
+            self.queue.insert(0, "quit")
+
+    def call_help(self, _) -> None:
+        """Process help command."""
+        self.print_help()
+
+    def call_quit(self, _) -> None:
+        """Process quit menu command."""
+        self.save_class()
+        self.queue.insert(0, "quit")
+
+    def call_exit(self, _) -> None:
+        # Not sure how to handle controller loading here
+        """Process exit cli command."""
+        self.save_class()
+        for _ in range(self.PATH.count("/")):
+            self.queue.insert(0, "quit")
+
+        if not session.is_local():
+            remove_file(
+                Path(session.user.preferences.export_directory, "routines", "hub")
+            )
+
+    def call_reset(self, _) -> None:
+        """Process reset command.
+
+        If you would like to have customization in the reset process define a method
+        `custom_reset` in the child class.
+        """
+        self.save_class()
+        if self.PATH != "/":
+            if self.custom_reset():
+                self.queue = self.custom_reset() + self.queue
+            else:
+                for val in self.path[::-1]:
+                    self.queue.insert(0, val)
+            self.queue.insert(0, "reset")
+            for _ in range(len(self.path)):
+                self.queue.insert(0, "quit")
+
+    def call_record(self, other_args) -> None:
+        """Process record command."""
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prog="record",
+            description="Start recording session into .openbb routine file",
+        )
+        parser.add_argument(
+            "-n",
+            "--name",
+            action="store",
+            dest="name",
+            type=str,
+            default="",
+            help="Routine title name to be saved - only use characters, digits and whitespaces.",
+            nargs="+",
+        )
+        parser.add_argument(
+            "-d",
+            "--description",
+            type=str,
+            dest="description",
+            help="The description of the routine",
+            default=f"Routine recorded at {datetime.now().strftime('%H:%M')} from the OpenBB Platform CLI",
+            nargs="+",
+        )
+        parser.add_argument(
+            "--tag1",
+            type=str,
+            dest="tag1",
+            help=f"The tag associated with the routine. Select from: {', '.join(SCRIPT_TAGS)}",
+            default="",
+            nargs="+",
+        )
+        parser.add_argument(
+            "--tag2",
+            type=str,
+            dest="tag2",
+            help=f"The tag associated with the routine. Select from: {', '.join(SCRIPT_TAGS)}",
+            default="",
+            nargs="+",
+        )
+        parser.add_argument(
+            "--tag3",
+            type=str,
+            dest="tag3",
+            help=f"The tag associated with the routine. Select from: {', '.join(SCRIPT_TAGS)}",
+            default="",
+            nargs="+",
+        )
+        parser.add_argument(
+            "-p",
+            "--public",
+            dest="public",
+            action="store_true",
+            help="Whether the routine should be public or not",
+            default=False,
+        )
+
+        if other_args and "-" not in other_args[0][0]:
+            other_args.insert(0, "-n")
+
+        ns_parser, _ = self.parse_simple_args(parser, other_args)
+
+        if ns_parser:
+            if not ns_parser.name:
+                session.console.print(
+                    "[red]Set a routine title by using the '-n' flag. E.g. 'record -n Morning routine'[/red]"
+                )
+                return
+
+            tag1 = (
+                " ".join(ns_parser.tag1)
+                if isinstance(ns_parser.tag1, list)
+                else ns_parser.tag1
+            )
+            if tag1 and tag1 not in SCRIPT_TAGS:
+                session.console.print(
+                    f"[red]The parameter 'tag1' needs to be one of the following {', '.join(SCRIPT_TAGS)}[/red]"
+                )
+                return
+
+            tag2 = (
+                " ".join(ns_parser.tag2)
+                if isinstance(ns_parser.tag2, list)
+                else ns_parser.tag2
+            )
+            if tag2 and tag2 not in SCRIPT_TAGS:
+                session.console.print(
+                    f"[red]The parameter 'tag2' needs to be one of the following {', '.join(SCRIPT_TAGS)}[/red]"
+                )
+                return
+
+            tag3 = (
+                " ".join(ns_parser.tag3)
+                if isinstance(ns_parser.tag3, list)
+                else ns_parser.tag3
+            )
+            if tag3 and tag3 not in SCRIPT_TAGS:
+                session.console.print(
+                    f"[red]The parameter 'tag3' needs to be one of the following {', '.join(SCRIPT_TAGS)}[/red]"
+                )
+                return
+
+            if session.is_local():
+                session.console.print(
+                    "[red]Recording session to the OpenBB Hub is not supported in guest mode.[/red]"
+                )
+                session.console.print(
+                    "\n[yellow]Visit the OpenBB Hub to register: http://my.openbb.co[/yellow]"
+                )
+                session.console.print(
+                    "\n[yellow]Your routine will be saved locally.[/yellow]\n"
+                )
+
+            # Check if title has a valid format
+            title = " ".join(ns_parser.name) if ns_parser.name else ""
+            pattern = re.compile(r"^[a-zA-Z0-9\s]+$")
+            if not pattern.match(title):
+                session.console.print(
+                    f"[red]Title '{title}' has invalid format. Please use only digits, characters and whitespaces.[/]"
+                )
+                return
+
+            global RECORD_SESSION  # noqa: PLW0603
+            global RECORD_SESSION_LOCAL_ONLY  # noqa: PLW0603
+            global SESSION_RECORDED_NAME  # noqa: PLW0603
+            global SESSION_RECORDED_DESCRIPTION  # noqa: PLW0603
+            global SESSION_RECORDED_TAGS  # noqa: PLW0603
+            global SESSION_RECORDED_PUBLIC  # noqa: PLW0603
+
+            RECORD_SESSION_LOCAL_ONLY = session.is_local()
+            RECORD_SESSION = True
+            SESSION_RECORDED_NAME = title
+            SESSION_RECORDED_DESCRIPTION = (
+                " ".join(ns_parser.description)
+                if isinstance(ns_parser.description, list)
+                else ns_parser.description
+            )
+            SESSION_RECORDED_TAGS = tag1 if tag1 else ""
+            SESSION_RECORDED_TAGS += "," + tag2 if tag2 else ""
+            SESSION_RECORDED_TAGS += "," + tag3 if tag3 else ""
+
+            SESSION_RECORDED_PUBLIC = ns_parser.public
+
+            session.console.print(
+                f"[green]The routine '{title}' is successfully being recorded.[/green]"
+            )
+            session.console.print(
+                "\n[yellow]Remember to run 'stop' command when you are done!\n[/yellow]"
+            )
+
+    def call_stop(self, other_args) -> None:
+        """Process stop command."""
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prog="stop",
+            description="Stop recording session into .openbb routine file",
+        )
+        # This is only for auto-completion purposes
+        _, _ = self.parse_simple_args(parser, other_args)
+
+        if "-h" not in other_args and "--help" not in other_args:
+            global RECORD_SESSION  # noqa: PLW0603
+            global SESSION_RECORDED  # noqa: PLW0603
+
+            if not RECORD_SESSION:
+                session.console.print(
+                    "[red]There is no session being recorded. Start one using the command 'record'[/red]\n"
+                )
+            elif len(SESSION_RECORDED) < 5:
+                session.console.print(
+                    "[red]Run at least 4 commands before stopping recording a session.[/red]\n"
+                )
+            else:
+                current_user = session.user
+
+                # Check if the user just wants to store routine locally
+                # This works regardless of whether they are logged in or not
+                if RECORD_SESSION_LOCAL_ONLY:
+                    # Whitespaces are replaced by underscores and an .openbb extension is added
+                    title_for_local_storage = (
+                        SESSION_RECORDED_NAME.replace(" ", "_") + ".openbb"
+                    )
+
+                    routine_file = os.path.join(
+                        f"{current_user.preferences.export_directory}/routines",
+                        title_for_local_storage,
+                    )
+
+                    # If file already exists, add a timestamp to the name
+                    if os.path.isfile(routine_file):
+                        i = session.console.input(
+                            "A local routine with the same name already exists, "
+                            "do you want to override it? (y/n): "
+                        )
+                        session.console.print("")
+                        while i.lower() not in ["y", "yes", "n", "no"]:
+                            i = session.console.input("Select 'y' or 'n' to proceed: ")
+                            session.console.print("")
+
+                        if i.lower() in ["n", "no"]:
+                            new_name = (
+                                datetime.now().strftime("%Y%m%d_%H%M%S_")
+                                + title_for_local_storage
+                            )
+                            routine_file = os.path.join(
+                                current_user.preferences.export_directory,
+                                "routines",
+                                new_name,
+                            )
+                            session.console.print(
+                                f"[yellow]The routine name has been updated to '{new_name}'[/yellow]\n"
+                            )
+
+                    # Writing to file
+                    Path(os.path.dirname(routine_file)).mkdir(
+                        parents=True, exist_ok=True
+                    )
+
+                    with open(routine_file, "w") as file1:
+                        lines = ["# OpenBB Platform CLI - Routine", "\n"]
+
+                        username = getattr(
+                            session.user.profile.hub_session, "username", "local"
+                        )
+
+                        lines += (
+                            [f"# Author: {username}", "\n\n"] if username else ["\n"]
+                        )
+                        lines += [
+                            f"# Title: {SESSION_RECORDED_NAME}",
+                            "\n",
+                            f"# Tags: {SESSION_RECORDED_TAGS}",
+                            "\n\n",
+                            f"# Description: {SESSION_RECORDED_DESCRIPTION}",
+                            "\n\n",
+                        ]
+                        lines += [c + "\n" for c in SESSION_RECORDED[:-1]]
+                        # Writing data to a file
+                        file1.writelines(lines)
+
+                    session.console.print(
+                        f"[green]Your routine has been recorded and saved here: {routine_file}[/green]\n"
+                    )
+
+                # If user doesn't specify they want to store routine locally
+                # Confirm that the user is logged in
+                elif not session.is_local():
+                    routine = "\n".join(SESSION_RECORDED[:-1])
+                    hub_session = current_user.profile.hub_session
+
+                    if routine is not None:
+                        auth_header = (
+                            f"{hub_session.token_type} {hub_session.access_token.get_secret_value()}"
+                            if hub_session
+                            else None
+                        )
+                        kwargs = {
+                            "auth_header": auth_header,
+                            "name": SESSION_RECORDED_NAME,
+                            "description": SESSION_RECORDED_DESCRIPTION,
+                            "routine": routine,
+                            "tags": SESSION_RECORDED_TAGS,
+                            "public": SESSION_RECORDED_PUBLIC,
+                        }
+                        response = upload_routine(**kwargs)  # type: ignore
+                        if response is not None and response.status_code == 409:
+                            i = session.console.input(
+                                "A routine with the same name already exists, "
+                                "do you want to replace it? (y/n): "
+                            )
+                            session.console.print("")
+                            if i.lower() in ["y", "yes"]:
+                                kwargs["override"] = True  # type: ignore
+                                response = upload_routine(**kwargs)  # type: ignore
+                            else:
+                                session.console.print("[info]Aborted.[/info]")
+
+                # Clear session to be recorded again
+                RECORD_SESSION = False
+                SESSION_RECORDED = list()
+
+    def call_whoami(self, other_args: List[str]) -> None:
+        """Process whoami command."""
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prog="whoami",
+            description="Show current user",
+        )
+        ns_parser, _ = self.parse_simple_args(parser, other_args)
+
+        if ns_parser:
+            current_user = session.user
+            local_user = session.is_local()
+            if not local_user:
+                hub_session = current_user.profile.hub_session
+                session.console.print(
+                    f"[info]email:[/info] {hub_session.email if hub_session else 'N/A'}"
+                )
+                session.console.print(
+                    f"[info]uuid:[/info] {hub_session.user_uuid if hub_session else 'N/A'}"
+                )
+            else:
+                print_guest_block_msg()
+
+    def call_results(self, other_args: List[str]):
+        """Process results command."""
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prog="results",
+            description="Process results command. This command displays a registry of "
+            "'OBBjects' where all execution results are stored. "
+            "It is organized as a stack, with the most recent result at index 0.",
+        )
+        parser.add_argument("--index", dest="index", help="Index of the result.")
+        parser.add_argument("--key", dest="key", help="Key of the result.")
+        parser.add_argument(
+            "--chart", action="store_true", dest="chart", help="Display chart."
+        )
+        parser.add_argument(
+            "--export",
+            default="",
+            type=check_file_type_saved(["csv", "json", "xlsx", "png", "jpg"]),
+            dest="export",
+            help="Export raw data into csv, json, xlsx and figure into png or jpg.",
+            nargs="+",
+        )
+        parser.add_argument(
+            "--sheet-name",
+            dest="sheet_name",
+            default=None,
+            nargs="+",
+            help="Name of excel sheet to save data to. Only valid for .xlsx files.",
+        )
+
+        ns_parser, unknown_args = self.parse_simple_args(
+            parser, other_args, unknown_args=True
+        )
+
+        if ns_parser:
+            kwargs = parse_unknown_args_to_dict(unknown_args)
+            if not ns_parser.index and not ns_parser.key:
+                results = session.obbject_registry.all
+                if results:
+                    df = pd.DataFrame.from_dict(results, orient="index")
+                    print_rich_table(
+                        df,
+                        show_index=True,
+                        index_name="stack index",
+                        title="OBBject Results",
+                    )
+                else:
+                    session.console.print("[info]No results found.[/info]")
+            elif ns_parser.index:
+                try:
+                    index = int(ns_parser.index)
+                    obbject = session.obbject_registry.get(index)
+                    if obbject:
+                        handle_obbject_display(
+                            obbject=obbject,
+                            chart=ns_parser.chart,
+                            export=ns_parser.export,
+                            sheet_name=ns_parser.sheet_name,
+                            **kwargs,
+                        )
+                    else:
+                        session.console.print(
+                            f"[info]No result found at index {index}.[/info]"
+                        )
+                except ValueError:
+                    session.console.print(
+                        f"[red]Index must be an integer, not '{ns_parser.index}'.[/red]"
+                    )
+            elif ns_parser.key:
+                obbject = session.obbject_registry.get(ns_parser.key)
+                if obbject:
+                    handle_obbject_display(
+                        obbject=obbject,
+                        chart=ns_parser.chart,
+                        export=ns_parser.export,
+                        sheet_name=ns_parser.sheet_name,
+                        **kwargs,
+                    )
+                else:
+                    session.console.print(
+                        f"[info]No result found with key '{ns_parser.key}'.[/info]"
+                    )
+
+    @staticmethod
+    def parse_simple_args(
+        parser: argparse.ArgumentParser,
+        other_args: List[str],
+        unknown_args: bool = False,
+    ) -> Tuple[Optional[argparse.Namespace], Optional[List[str]]]:
+        """Parse list of arguments into the supplied parser.
+
+        Parameters
+        ----------
+        parser: argparse.ArgumentParser
+            Parser with predefined arguments
+        other_args: List[str]
+            List of arguments to parse
+        unknown_args: bool
+            Flag to indicate if unknown arguments should be returned
+
+        Returns
+        -------
+        ns_parser: argparse.Namespace
+            Namespace with parsed arguments
+        l_unknown_args: List[str]
+            List of unknown arguments
+        """
+        parser.add_argument(
+            "-h", "--help", action="store_true", help="show this help message"
+        )
+
+        if session.settings.USE_CLEAR_AFTER_CMD:
+            system_clear()
+
+        try:
+            (ns_parser, l_unknown_args) = parser.parse_known_args(other_args)
+        except SystemExit:
+            # In case the command has required argument that isn't specified
+            session.console.print("\n")
+            return None, None
+
+        if ns_parser.help:
+            txt_help = parser.format_help()
+            session.console.print(f"[help]{txt_help}[/help]")
+            return None, None
+
+        if l_unknown_args and not unknown_args:
+            session.console.print(
+                f"The following args couldn't be interpreted: {l_unknown_args}\n"
+            )
+        return ns_parser, l_unknown_args
+
+    @classmethod
+    def parse_known_args_and_warn(
+        cls,
+        parser: argparse.ArgumentParser,
+        other_args: List[str],
+        export_allowed: Literal[
+            "no_export", "raw_data_only", "figures_only", "raw_data_and_figures"
+        ] = "no_export",
+        raw: bool = False,
+        limit: int = 0,
+    ):
+        """Parse list of arguments into the supplied parser.
+
+        Parameters
+        ----------
+        parser: argparse.ArgumentParser
+            Parser with predefined arguments
+        other_args: List[str]
+            list of arguments to parse
+        export_allowed: Literal["no_export", "raw_data_only", "figures_only", "raw_data_and_figures"]
+            Export options
+        raw: bool
+            Add the --raw flag
+        limit: int
+            Add a --limit flag with this number default
+
+        Returns
+        ----------
+        ns_parser:
+            Namespace with parsed arguments
+        """
+        parser.add_argument(
+            "-h", "--help", action="store_true", help="show this help message"
+        )
+
+        if export_allowed != "no_export":
+            choices_export = []
+            help_export = "Does not export!"
+
+            if export_allowed == "raw_data_only":
+                choices_export = ["csv", "json", "xlsx"]
+                help_export = "Export raw data into csv, json or xlsx."
+            elif export_allowed == "figures_only":
+                choices_export = ["png", "jpg"]
+                help_export = "Export figure into png or jpg."
+            else:
+                choices_export = ["csv", "json", "xlsx", "png", "jpg"]
+                help_export = (
+                    "Export raw data into csv, json, xlsx and figure into png or jpg."
+                )
+
+            parser.add_argument(
+                "--export",
+                default="",
+                type=check_file_type_saved(choices_export),
+                dest="export",
+                help=help_export,
+                nargs="+",
+            )
+
+            # If excel is an option, add the sheet name
+            if export_allowed in [
+                "raw_data_only",
+                "raw_data_and_figures",
+            ]:
+                parser.add_argument(
+                    "--sheet-name",
+                    dest="sheet_name",
+                    default=None,
+                    nargs="+",
+                    help="Name of excel sheet to save data to. Only valid for .xlsx files.",
+                )
+
+        if raw:
+            parser.add_argument(
+                "--raw",
+                dest="raw",
+                action="store_true",
+                default=False,
+                help="Flag to display raw data",
+            )
+        if limit > 0:
+            parser.add_argument(
+                "-l",
+                "--limit",
+                dest="limit",
+                default=limit,
+                help="Number of entries to show in data.",
+                type=check_positive,
+            )
+
+        parser.add_argument(
+            "--register_obbject",
+            dest="register_obbject",
+            action="store_false",
+            default=True,
+            help="Flag to store data in the OBBject registry, True by default.",
+        )
+        parser.add_argument(
+            "--register_key",
+            dest="register_key",
+            default="",
+            help="Key to reference data in the OBBject registry.",
+            type=validate_register_key,
+        )
+
+        if session.settings.USE_CLEAR_AFTER_CMD:
+            system_clear()
+
+        if "--help" in other_args or "-h" in other_args:
+            txt_help = parser.format_help() + "\n"
+            session.console.print(f"[help]{txt_help}[/help]")
+            return None
+
+        try:
+            # Determine the index of the routine arguments
+            routine_args_index = next(
+                (
+                    i + 1
+                    for i, arg in enumerate(other_args)
+                    if arg in ("-i", "--input")
+                    and "routine_args"
+                    in [
+                        action.dest
+                        for action in parser._actions  # pylint: disable=protected-access
+                    ]
+                ),
+                -1,
+            )
+            # Split comma-separated arguments, except for the argument at routine_args_index
+            other_args = [
+                part
+                for index, arg in enumerate(other_args)
+                for part in (arg.split(",") if index != routine_args_index else [arg])
+            ]
+
+            # Check if the action has optional choices, if yes, remove them
+            for action in parser._actions:  # pylint: disable=protected-access
+                if hasattr(action, "optional_choices") and action.optional_choices:
+                    action.choices = None
+
+            (ns_parser, l_unknown_args) = parser.parse_known_args(other_args)
+
+            if export_allowed in [
+                "raw_data_only",
+                "raw_data_and_figures",
+            ]:
+                ns_parser.is_image = any(
+                    ext in ns_parser.export for ext in ["png", "jpg"]
+                )
+
+        except SystemExit:
+            # In case the command has required argument that isn't specified
+
+            return None
+
+        if l_unknown_args:
+            session.console.print(
+                f"The following args couldn't be interpreted: {l_unknown_args}"
+            )
+        return ns_parser
+
+    def menu(self, custom_path_menu_above: str = ""):
+        """Enter controller menu."""
+        settings = session.settings
+        an_input = "HELP_ME"
+
+        while True:
+            # There is a command in the queue
+            if self.queue and len(self.queue) > 0:
+                if self.queue[0] in ("q", "..", "quit"):
+                    self.save_class()
+                    # Go back to the root in order to go to the right directory because
+                    # there was a jump between indirect menus
+                    if custom_path_menu_above:
+                        self.queue.insert(1, custom_path_menu_above)
+
+                    if len(self.queue) > 1:
+                        return self.queue[1:]
+
+                    if settings.ENABLE_EXIT_AUTO_HELP:
+                        return ["help"]
+                    return []
+
+                # Consume 1 element from the queue
+                an_input = self.queue[0]
+                self.queue = self.queue[1:]
+
+                # Print location because this was an instruction and we want user to know the action
+                if (
+                    an_input
+                    and an_input != "home"
+                    and an_input != "help"
+                    and an_input.split(" ")[0] in self.controller_choices
+                ):
+                    session.console.print(
+                        f"{get_flair_and_username()} {self.PATH} $ {an_input}"
+                    )
+
+            # Get input command from user
+            else:
+                # Display help menu when entering on this menu from a level above
+                if an_input == "HELP_ME":
+                    self.print_help()
+
+                try:
+                    prompt_session = session.prompt_session
+                    if prompt_session and settings.USE_PROMPT_TOOLKIT:
+                        # Check if toolbar hint was enabled
+                        if settings.TOOLBAR_HINT:
+                            an_input = prompt_session.prompt(
+                                f"{get_flair_and_username()} {self.PATH} $ ",
+                                completer=self.completer,
+                                search_ignore_case=True,
+                                bottom_toolbar=HTML(
+                                    '<style bg="ansiblack" fg="ansiwhite">[h]</style> help menu    '
+                                    '<style bg="ansiblack" fg="ansiwhite">[q]</style> return to previous menu    '
+                                    '<style bg="ansiblack" fg="ansiwhite">[e]</style> exit the program    '
+                                    '<style bg="ansiblack" fg="ansiwhite">[cmd -h]</style> '
+                                    "see usage and available options    "
+                                    f"{self.path[-1].capitalize()} (cmd/menu) Documentation"
+                                ),
+                                style=Style.from_dict(
+                                    {"bottom-toolbar": "#ffffff bg:#333333"}
+                                ),
+                            )
+                        else:
+                            an_input = prompt_session.prompt(
+                                f"{get_flair_and_username()} {self.PATH} $ ",
+                                completer=self.completer,
+                                search_ignore_case=True,
+                            )
+                    # Get input from user without auto-completion
+                    else:
+                        an_input = input(f"{get_flair_and_username()} {self.PATH} $ ")
+
+                except (KeyboardInterrupt, EOFError):
+                    # Exit in case of keyboard interrupt
+                    an_input = "exit"
+
+            try:
+                # Allow user to go back to root
+                an_input = "home" if an_input == "/" else an_input
+
+                # Process the input command
+                self.queue = self.switch(an_input)
+
+            except SystemExit:
+                session.console.print(
+                    f"[red]The command '{an_input}' doesn't exist on the {self.PATH} menu.[/red]\n",
+                )
+                similar_cmd = difflib.get_close_matches(
+                    an_input.split(" ")[0] if " " in an_input else an_input,
+                    self.controller_choices,
+                    n=1,
+                    cutoff=0.7,
+                )
+                if similar_cmd:
+                    if " " in an_input:
+                        candidate_input = (
+                            f"{similar_cmd[0]} {' '.join(an_input.split(' ')[1:])}"
+                        )
+                        if candidate_input == an_input:
+                            an_input = ""
+                            self.queue = []
+                            session.console.print("\n")
+                            continue
+
+                        an_input = candidate_input
+                    else:
+                        an_input = similar_cmd[0]
+
+                    session.console.print(
+                        f"[green]Replacing by '{an_input}'.[/green]\n"
+                    )
+                    self.queue.insert(0, an_input)

cli/openbb_cli/controllers/base_platform_controller.py

@@ -0,0 +1,392 @@
+"""Platform Equity Controller."""
+
+import os
+from functools import partial, update_wrapper
+from types import MethodType
+from typing import Dict, List, Optional
+
+import pandas as pd
+from openbb import obb
+from openbb_charting.core.openbb_figure import OpenBBFigure
+from openbb_cli.argparse_translator.argparse_class_processor import (
+    ArgparseClassProcessor,
+)
+from openbb_cli.config.menu_text import MenuText
+from openbb_cli.controllers.base_controller import BaseController
+from openbb_cli.controllers.utils import export_data, print_rich_table
+from openbb_cli.session import Session
+from openbb_core.app.model.obbject import OBBject
+
+session = Session()
+
+
+class DummyTranslation:
+    """Dummy Translation for testing."""
+
+    def __init__(self):
+        """Construct a Dummy Translation Class."""
+        self.paths = {}
+        self.translators = {}
+
+
+class PlatformController(BaseController):
+    """Platform Controller Base class."""
+
+    CHOICES_GENERATION = True
+
+    def __init__(  # pylint: disable=too-many-positional-arguments
+        self,
+        name: str,
+        parent_path: List[str],
+        platform_target: Optional[type] = None,
+        queue: Optional[List[str]] = None,
+        translators: Optional[Dict] = None,
+    ):
+        """Construct a Platform based Controller."""
+        self.PATH = f"/{'/'.join(parent_path)}/{name}/" if parent_path else f"/{name}/"
+        super().__init__(queue)
+        self._name = name
+
+        if not (platform_target or translators):
+            raise ValueError("Either platform_target or translators must be provided.")
+
+        self._translated_target = (
+            ArgparseClassProcessor(
+                target_class=platform_target, reference=obb.reference["paths"]  # type: ignore
+            )
+            if platform_target
+            else DummyTranslation()
+        )
+        self.translators = (
+            translators
+            if translators is not None
+            else getattr(self._translated_target, "translators", {})
+        )
+        self.paths = getattr(self._translated_target, "paths", {})
+
+        if self.translators:
+            self._link_obbject_to_data_processing_commands()
+            self._generate_commands()
+            self._generate_sub_controllers()
+            self.update_completer(self.choices_default)
+
+    def _link_obbject_to_data_processing_commands(self):
+        """Link data processing commands to OBBject registry."""
+        for _, trl in self.translators.items():
+            for action in trl._parser._actions:  # pylint: disable=protected-access
+                if action.dest == "data":
+                    # Generate choices by combining indexed and key-based choices
+                    action.choices = [
+                        "OBB" + str(i)
+                        for i in range(len(session.obbject_registry.obbjects))
+                    ] + [
+                        obbject.extra["register_key"]
+                        for obbject in session.obbject_registry.obbjects
+                        if "register_key" in obbject.extra
+                    ]
+
+                    action.type = str
+                    action.nargs = None
+
+    def _intersect_data_processing_commands(self, ns_parser):
+        """Intersect data processing commands and change the obbject id into an actual obbject."""
+        if hasattr(ns_parser, "data"):
+            if "OBB" in ns_parser.data:
+                ns_parser.data = int(ns_parser.data.replace("OBB", ""))
+
+            if (ns_parser.data in range(len(session.obbject_registry.obbjects))) or (
+                ns_parser.data in session.obbject_registry.obbject_keys
+            ):
+                obbject = session.obbject_registry.get(ns_parser.data)
+                if obbject and isinstance(obbject, OBBject):
+                    setattr(ns_parser, "data", obbject.results)
+
+        return ns_parser
+
+    def _generate_sub_controllers(self):
+        """Handle paths."""
+        for path, value in self.paths.items():
+            if value == "path":
+                continue
+
+            sub_menu_translators = {}
+            choices_commands = []
+
+            for translator_name, translator in self.translators.items():
+                if f"{self._name}_{path}" in translator_name:
+                    new_name = translator_name.replace(f"{self._name}_{path}_", "")
+                    sub_menu_translators[new_name] = translator
+                    choices_commands.append(new_name)
+
+                    if translator_name in self.CHOICES_COMMANDS:
+                        self.CHOICES_COMMANDS.remove(translator_name)
+
+            # Create the sub controller as a new class
+            class_name = f"{self._name.capitalize()}{path.capitalize()}Controller"
+            SubController = type(
+                class_name,
+                (PlatformController,),
+                {
+                    "CHOICES_GENERATION": True,
+                    # "CHOICES_MENUS": [],
+                    "CHOICES_COMMANDS": choices_commands,
+                },
+            )
+
+            self._generate_controller_call(
+                controller=SubController,
+                name=path,
+                parent_path=self.path,
+                translators=sub_menu_translators,
+            )
+
+    def _generate_commands(self):
+        """Generate commands."""
+        for name, translator in self.translators.items():
+            # Prepare the translator name to create a command call in the controller
+            new_name = name.replace(f"{self._name}_", "")
+
+            self._generate_command_call(name=new_name, translator=translator)
+
+    def _generate_command_call(self, name, translator):
+        """Generate command call."""
+
+        def method(self, other_args: List[str], translator=translator):
+            """Call the translator."""
+            parser = translator.parser
+
+            if ns_parser := self.parse_known_args_and_warn(
+                parser=parser,
+                other_args=other_args,
+                export_allowed="raw_data_and_figures",
+            ):
+                try:
+                    ns_parser = self._intersect_data_processing_commands(ns_parser)
+                    export = hasattr(ns_parser, "export") and ns_parser.export
+                    store_obbject = (
+                        hasattr(ns_parser, "register_obbject")
+                        and ns_parser.register_obbject
+                    )
+
+                    obbject = translator.execute_func(parsed_args=ns_parser)
+                    df: pd.DataFrame = pd.DataFrame()
+                    fig: Optional[OpenBBFigure] = None
+                    title = f"{self.PATH}{translator.func.__name__}"
+
+                    if obbject:
+                        if isinstance(obbject, list):
+                            obbject = OBBject(results=obbject)
+
+                        if isinstance(obbject, OBBject):
+                            if (
+                                session.max_obbjects_exceeded()
+                                and obbject.results
+                                and store_obbject
+                            ):
+                                session.obbject_registry.remove()
+                                session.console.print(
+                                    "[yellow]Maximum number of OBBjects reached. The oldest entry was removed.[yellow]"
+                                )
+
+                            # use the obbject to store the command so we can display it later on results
+                            obbject.extra["command"] = f"{title} {' '.join(other_args)}"
+                            # if there is a registry key in the parser, store to the obbject
+                            if (
+                                hasattr(ns_parser, "register_key")
+                                and ns_parser.register_key
+                            ):
+                                if (
+                                    ns_parser.register_key
+                                    not in session.obbject_registry.obbject_keys
+                                ):
+                                    obbject.extra["register_key"] = str(
+                                        ns_parser.register_key
+                                    )
+                                else:
+                                    session.console.print(
+                                        f"[yellow]Key `{ns_parser.register_key}` already exists in the registry."
+                                        "The `OBBject` was kept without the key.[/yellow]"
+                                    )
+
+                            if store_obbject:
+                                # store the obbject in the registry
+                                register_result = session.obbject_registry.register(
+                                    obbject
+                                )
+
+                                # we need to force to re-link so that the new obbject
+                                # is immediately available for data processing commands
+                                self._link_obbject_to_data_processing_commands()
+                                # also update the completer
+                                self.update_completer(self.choices_default)
+
+                                if (
+                                    session.settings.SHOW_MSG_OBBJECT_REGISTRY
+                                    and register_result
+                                ):
+                                    session.console.print(
+                                        "Added `OBBject` to cached results."
+                                    )
+
+                            # making the dataframe available either for printing or exporting
+                            df = obbject.to_dataframe()
+
+                            if hasattr(ns_parser, "chart") and ns_parser.chart:
+                                fig = obbject.chart.fig if obbject.chart else None
+                                if not export:
+                                    obbject.show()
+                            elif session.settings.USE_INTERACTIVE_DF and not export:
+                                obbject.charting.table()
+                            else:
+                                if isinstance(df.columns, pd.RangeIndex):
+                                    df.columns = [str(i) for i in df.columns]
+
+                                print_rich_table(
+                                    df=df, show_index=True, title=title, export=export
+                                )
+
+                        elif isinstance(obbject, dict):
+                            df = pd.DataFrame.from_dict(obbject, orient="columns")
+                            print_rich_table(
+                                df=df, show_index=True, title=title, export=export
+                            )
+
+                        elif not isinstance(obbject, OBBject):
+                            session.console.print(obbject)
+
+                    if export and not df.empty:
+                        sheet_name = getattr(ns_parser, "sheet_name", None)
+                        if sheet_name and isinstance(sheet_name, list):
+                            sheet_name = sheet_name[0]
+
+                        export_data(
+                            export_type=",".join(ns_parser.export),
+                            dir_path=os.path.dirname(os.path.abspath(__file__)),
+                            func_name=translator.func.__name__,
+                            df=df,
+                            sheet_name=sheet_name,
+                            figure=fig,
+                        )
+                    elif export and df.empty:
+                        session.console.print("[yellow]No data to export.[/yellow]")
+
+                except Exception as e:
+                    session.console.print(f"[red]{e}[/]\n")
+                    return
+
+        # Bind the method to the class
+        bound_method = MethodType(method, self)
+
+        # Update the wrapper and set the attribute
+        bound_method = update_wrapper(  # type: ignore
+            partial(bound_method, translator=translator), method
+        )
+        setattr(self, f"call_{name}", bound_method)
+
+    def _generate_controller_call(self, controller, name, parent_path, translators):
+        """Generate controller call."""
+
+        def method(self, _, controller, name, parent_path, translators):
+            """Call the controller."""
+            self.queue = self.load_class(
+                class_ins=controller,
+                name=name,
+                parent_path=parent_path,
+                translators=translators,
+                queue=self.queue,
+            )
+
+        # Bind the method to the class
+        bound_method = MethodType(method, self)
+
+        # Update the wrapper and set the attribute
+        bound_method = update_wrapper(  # type: ignore
+            partial(
+                bound_method,
+                name=name,
+                parent_path=parent_path,
+                translators=translators,
+                controller=controller,
+            ),
+            method,
+        )
+        setattr(self, f"call_{name}", bound_method)
+
+    def _get_command_description(self, command: str) -> str:
+        """Get command description."""
+        command_description = (
+            obb.reference["paths"]  # type: ignore
+            .get(f"{self.PATH}{command}", {})
+            .get("description", "")
+        )
+
+        if not command_description:
+            trl = self.translators.get(
+                f"{self._name}_{command}"
+            ) or self.translators.get(command)
+            if trl and hasattr(trl, "parser"):
+                command_description = trl.parser.description
+
+        return command_description.split(".")[0].lower()
+
+    def _get_menu_description(self, menu: str) -> str:
+        """Get menu description."""
+
+        def _get_sub_menu_commands():
+            """Get sub menu commands."""
+            sub_path = f"{self.PATH[1:].replace('/','_')}{menu}"
+            commands = []
+            for trl in self.translators:
+                if sub_path in trl:
+                    commands.append(trl.replace(f"{sub_path}_", ""))
+            return commands
+
+        menu_description = (
+            obb.reference["routers"]  # type: ignore
+            .get(f"{self.PATH}{menu}", {})
+            .get("description", "")
+        ) or ""
+        if menu_description:
+            return menu_description.split(".")[0].lower()
+
+        # If no description is found, return the sub menu commands
+        return ", ".join(_get_sub_menu_commands())
+
+    def print_help(self):
+        """Print help."""
+        mt = MenuText(self.PATH)
+
+        if self.CHOICES_MENUS:
+            for menu in self.CHOICES_MENUS:
+                description = self._get_menu_description(menu)
+                mt.add_menu(name=menu, description=description)
+
+            if self.CHOICES_COMMANDS:
+                mt.add_raw("\n")
+
+        if self.CHOICES_COMMANDS:
+            for command in self.CHOICES_COMMANDS:
+                command_description = self._get_command_description(command)
+                mt.add_cmd(
+                    name=command.replace(f"{self._name}_", ""),
+                    description=command_description,
+                )
+
+        if session.obbject_registry.obbjects:
+            mt.add_info("\nCached Results")
+            for key, value in list(session.obbject_registry.all.items())[
+                : session.settings.N_TO_DISPLAY_OBBJECT_REGISTRY
+            ]:
+                mt.add_raw(
+                    f"[yellow]OBB{key}[/yellow]: {value['command']}",
+                    left_spacing=True,
+                )
+
+        session.console.print(text=mt.menu_text, menu=self.PATH)
+
+        if mt.warnings:
+            session.console.print("")
+            for w in mt.warnings:
+                w_str = str(w).replace("{", "").replace("}", "").replace("'", "")
+                session.console.print(f"[yellow]{w_str}[/yellow]")
+            session.console.print("")

cli/openbb_cli/controllers/choices.py

@@ -0,0 +1,344 @@
+"""This module contains functions to build the choice map for the controllers."""
+
+from argparse import SUPPRESS, ArgumentParser
+from contextlib import contextmanager
+from inspect import isfunction, unwrap
+from types import MethodType
+from typing import Callable, List, Literal, Tuple
+from unittest.mock import patch
+
+from openbb_cli.controllers.utils import (
+    check_file_type_saved,
+    check_positive,
+    validate_register_key,
+)
+from openbb_cli.session import Session
+
+session = Session()
+
+
+def __mock_parse_known_args_and_warn(
+    controller,  # pylint: disable=unused-argument
+    parser: ArgumentParser,
+    other_args: List[str],
+    export_allowed: Literal[
+        "no_export", "raw_data_only", "figures_only", "raw_data_and_figures"
+    ] = "no_export",
+    raw: bool = False,
+    limit: int = 0,
+) -> None:
+    """Add arguments.
+
+    Add the arguments that would have normally added by :
+        - openbb_cli.base_controller.BaseController.parse_known_args_and_warn
+
+    Parameters
+    ----------
+    parser: argparse.ArgumentParser
+        Parser with predefined arguments
+    other_args: List[str]
+        list of arguments to parse
+    export_allowed: Literal["no_export", "raw_data_only", "figures_only", "raw_data_and_figures"]
+            Export options
+    raw: bool
+        Add the --raw flag
+    limit: int
+        Add a --limit flag with this number default
+    """
+    _ = other_args
+
+    parser.add_argument(
+        "-h", "--help", action="store_true", help="show this help message"
+    )
+
+    if export_allowed != "no_export":
+        choices_export = []
+        help_export = "Does not export!"
+
+        if export_allowed == "raw_data_only":
+            choices_export = ["csv", "json", "xlsx"]
+            help_export = "Export raw data into csv, json or xlsx."
+        elif export_allowed == "figures_only":
+            choices_export = ["png", "jpg"]
+            help_export = "Export figure into png or jpg."
+        else:
+            choices_export = ["csv", "json", "xlsx", "png", "jpg"]
+            help_export = (
+                "Export raw data into csv, json, xlsx and figure into png or jpg."
+            )
+
+        parser.add_argument(
+            "--export",
+            default="",
+            type=check_file_type_saved(choices_export),
+            dest="export",
+            help=help_export,
+            choices=choices_export,
+        )
+
+    if raw:
+        parser.add_argument(
+            "--raw",
+            dest="raw",
+            action="store_true",
+            default=False,
+            help="Flag to display raw data",
+        )
+    if limit > 0:
+        parser.add_argument(
+            "-l",
+            "--limit",
+            dest="limit",
+            default=limit,
+            help="Number of entries to show in data.",
+            type=check_positive,
+        )
+
+    parser.add_argument(
+        "--register_obbject",
+        dest="register_obbject",
+        action="store_false",
+        default=True,
+        help="Flag to store data in the OBBject registry, True by default.",
+    )
+    parser.add_argument(
+        "--register_key",
+        dest="register_key",
+        default="",
+        help="Key to reference data in the OBBject registry.",
+        type=validate_register_key,
+    )
+
+
+def __mock_parse_simple_args(parser: ArgumentParser, other_args: List[str]) -> Tuple:
+    """Add arguments.
+
+    Add the arguments that would have normally added by:
+        - openbb_cli.parent_classes.BaseController.parse_simple_args
+
+    Parameters
+    ----------
+    parser: argparse.ArgumentParser
+        Parser with predefined arguments
+    other_args: List[str]
+        List of arguments to parse
+    """
+    parser.add_argument(
+        "-h", "--help", action="store_true", help="show this help message"
+    )
+    _ = other_args
+    return None, None
+
+
+def __get_command_func(controller, command: str):
+    """Get the function with the name `f"call_{command}"` from controller object.
+
+    Parameters
+    ----------
+    controller: BaseController
+        Instance of the CLI Controller.
+    command: str
+        A name from controller.CHOICES_COMMANDS
+
+    Returns
+    -------
+    Callable: Command function.
+    """
+    if command not in controller.CHOICES_COMMANDS:
+        raise AttributeError(
+            f"The following command is not inside `CHOICES_COMMANDS` : '{command}'"
+        )
+
+    command = f"call_{command}"
+    command_func = getattr(controller, command)
+    command_func = unwrap(func=command_func)
+
+    if isfunction(command_func):
+        command_func = MethodType(command_func, controller)
+
+    return command_func
+
+
+def contains_functions_to_patch(command_func: Callable) -> bool:
+    """Check command function.
+
+    Check if a `command_func` actually contains the functions we want to mock, i.e.:
+        - parse_simple_args
+        - parse_known_args_and_warn
+
+    Parameters
+    ----------
+    command_func: Callable
+        Function to check.
+
+    Returns
+    -------
+    bool: Whether or not `command_func` contains the mocked functions.
+    """
+    co_names = command_func.__code__.co_names
+
+    return bool(
+        "parse_simple_args" in co_names or "parse_known_args_and_warn" in co_names
+    )
+
+
+@contextmanager
+def __patch_controller_functions(controller):
+    """Patch controller functions.
+
+    Patch the following function from a BaseController instance:
+        - parse_simple_args
+        - parse_known_args_and_warn
+
+    These functions take an 'argparse.ArgumentParser' object as parameter.
+    We want to intercept this 'argparse.ArgumentParser' object.
+
+    Parameters
+    ----------
+    controller: BaseController
+        BaseController object that needs to be patched.
+
+    Returns
+    -------
+    List[Callable]: List of mocked functions.
+    """
+    bound_mock_parse_known_args_and_warn = MethodType(
+        __mock_parse_known_args_and_warn,
+        controller,
+    )
+
+    rich = patch(
+        target="openbb_cli.config.console.Console.print",
+        return_value=None,
+    )
+
+    patcher_list = [
+        patch.object(
+            target=controller,
+            attribute="parse_simple_args",
+            side_effect=__mock_parse_simple_args,
+            return_value=(None, None),
+        ),
+        patch.object(
+            target=controller,
+            attribute="parse_known_args_and_warn",
+            side_effect=bound_mock_parse_known_args_and_warn,
+            return_value=None,
+        ),
+    ]
+
+    if not session.settings.DEBUG_MODE:
+        rich.start()
+    patched_function_list = []
+    for patcher in patcher_list:
+        patched_function_list.append(patcher.start())
+
+    yield patched_function_list
+
+    if not session.settings.DEBUG_MODE:
+        rich.stop()
+    for patcher in patcher_list:
+        patcher.stop()
+
+
+def _get_argument_parser(
+    controller,
+    command: str,
+) -> ArgumentParser:
+    """Intercept the ArgumentParser instance from the command function.
+
+    A command function being a function starting with `call_`, like:
+        - call_help
+        - call_overview
+        - call_load
+
+    Parameters
+    ----------
+    controller: BaseController
+        Instance of the CLI Controller.
+    command: str
+        A name from `controller.CHOICES_COMMANDS`.
+
+    Returns
+    -------
+    ArgumentParser: ArgumentParser instance from the command function.
+    """
+    command_func: Callable = __get_command_func(controller=controller, command=command)
+
+    if not contains_functions_to_patch(command_func=command_func):
+        raise AssertionError(
+            f"One of these functions should be inside `call_{command}`:\n"
+            " - parse_simple_args\n"
+            " - parse_known_args_and_warn\n"
+        )
+
+    with __patch_controller_functions(controller=controller) as patched_function_list:
+        command_func([])
+
+        call_count = 0
+        for patched_function in patched_function_list:
+            call_count += patched_function.call_count
+            if patched_function.call_count == 1:
+                args, kwargs = patched_function.call_args
+                argument_parser = (
+                    kwargs["parser"] if kwargs.get("parser", None) else args[0]
+                )
+
+        if call_count != 1:
+            raise AssertionError(
+                f"One of these functions should be called once inside `call_{command}`:\n"
+                " - parse_simple_args\n"
+                " - parse_known_args_and_warn\n"
+            )
+
+    # pylint: disable=possibly-used-before-assignment
+    return argument_parser
+
+
+def _build_command_choice_map(argument_parser: ArgumentParser) -> dict:
+    """Build the choice map for a command."""
+    choice_map: dict = {}
+    for action in argument_parser._actions:  # pylint: disable=protected-access
+        if action.help == SUPPRESS:
+            continue
+        if len(action.option_strings) == 1:
+            long_name = action.option_strings[0]
+            short_name = ""
+        elif len(action.option_strings) == 2:
+            short_name = action.option_strings[0]
+            long_name = action.option_strings[1]
+        else:
+            raise AttributeError(f"Invalid argument_parser: {argument_parser}")
+
+        if hasattr(action, "choices") and action.choices:
+            choice_map[long_name] = {str(c): {} for c in action.choices}
+        else:
+            choice_map[long_name] = {}
+
+        if short_name and long_name:
+            choice_map[short_name] = long_name
+
+    return choice_map
+
+
+def build_controller_choice_map(controller) -> dict:
+    """Build the choice map for a controller."""
+    command_list = controller.CHOICES_COMMANDS
+    controller_choice_map: dict = {c: {} for c in controller.controller_choices}
+
+    for command in command_list:
+        try:
+            argument_parser = _get_argument_parser(
+                controller=controller,
+                command=command,
+            )
+            controller_choice_map[command] = _build_command_choice_map(
+                argument_parser=argument_parser
+            )
+        except Exception as exception:
+            if session.settings.DEBUG_MODE:
+                raise Exception(
+                    f"On command : `{command}`.\n{str(exception)}"
+                ) from exception
+
+    return controller_choice_map

cli/openbb_cli/controllers/cli_controller.py

@@ -0,0 +1,944 @@
+#!/usr/bin/env python
+"""Main CLI Module."""
+
+import argparse
+import contextlib
+import difflib
+import os
+import re
+import sys
+import time
+import webbrowser
+from datetime import datetime
+from functools import partial, update_wrapper
+from pathlib import Path
+from types import MethodType
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import requests
+from openbb import obb
+from openbb_cli.config import constants
+from openbb_cli.config.constants import (
+    ASSETS_DIRECTORY,
+    ENV_FILE_SETTINGS,
+    HOME_DIRECTORY,
+    REPOSITORY_DIRECTORY,
+)
+from openbb_cli.config.menu_text import MenuText
+from openbb_cli.controllers.base_controller import BaseController
+from openbb_cli.controllers.platform_controller_factory import (
+    PlatformControllerFactory,
+)
+from openbb_cli.controllers.script_parser import is_reset, parse_openbb_script
+from openbb_cli.controllers.utils import (
+    bootup,
+    first_time_user,
+    get_flair_and_username,
+    parse_and_split_input,
+    print_goodbye,
+    print_rich_table,
+    reset,
+    suppress_stdout,
+    welcome_message,
+)
+from openbb_cli.session import Session
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.styles import Style
+from pydantic import BaseModel
+
+PLATFORM_ROUTERS = {
+    d: "menu" if not isinstance(getattr(obb, d), BaseModel) else "command"
+    for d in dir(obb)
+    if "_" not in d
+}
+NON_DATA_ROUTERS = ["coverage", "account", "reference", "system", "user"]
+DATA_PROCESSING_ROUTERS = ["technical", "quantitative", "econometrics"]
+
+# pylint: disable=too-many-public-methods,import-outside-toplevel, too-many-function-args
+# pylint: disable=too-many-branches,no-member,C0302,too-many-return-statements, inconsistent-return-statements
+
+env_file = str(ENV_FILE_SETTINGS)
+session = Session()
+
+
+class CLIController(BaseController):
+    """CLI Controller class."""
+
+    CHOICES_COMMANDS = ["record", "stop", "exe", "results"]
+    CHOICES_MENUS = [
+        "settings",
+    ]
+
+    for router, value in PLATFORM_ROUTERS.items():
+        if value == "menu":
+            CHOICES_MENUS.append(router)
+        else:
+            CHOICES_COMMANDS.append(router)
+
+    PATH = "/"
+    CHOICES_GENERATION = False
+
+    def __init__(self, jobs_cmds: Optional[List[str]] = None):
+        """Construct CLI controller."""
+        self.ROUTINE_FILES: Dict[str, str] = dict()
+        self.ROUTINE_DEFAULT_FILES: Dict[str, str] = dict()
+        self.ROUTINE_PERSONAL_FILES: Dict[str, str] = dict()
+        self.ROUTINE_CHOICES: Dict[str, Any] = dict()
+
+        super().__init__(jobs_cmds)
+
+        self.queue: List[str] = list()
+
+        if jobs_cmds:
+            self.queue = parse_and_split_input(
+                an_input=" ".join(jobs_cmds), custom_filters=[]
+            )
+
+        self.update_success = False
+
+        self._generate_platform_commands()
+
+        self.update_runtime_choices()
+
+    def _generate_platform_commands(self):
+        """Generate Platform based commands/menus."""
+
+        def method_call_class(self, _, controller, name, parent_path, target):
+            self.queue = self.load_class(
+                controller, name, parent_path, target, self.queue
+            )
+
+        # pylint: disable=unused-argument
+        def method_call_command(self, _, router: str):
+            """Call command."""
+            mdl = getattr(obb, router)
+            df = pd.DataFrame.from_dict(mdl.model_dump(), orient="index")
+            if isinstance(df.columns, pd.RangeIndex):
+                df.columns = [str(i) for i in df.columns]
+            return print_rich_table(df, show_index=True)
+
+        for router, value in PLATFORM_ROUTERS.items():
+            target = getattr(obb, router)
+
+            if value == "menu":
+                pcf = PlatformControllerFactory(
+                    target, reference=obb.reference["paths"]  # type: ignore
+                )
+                DynamicController = pcf.create()
+
+                # Bind the method to the class
+                bound_method = MethodType(method_call_class, self)
+
+                # Update the wrapper and set the attribute
+                bound_method = update_wrapper(  # type: ignore
+                    partial(
+                        bound_method,
+                        controller=DynamicController,
+                        name=router,
+                        target=target,
+                        parent_path=self.path,
+                    ),
+                    method_call_class,
+                )
+            else:
+                bound_method = MethodType(method_call_command, self)
+                bound_method = update_wrapper(  # type: ignore
+                    partial(bound_method, router=router),
+                    method_call_command,
+                )
+
+            setattr(self, f"call_{router}", bound_method)
+
+    def update_runtime_choices(self):
+        """Update runtime choices."""
+        routines_directory = Path(session.user.preferences.export_directory, "routines")
+
+        if session.prompt_session and session.settings.USE_PROMPT_TOOLKIT:
+            # choices: dict = self.choices_default
+            choices: dict = {c: {} for c in self.controller_choices}  # type: ignore
+
+            self.ROUTINE_FILES = {
+                filepath.name: filepath  # type: ignore
+                for filepath in routines_directory.rglob("*.openbb")
+            }
+            self.ROUTINE_DEFAULT_FILES = {
+                filepath.name: filepath  # type: ignore
+                for filepath in Path(routines_directory / "hub" / "default").rglob(
+                    "*.openbb"
+                )
+            }
+            self.ROUTINE_PERSONAL_FILES = {
+                filepath.name: filepath  # type: ignore
+                for filepath in Path(routines_directory / "hub" / "personal").rglob(
+                    "*.openbb"
+                )
+            }
+
+            choices["exe"] = {
+                "--file": {
+                    filename: {} for filename in list(self.ROUTINE_FILES.keys())
+                },
+                "-f": "--file",
+                "--example": None,
+                "-e": "--example",
+                "--input": None,
+                "-i": "--input",
+                "--url": None,
+                "--help": None,
+                "-h": "--help",
+            }
+            choices["record"] = {
+                "--name": None,
+                "-n": "--name",
+                "--description": None,
+                "-d": "--description",
+                "--public": None,
+                "-p": "--public",
+                "--tag1": {c: None for c in constants.SCRIPT_TAGS},
+                "--tag2": {c: None for c in constants.SCRIPT_TAGS},
+                "--tag3": {c: None for c in constants.SCRIPT_TAGS},
+                "--help": None,
+                "-h": "--help",
+            }
+            choices["stop"] = {"--help": None, "-h": "--help"}
+            choices["results"] = {
+                "--help": None,
+                "-h": "--help",
+                "--export": {c: None for c in ["csv", "json", "xlsx", "png", "jpg"]},
+                "--index": None,
+                "--key": None,
+                "--chart": None,
+                "--sheet_name": None,
+            }
+
+            self.update_completer(choices)
+
+    def print_help(self):
+        """Print help."""
+        mt = MenuText("")
+
+        mt.add_info("Configure the platform and manage your account")
+        for router, value in PLATFORM_ROUTERS.items():
+            if router not in NON_DATA_ROUTERS or router in ["reference", "coverage"]:
+                continue
+            if value == "menu":
+                menu_description = (
+                    obb.reference["routers"]  # type: ignore
+                    .get(f"{self.PATH}{router}", {})
+                    .get("description")
+                ) or ""
+                mt.add_menu(
+                    name=router,
+                    description=menu_description.split(".")[0].lower(),
+                )
+            else:
+                mt.add_cmd(router)
+
+        mt.add_info("\nConfigure your CLI")
+        mt.add_menu(
+            "settings",
+            description="enable and disable feature flags, preferences and settings",
+        )
+        mt.add_raw("\n")
+        mt.add_info("Record and execute your own .openbb routine scripts")
+        mt.add_cmd("record", description="start recording current session")
+        mt.add_cmd(
+            "stop", description="stop session recording and convert to .openbb routine"
+        )
+        mt.add_cmd(
+            "exe",
+            description="execute .openbb routine scripts (use exe --example for an example)",
+        )
+        mt.add_raw("\n")
+        mt.add_info("Retrieve data from different asset classes and providers")
+
+        for router, value in PLATFORM_ROUTERS.items():
+            if router in NON_DATA_ROUTERS or router in DATA_PROCESSING_ROUTERS:
+                continue
+            if value == "menu":
+                menu_description = (
+                    obb.reference["routers"]  # type: ignore
+                    .get(f"{self.PATH}{router}", {})
+                    .get("description")
+                ) or ""
+                mt.add_menu(
+                    name=router,
+                    description=menu_description.split(".")[0].lower(),
+                )
+            else:
+                mt.add_cmd(router)
+
+        if any(router in PLATFORM_ROUTERS for router in DATA_PROCESSING_ROUTERS):
+            mt.add_info("\nAnalyze and process previously obtained data")
+
+            for router, value in PLATFORM_ROUTERS.items():
+                if router not in DATA_PROCESSING_ROUTERS:
+                    continue
+                if value == "menu":
+                    menu_description = (
+                        obb.reference["routers"]  # type: ignore
+                        .get(f"{self.PATH}{router}", {})
+                        .get("description")
+                    ) or ""
+                    mt.add_menu(
+                        name=router,
+                        description=menu_description.split(".")[0].lower(),
+                    )
+                else:
+                    mt.add_cmd(router)
+
+        mt.add_raw("\n")
+        mt.add_cmd("results")
+        if session.obbject_registry.obbjects:
+            mt.add_info("\nCached Results")
+            for key, value in list(session.obbject_registry.all.items())[  # type: ignore
+                : session.settings.N_TO_DISPLAY_OBBJECT_REGISTRY
+            ]:
+                mt.add_raw(
+                    f"[yellow]OBB{key}[/yellow]: {value['command']}",  # type: ignore[index]
+                    left_spacing=True,
+                )
+
+        session.console.print(text=mt.menu_text, menu="Home")
+        self.update_runtime_choices()
+
+    def parse_input(self, an_input: str) -> List:
+        """Overwrite the BaseController parse_input for `askobb` and 'exe'.
+
+        This will allow us to search for something like "P/E" ratio.
+        """
+        # Filtering out sorting parameters with forward slashes like P/E
+        sort_filter = r"((\ -q |\ --question|\ ).*?(/))"
+        # Filter out urls
+        url = r"(exe (--url )?(https?://)?my\.openbb\.(dev|co)/u/.*/routine/.*)"
+        custom_filters = [sort_filter, url]
+        return parse_and_split_input(an_input=an_input, custom_filters=custom_filters)
+
+    def call_settings(self, _):
+        """Process settings command."""
+        from openbb_cli.controllers.settings_controller import (
+            SettingsController,
+        )
+
+        self.queue = self.load_class(SettingsController, self.queue)
+
+    def call_exe(self, other_args: List[str]):
+        """Process exe command."""
+        # Merge rest of string path to other_args and remove queue since it is a dir
+        other_args += self.queue
+
+        if not other_args:
+            session.console.print(
+                "[info]Provide a path to the routine you wish to execute. For an example, please use "
+                "`exe --example`.\n[/info]"
+            )
+            return
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prog="exe",
+            description="Execute automated routine script. For an example, please use "
+            "`exe --example`.",
+        )
+        parser.add_argument(
+            "--file",
+            "-f",
+            help="The path or .openbb file to run.",
+            dest="file",
+            required="-h" not in other_args
+            and "--help" not in other_args
+            and "-e" not in other_args
+            and "--example" not in other_args
+            and "--url" not in other_args
+            and "my.openbb" not in other_args[0],
+            type=str,
+            nargs="+",
+        )
+        parser.add_argument(
+            "-i",
+            "--input",
+            help="Select multiple inputs to be replaced in the routine and separated by commas. E.g. GME,AMC,BTC-USD",
+            dest="routine_args",
+            type=str,
+        )
+        parser.add_argument(
+            "-e",
+            "--example",
+            help="Run an example script to understand how routines can be used.",
+            dest="example",
+            action="store_true",
+            default=False,
+        )
+        parser.add_argument(
+            "--url", help="URL to run openbb script from.", dest="url", type=str
+        )
+        if other_args and "-" not in other_args[0][0]:
+            if other_args[0].startswith("my.") or other_args[0].startswith("http"):
+                other_args.insert(0, "--url")
+            else:
+                other_args.insert(0, "--file")
+        ns_parser = self.parse_known_args_and_warn(parser, other_args)
+        if ns_parser:
+            if ns_parser.example:
+                routine_path = ASSETS_DIRECTORY / "routines" / "routine_example.openbb"
+                session.console.print(  # TODO: Point to docs when ready
+                    "[info]Executing an example, please visit our docs "
+                    "to learn how to create your own script.[/info]\n"
+                )
+                time.sleep(3)
+            elif ns_parser.url:
+                if not ns_parser.url.startswith(
+                    "https"
+                ) and not ns_parser.url.startswith("http:"):
+                    url = "https://" + ns_parser.url
+                elif ns_parser.url.startswith("http://"):
+                    url = ns_parser.url.replace("http://", "https://")
+                else:
+                    url = ns_parser.url
+                username = url.split("/")[-3]
+                script_name = url.split("/")[-1]
+                file_name = f"{username}_{script_name}.openbb"
+                final_url = f"{url}?raw=true"
+                response = requests.get(final_url, timeout=10)
+                if response.status_code != 200:
+                    session.console.print(
+                        "[red]Could not find the requested script.[/red]"
+                    )
+                    return
+                routine_text = response.json()["script"]
+                file_path = Path(session.user.preferences.export_directory, "routines")
+                routine_path = file_path / file_name
+                with open(routine_path, "w") as file:
+                    file.write(routine_text)
+                self.update_runtime_choices()
+
+            elif ns_parser.file:
+                file_path = " ".join(ns_parser.file)  # type: ignore
+                # if string is not in this format "default/file.openbb" then check for files in ROUTINE_FILES
+                full_path = file_path
+                hub_routine = file_path.split("/")  # type: ignore
+                # Change with: my.openbb.co
+                if hub_routine[0] == "default":
+                    routine_path = Path(
+                        self.ROUTINE_DEFAULT_FILES.get(hub_routine[1], full_path)
+                    )
+                elif hub_routine[0] == "personal":
+                    routine_path = Path(
+                        self.ROUTINE_PERSONAL_FILES.get(hub_routine[1], full_path)
+                    )
+                else:
+                    routine_path = Path(self.ROUTINE_FILES.get(file_path, full_path))  # type: ignore
+            else:
+                return
+
+            try:
+                with open(routine_path) as fp:
+                    raw_lines = list(fp)
+
+                script_inputs = []
+                # Capture ARGV either as list if args separated by commas or as single value
+                if routine_args := ns_parser.routine_args:
+                    pattern = r"\[(.*?)\]"
+                    matches = re.findall(pattern, routine_args)
+
+                    for match in matches:
+                        routine_args = routine_args.replace(f"[{match}]", "")
+                        script_inputs.append(match)
+
+                    script_inputs.extend(
+                        [val for val in routine_args.split(",") if val]
+                    )
+
+                err, parsed_script = parse_openbb_script(
+                    raw_lines=raw_lines, script_inputs=script_inputs
+                )
+
+                # If there err output is not an empty string then it means there was an
+                # issue in parsing the routine and therefore we don't want to feed it
+                # to the terminal
+                if err:
+                    session.console.print(err)
+                    return
+
+                self.queue = [
+                    val
+                    for val in parse_and_split_input(
+                        an_input=parsed_script, custom_filters=[]
+                    )
+                    if val
+                ]
+
+                if "export" in self.queue[0]:
+                    export_path = self.queue[0].split(" ")[1]
+                    # If the path selected does not start from the user root, give relative location from root
+                    if export_path[0] == "~":
+                        export_path = export_path.replace(
+                            "~", HOME_DIRECTORY.as_posix()
+                        )
+                    elif export_path[0] != "/":
+                        export_path = os.path.join(
+                            os.path.dirname(os.path.abspath(__file__)), export_path
+                        )
+
+                    # Check if the directory exists
+                    if os.path.isdir(export_path):
+                        session.console.print(
+                            f"Export data to be saved in the selected folder: '{export_path}'"
+                        )
+                    else:
+                        os.makedirs(export_path)
+                        session.console.print(
+                            f"[green]Folder '{export_path}' successfully created.[/green]"
+                        )
+                    self.queue = self.queue[1:]
+
+            except FileNotFoundError:
+                session.console.print(
+                    f"[red]File '{routine_path}' doesn't exist.[/red]"
+                )
+                return
+
+
+def handle_job_cmds(jobs_cmds: Optional[List[str]]) -> Optional[List[str]]:
+    """Handle job commands."""
+    export_path = ""
+    if jobs_cmds and "export" in jobs_cmds[0]:
+        commands = jobs_cmds[0].split("/")
+        first_split = commands[0].split(" ")
+        if len(first_split) > 1:
+            export_path = first_split[1]
+        jobs_cmds = ["/".join(commands[1:])]
+    if not export_path:
+        return jobs_cmds
+    if export_path[0] == "~":
+        export_path = export_path.replace("~", HOME_DIRECTORY.as_posix())
+    elif export_path[0] != "/":
+        export_path = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), export_path
+        )
+
+    # Check if the directory exists
+    if os.path.isdir(export_path):
+        session.console.print(
+            f"Export data to be saved in the selected folder: '{export_path}'"
+        )
+    else:
+        os.makedirs(export_path)
+        session.console.print(
+            f"[green]Folder '{export_path}' successfully created.[/green]"
+        )
+    return jobs_cmds
+
+
+# pylint: disable=unused-argument
+def run_cli(jobs_cmds: Optional[List[str]] = None, test_mode=False):
+    """Run the CLI menu."""
+    ret_code = 1
+    t_controller = CLIController(jobs_cmds)
+    an_input = ""
+
+    jobs_cmds = handle_job_cmds(jobs_cmds)
+
+    bootup()
+    if not jobs_cmds:
+        welcome_message()
+
+        if first_time_user():
+            with contextlib.suppress(EOFError):
+                webbrowser.open("https://docs.openbb.co/cli")
+
+        t_controller.print_help()
+
+    while ret_code:
+        # There is a command in the queue
+        if t_controller.queue and len(t_controller.queue) > 0:
+            # If the command is quitting the menu we want to return in here
+            if t_controller.queue[0] in ("q", "..", "quit"):
+                print_goodbye()
+                break
+
+            # Consume 1 element from the queue
+            an_input = t_controller.queue[0]
+            t_controller.queue = t_controller.queue[1:]
+
+            # Print the current location because this was an instruction and we want user to know what was the action
+            if an_input and an_input.split(" ")[0] in t_controller.CHOICES_COMMANDS:
+                session.console.print(f"{get_flair_and_username()} / $ {an_input}")
+
+        # Get input command from user
+        else:
+            try:
+                # Get input from user using auto-completion
+                if session.prompt_session and session.settings.USE_PROMPT_TOOLKIT:
+                    # Check if toolbar hint was enabled
+                    if session.settings.TOOLBAR_HINT:
+                        an_input = session.prompt_session.prompt(  # type: ignore[union-attr]
+                            f"{get_flair_and_username()} / $ ",
+                            completer=t_controller.completer,
+                            search_ignore_case=True,
+                            bottom_toolbar=HTML(
+                                '<style bg="ansiblack" fg="ansiwhite">[h]</style> help menu    '
+                                '<style bg="ansiblack" fg="ansiwhite">[q]</style> return to previous menu    '
+                                '<style bg="ansiblack" fg="ansiwhite">[e]</style> exit the program    '
+                                '<style bg="ansiblack" fg="ansiwhite">[cmd -h]</style> '
+                                "see usage and available options    "
+                            ),
+                            style=Style.from_dict(
+                                {
+                                    "bottom-toolbar": "#ffffff bg:#333333",
+                                }
+                            ),
+                        )
+                    else:
+                        an_input = session.prompt_session.prompt(  # type: ignore[union-attr]
+                            f"{get_flair_and_username()} / $ ",
+                            completer=t_controller.completer,
+                            search_ignore_case=True,
+                        )
+
+                # Get input from user without auto-completion
+                else:
+                    an_input = input(f"{get_flair_and_username()} / $ ")
+
+            except (KeyboardInterrupt, EOFError):
+                print_goodbye()
+                break
+
+        try:
+            # Process the input command
+            t_controller.queue = t_controller.switch(an_input)
+
+            if an_input in ("q", "quit", "..", "exit", "e"):
+                print_goodbye()
+                break
+
+            # Check if the user wants to reset application
+            if an_input in ("r", "reset") or t_controller.update_success:
+                reset(t_controller.queue if t_controller.queue else [])
+                break
+
+        except SystemExit:
+            session.console.print(
+                f"[red]The command '{an_input}' doesn't exist on the / menu.[/red]\n",
+            )
+            similar_cmd = difflib.get_close_matches(
+                an_input.split(" ")[0] if " " in an_input else an_input,
+                t_controller.controller_choices,
+                n=1,
+                cutoff=0.7,
+            )
+            if similar_cmd:
+                an_input = similar_cmd[0]
+                if " " in an_input:
+                    candidate_input = (
+                        f"{similar_cmd[0]} {' '.join(an_input.split(' ')[1:])}"
+                    )
+                    if candidate_input == an_input:
+                        an_input = ""
+                        t_controller.queue = []
+                        session.console.print("\n")
+                        continue
+                    an_input = candidate_input
+
+                session.console.print(f"[green]Replacing by '{an_input}'.[/green]")
+                t_controller.queue.insert(0, an_input)
+
+
+def insert_start_slash(cmds: List[str]) -> List[str]:
+    """Insert a slash at the beginning of a command sequence."""
+    if not cmds[0].startswith("/"):
+        cmds[0] = f"/{cmds[0]}"
+    if cmds[0].startswith("/home"):
+        cmds[0] = f"/{cmds[0][5:]}"
+    return cmds
+
+
+def run_scripts(
+    path: Path,
+    test_mode: bool = False,
+    verbose: bool = False,
+    routines_args: Optional[List[str]] = None,
+    special_arguments: Optional[Dict[str, str]] = None,
+    output: bool = True,
+):
+    """Run given .openbb scripts.
+
+    Parameters
+    ----------
+    path : str
+        The location of the .openbb file
+    test_mode : bool
+        Whether the CLI is in test mode
+    verbose : bool
+        Whether to run tests in verbose mode
+    routines_args : List[str]
+        One or multiple inputs to be replaced in the routine and separated by commas.
+        E.g. GME,AMC,BTC-USD
+    special_arguments: Optional[Dict[str, str]]
+        Replace `${key=default}` with `value` for every key in the dictionary
+    output: bool
+        Whether to log tests to txt files
+    """
+    if not path.exists():
+        session.console.print(f"File '{path}' doesn't exist. Launching base CLI.\n")
+        if not test_mode:
+            run_cli()
+
+    # THIS NEEDS TO BE REFACTORED!!! - ITS USED FOR TESTING
+    with path.open() as fp:
+        raw_lines = [x for x in fp if (not is_reset(x)) and ("#" not in x) and x]
+        raw_lines = [
+            raw_line.strip("\n") for raw_line in raw_lines if raw_line.strip("\n")
+        ]
+
+        if routines_args:
+            lines = []
+            for rawline in raw_lines:
+                templine = rawline
+                for i, arg in enumerate(routines_args):
+                    templine = templine.replace(f"$ARGV[{i}]", arg)
+                lines.append(templine)
+        # Handle new testing arguments:
+        elif special_arguments:
+            lines = []
+            for line in raw_lines:
+                new_line = re.sub(
+                    r"\${[^{]+=[^{]+}",
+                    lambda x: replace_dynamic(x, special_arguments),  # type: ignore
+                    line,
+                )
+                lines.append(new_line)
+
+        else:
+            lines = raw_lines
+
+        if test_mode and "exit" not in lines[-1]:
+            lines.append("exit")
+
+        # Deals with the export with a path with "/" in it
+        export_folder = ""
+        if "export" in lines[0]:
+            export_folder = lines[0].split("export ")[1].rstrip()
+            lines = lines[1:]
+
+        simulate_argv = f"/{'/'.join([line.rstrip() for line in lines])}"
+        file_cmds = simulate_argv.replace("//", "/home/").split()
+        file_cmds = insert_start_slash(file_cmds) if file_cmds else file_cmds
+        file_cmds = (
+            [f"export {export_folder}{' '.join(file_cmds)}"]
+            if export_folder
+            else [" ".join(file_cmds)]
+        )
+
+        if not test_mode or verbose:
+            run_cli(file_cmds, test_mode=True)
+        else:
+            with suppress_stdout():
+                session.console.print(f"To ensure: {output}")
+                if output:
+                    timestamp = datetime.now().timestamp()
+                    stamp_str = str(timestamp).replace(".", "")
+                    whole_path = Path(REPOSITORY_DIRECTORY / "integration_test_output")
+                    whole_path.mkdir(parents=True, exist_ok=True)
+                    first_cmd = file_cmds[0].split("/")[1]
+                    with open(
+                        whole_path / f"{stamp_str}_{first_cmd}_output.txt", "w"
+                    ) as output_file, contextlib.redirect_stdout(output_file):
+                        run_cli(file_cmds, test_mode=True)
+                else:
+                    run_cli(file_cmds, test_mode=True)
+
+
+def replace_dynamic(match: re.Match, special_arguments: Dict[str, str]) -> str:
+    """Replace ${key=default} with value in special_arguments if it exists, else with default.
+
+    Parameters
+    ----------
+    match: re.Match[str]
+        The match object
+    special_arguments: Dict[str, str]
+        The key value pairs to replace in the scripts
+
+    Returns
+    ----------
+    str
+        The new string
+    """
+    cleaned = match[0].replace("{", "").replace("}", "").replace("$", "")
+    key, default = cleaned.split("=")
+    dict_value = special_arguments.get(key, default)
+    if dict_value:
+        return dict_value
+    return default
+
+
+def run_routine(file: str, routines_args=Optional[str]):
+    """Execute command routine from .openbb file."""
+    user_routine_path = Path(session.user.preferences.export_directory, "routines")
+    default_routine_path = ASSETS_DIRECTORY / "routines" / file
+
+    if user_routine_path.exists():
+        run_scripts(path=user_routine_path, routines_args=routines_args)
+    elif default_routine_path.exists():
+        run_scripts(path=default_routine_path, routines_args=routines_args)
+    else:
+        session.console.print(
+            f"Routine not found, please put your `.openbb` file into : {user_routine_path}."
+        )
+
+
+# pylint: disable=unused-argument
+def main(
+    debug: bool,
+    dev: bool,
+    path_list: List[str],
+    routines_args: Optional[List[str]] = None,
+    **kwargs,
+):
+    """Run the CLI with various options.
+
+    Parameters
+    ----------
+    debug : bool
+        Whether to run the CLI in debug mode
+    dev:
+        Points backend towards development environment instead of production
+    test : bool
+        Whether to run the CLI in integrated test mode
+    filtert : str
+        Filter test files with given string in name
+    paths : List[str]
+        The paths to run for scripts or to test
+    verbose : bool
+        Whether to show output from tests
+    routines_args : List[str]
+        One or multiple inputs to be replaced in the routine and separated by commas.
+        E.g. GME,AMC,BTC-USD
+    """
+    if debug:
+        session.settings.DEBUG_MODE = True
+
+    if dev:
+        session.settings.DEV_BACKEND = True
+        session.settings.BASE_URL = "https://payments.openbb.dev/"
+        session.settings.HUB_URL = "https://my.openbb.dev"
+
+    if isinstance(path_list, list) and path_list[0].endswith(".openbb"):
+        run_routine(file=path_list[0], routines_args=routines_args)
+    elif path_list:
+        argv_cmds = list([" ".join(path_list).replace(" /", "/home/")])
+        argv_cmds = insert_start_slash(argv_cmds) if argv_cmds else argv_cmds
+        run_cli(argv_cmds)
+    else:
+        run_cli()
+
+
+def parse_args_and_run():
+    """Parse input arguments and run CLI."""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        prog="cli",
+        description="The OpenBB Platform CLI.",
+    )
+    parser.add_argument(
+        "-d",
+        "--debug",
+        dest="debug",
+        action="store_true",
+        default=False,
+        help="Runs the CLI in debug mode.",
+    )
+    parser.add_argument(
+        "--dev",
+        dest="dev",
+        action="store_true",
+        default=False,
+        help="Points backend towards development environment instead of production",
+    )
+    parser.add_argument(
+        "--file",
+        help="The path or .openbb file to run.",
+        dest="path",
+        nargs="+",
+        default="",
+        type=str,
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        help=(
+            "Select multiple inputs to be replaced in the routine and separated by commas."
+            "E.g. GME,AMC,BTC-USD"
+        ),
+        dest="routine_args",
+        type=lambda s: [str(item) for item in s.split(",")],
+        default=None,
+    )
+    parser.add_argument(
+        "-t",
+        "--test",
+        action="store_true",
+        help=(
+            "Run the CLI in testing mode. Also run this option and '-h'"
+            " to see testing argument options."
+        ),
+    )
+    # The args -m, -f and --HistoryManager.hist_file are used only in reports menu
+    # by papermill and that's why they have suppress help.
+    parser.add_argument(
+        "-m",
+        help=argparse.SUPPRESS,
+        dest="module",
+        default="",
+        type=str,
+    )
+    parser.add_argument(
+        "-f",
+        help=argparse.SUPPRESS,
+        dest="module_file",
+        default="",
+        type=str,
+    )
+    parser.add_argument(
+        "--HistoryManager.hist_file",
+        help=argparse.SUPPRESS,
+        dest="module_hist_file",
+        default="",
+        type=str,
+    )
+    if sys.argv[1:] and "-" not in sys.argv[1][0]:
+        sys.argv.insert(1, "--file")
+    ns_parser, unknown = parser.parse_known_args()
+
+    # This ensures that if cli.py receives unknown args it will not start.
+    # Use -d flag if you want to see the unknown args.
+    if unknown:
+        if ns_parser.debug:
+            session.console.print(unknown)
+        else:
+            sys.exit(-1)
+
+    main(
+        ns_parser.debug,
+        ns_parser.dev,
+        ns_parser.path,
+        ns_parser.routine_args,
+        module=ns_parser.module,
+        module_file=ns_parser.module_file,
+        module_hist_file=ns_parser.module_hist_file,
+    )
+
+
+def launch(
+    debug: bool = False, dev: bool = False, queue: Optional[List[str]] = None
+) -> None:
+    """Launch CLI."""
+    if queue:
+        main(debug, dev, queue, module="")
+    else:
+        parse_args_and_run()
+
+
+if __name__ == "__main__":
+    parse_args_and_run()

cli/openbb_cli/controllers/hub_service.py

@@ -0,0 +1,107 @@
+"""Routines handler module."""
+
+from typing import Optional
+
+import requests
+from openbb_cli.config.constants import (
+    CONNECTION_ERROR_MSG,
+    CONNECTION_TIMEOUT_MSG,
+    TIMEOUT,
+)
+from openbb_cli.session import Session
+
+# created dictionaries for personal and default routines with the structure
+# {"file_name" :["script","personal/default"]}
+# and stored dictionaries in list
+# created new directory structure to account for personal and default routines
+
+
+session = Session()
+
+
+# pylint: disable=too-many-arguments
+def upload_routine(
+    auth_header: str,
+    name: str = "",
+    description: str = "",
+    routine: str = "",
+    override: bool = False,
+    tags: str = "",
+    public: bool = False,
+    timeout: int = TIMEOUT,
+) -> Optional[requests.Response]:
+    """Send a routine to the server.
+
+    Parameters
+    ----------
+    auth_header : str
+        The authorization header, e.g. "Bearer <token>".
+    name : str
+        The name of the routine.
+    routine : str
+        The routine.
+    override : bool
+        Whether to override the routine if it already exists.
+    tags : str
+        The tags of the routine.
+    public : bool
+        Whether to make the routine public or not.
+    timeout : int
+        The timeout, by default TIMEOUT
+
+    Returns
+    -------
+    Optional[requests.Response]
+        The response from the post request.
+    """
+    data = {
+        "name": name,
+        "description": description,
+        "script": routine,
+        "override": override,
+        "tags": tags,
+        "version": session.settings.VERSION,
+        "public": public,
+    }
+    _console = session.console
+    try:
+        response = requests.post(
+            headers={"Authorization": auth_header},
+            url=session.settings.BASE_URL + "/terminal/script",
+            json=data,
+            timeout=timeout,
+        )
+        if response.status_code == 200:
+            username = getattr(session.user.profile.hub_session, "username", None)
+            if not username:
+                _console.print("[red]No username found.[/red]")
+                _console.print("[red]Failed to upload your routine.[/red]")
+                return None
+            _console.print("[green]Successfully uploaded your routine.[/]")
+
+            hub_url = session.settings.HUB_URL
+
+            if public:
+                _console.print(
+                    f"\n[yellow]Share or edit it at {hub_url}/u/{username}/routine/{name.replace(' ', '-')}[/]"
+                )
+            else:
+                _console.print(f"\n[yellow]Go to {hub_url} to edit this script,[/]")
+                _console.print(
+                    f"[yellow]or even make it public so you can access it at "
+                    f"{hub_url}/u/{username}/routine/{name.replace(' ', '-')}[/]"
+                )
+        elif response.status_code != 409:  # 409: routine already exists
+            _console.print(
+                "[red]" + response.json().get("detail", "Unknown error.") + "[/red]"
+            )
+        return response
+    except requests.exceptions.ConnectionError:
+        _console.print(f"\n{CONNECTION_ERROR_MSG}")
+        return None
+    except requests.exceptions.Timeout:
+        _console.print(f"\n{CONNECTION_TIMEOUT_MSG}")
+        return None
+    except Exception:
+        _console.print("[red]Failed to upload your routine.[/red]")
+        return None

cli/openbb_cli/controllers/platform_controller_factory.py

@@ -0,0 +1,58 @@
+"""Platform controller factory to create a platform controller."""
+
+from typing import Dict, List, Union
+
+from openbb_cli.argparse_translator.argparse_class_processor import (
+    ArgparseClassProcessor,
+)
+from openbb_cli.controllers.base_platform_controller import PlatformController
+
+
+class PlatformControllerFactory:
+    """Factory to create a platform controller."""
+
+    def __init__(self, platform_router: type, **kwargs):
+        """Create the controller name."""
+        self.platform_router = platform_router
+        self._translated_target = ArgparseClassProcessor(
+            target_class=self.platform_router, reference=kwargs.get("reference", {})
+        )
+        self.router_name = (
+            str(type(self.platform_router))
+            .rsplit(".", maxsplit=1)[-1]
+            .replace("'>", "")
+            .replace("ROUTER_", "")
+            .lower()
+        )
+        self.controller_name = f"{self.router_name.capitalize()}Controller"
+
+    def create(self) -> type:
+        """Create the platform controller."""
+        ClassName = self.controller_name
+        Parents = (PlatformController,)
+        Attributes: Dict[str, Union[bool, List[str]]] = {"CHOICES_GENERATION": True}
+
+        # Menu and Command choices generation
+        choices_menus: List[str] = []
+        choices_commands: List[str] = []
+        translators = self._translated_target.translators
+        paths = self._translated_target.paths
+        # menus
+        for key, value in paths.items():
+            if value == "path":
+                continue
+            choices_menus.append(key)
+        # commands
+        for name, _ in translators.items():
+            if any(f"{self.router_name}_{path}" in name for path in paths):
+                continue
+            new_name = name.replace(f"{self.router_name}_", "")
+            choices_commands.append(new_name)
+
+        Attributes["CHOICES_MENUS"] = choices_menus
+        Attributes["CHOICES_COMMANDS"] = choices_commands
+
+        # Use type to create the class
+        DynamicClass = type(ClassName, Parents, Attributes)
+
+        return DynamicClass

cli/openbb_cli/controllers/script_parser.py

@@ -0,0 +1,488 @@
+"""Routine functions for OpenBB Platform CLI."""
+
+import re
+from datetime import datetime, timedelta
+from typing import Dict, List, Match, Optional, Tuple, Union
+
+from dateutil.relativedelta import relativedelta
+from openbb_cli.session import Session
+
+session = Session()
+
+# pylint: disable=too-many-statements,eval-used,consider-iterating-dictionary
+# pylint: disable=too-many-branches,too-many-return-statements
+
+# Necessary for OpenBB keywords
+MONTHS_VALUE = {
+    "JANUARY": 1,
+    "FEBRUARY": 2,
+    "MARCH": 3,
+    "APRIL": 4,
+    "MAY": 5,
+    "JUNE": 6,
+    "JULY": 7,
+    "AUGUST": 8,
+    "SEPTEMBER": 9,
+    "OCTOBER": 10,
+    "NOVEMBER": 11,
+    "DECEMBER": 12,
+}
+
+WEEKDAY_VALUE = {
+    "MONDAY": 0,
+    "TUESDAY": 1,
+    "WEDNESDAY": 2,
+    "THURSDAY": 3,
+    "FRIDAY": 4,
+    "SATURDAY": 5,
+    "SUNDAY": 6,
+}
+
+
+def is_reset(command: str) -> bool:
+    """Test whether a command is a reset command.
+
+    Parameters
+    ----------
+    command : str
+        The command to test
+
+    Returns
+    -------
+    answer : bool
+        Whether the command is a reset command
+    """
+    if "reset" in command:
+        return True
+    if command == "r":
+        return True
+    if command == "r\n":
+        return True
+    return False
+
+
+def match_and_return_openbb_keyword_date(keyword: str) -> str:  # noqa: PLR0911
+    """Return OpenBB keyword into date.
+
+    Parameters
+    ----------
+    keyword : str
+        String with potential OpenBB keyword (e.g. 1MONTHAGO,LASTFRIDAY,3YEARSFROMNOW,NEXTTUESDAY)
+
+    Returns
+    ----------
+        str: Date with format YYYY-MM-DD
+    """
+    now = datetime.now()
+    for i, regex in enumerate([r"^\$(\d+)([A-Z]+)AGO$", r"^\$(\d+)([A-Z]+)FROMNOW$"]):
+        match = re.match(regex, keyword)
+        if match:
+            integer_value = int(match.group(1))
+            time_unit = match.group(2)
+            clean_time = time_unit.upper()
+            if "DAYS" in clean_time or "MONTHS" in clean_time or "YEARS" in clean_time:
+                kwargs = {time_unit.lower(): integer_value}
+                if i == 0:
+                    return (now - relativedelta(**kwargs)).strftime("%Y-%m-%d")  # type: ignore
+                return (now + relativedelta(**kwargs)).strftime("%Y-%m-%d")  # type: ignore
+
+    match = re.search(r"\$LAST(\w+)", keyword)
+    if match:
+        time_unit = match.group(1)
+        # Check if it corresponds to a month
+        if time_unit in list(MONTHS_VALUE.keys()):
+            the_year = now.year
+            # Calculate the year and month for last month date
+            if now.month <= MONTHS_VALUE[time_unit]:
+                # If the current month is greater than the last date month, it means it is this year
+                the_year = now.year - 1
+            return datetime(the_year, MONTHS_VALUE[time_unit], 1).strftime("%Y-%m-%d")
+
+        # Check if it corresponds to a week day
+        if time_unit in list(WEEKDAY_VALUE.keys()):
+            if datetime.weekday(now) > WEEKDAY_VALUE[time_unit]:
+                return (
+                    now
+                    - timedelta(datetime.weekday(now))
+                    + timedelta(WEEKDAY_VALUE[time_unit])
+                ).strftime("%Y-%m-%d")
+            return (
+                now
+                - timedelta(7)
+                - timedelta(datetime.weekday(now))
+                + timedelta(WEEKDAY_VALUE[time_unit])
+            ).strftime("%Y-%m-%d")
+
+    match = re.search(r"\$NEXT(\w+)", keyword)
+    if match:
+        time_unit = match.group(1)
+        # Check if it corresponds to a month
+        if time_unit in list(MONTHS_VALUE.keys()):
+            # Calculate the year and month for next month date
+            if now.month < MONTHS_VALUE[time_unit]:
+                # If the current month is greater than the last date month, it means it is this year
+                return datetime(now.year, MONTHS_VALUE[time_unit], 1).strftime(
+                    "%Y-%m-%d"
+                )
+
+            return datetime(now.year + 1, MONTHS_VALUE[time_unit], 1).strftime(
+                "%Y-%m-%d"
+            )
+
+        # Check if it corresponds to a week day
+        if time_unit in list(WEEKDAY_VALUE.keys()):
+            if datetime.weekday(now) < WEEKDAY_VALUE[time_unit]:
+                return (
+                    now
+                    - timedelta(datetime.weekday(now))
+                    + timedelta(WEEKDAY_VALUE[time_unit])
+                ).strftime("%Y-%m-%d")
+            return (
+                now
+                + timedelta(7)
+                - timedelta(datetime.weekday(now))
+                + timedelta(WEEKDAY_VALUE[time_unit])
+            ).strftime("%Y-%m-%d")
+
+    return ""
+
+
+def parse_openbb_script(  # noqa: PLR0911,PLR0912
+    raw_lines: List[str],
+    script_inputs: Optional[List[str]] = None,
+) -> Tuple[str, str]:
+    """Parse .openbb script.
+
+    Parameters
+    ----------
+    raw_lines : List[str]
+        Lines from .openbb script
+    script_inputs: str, optional
+        Inputs to the script that come externally
+
+    Returns
+    -------
+    str
+        Error that occurred - if empty means no error
+    str
+        Processed string from .openbb script that can be run by the OpenBB Platform CLI
+    """
+    ROUTINE_VARS: Dict[str, Union[str, List[str]]] = dict()
+    if script_inputs:
+        ROUTINE_VARS["$ARGV"] = script_inputs
+
+    ## PRE PROCESSING
+    # Remove reset commands, comments, empty lines and trailing/leading whitespaces
+    raw_lines = [
+        x.strip()
+        for x in raw_lines
+        if (not is_reset(x)) and ("#" not in x) and x.strip()
+    ]
+
+    ## LOOK FOR NEW VARIABLES BEING DECLARED FROM USERS
+    lines_without_declarations = list()
+    for line in raw_lines:
+        # Check if this line has a variable attribution
+        # This currently allows user to override ARGV parameter
+        if "$" in line and "=" in line:
+            match = re.search(r"\$(\w+)\s*=\s*([\w\d,-.\s]+)", line)
+            if match:
+                VAR_NAME = match.group(1)
+                VAR_VALUES = match.group(2)
+                ROUTINE_VARS["$" + VAR_NAME] = (
+                    VAR_VALUES if "," not in VAR_VALUES else VAR_VALUES.split(",")
+                )
+
+                # Just throw a warning when user uses wrong convention
+                numdollars = len(re.findall(r"\$", line))
+                if numdollars > 1:
+                    session.console.print(
+                        f"The variable {VAR_NAME} should not be declared as "
+                        f"{'$' * numdollars}{VAR_NAME}. Instead it will be "
+                        f"converted into ${VAR_NAME}."
+                    )
+
+            else:
+                lines_without_declarations.append(line)
+        else:
+            lines_without_declarations.append(line)
+
+    # At this stage our ROUTINE_VARS should be completed coming from external AND from internal
+    # Now we want to replace the ROUTINE_VARS to where applicable throughout the .openbb script
+    # Due to this implementation, a variable declared at the end will still be effective
+
+    lines_with_vars_replaced = list()
+    foreach_loop_found = False
+    for line in lines_without_declarations:
+        # Save temporary line to ensure that all vars get replaced by correct vars
+        templine = line
+
+        # Found 'end' keyword which means that a loop has terminated
+        if re.match(r"^\s*end\s*$", line, re.IGNORECASE):
+            # Check whether the foreach loop has started or not
+            if not foreach_loop_found:
+                return (
+                    "[red]The script has a foreach loop that terminates before it gets started. "
+                    "Add the keyword 'foreach' to explicitly start loop[/red]",
+                    "",
+                )
+            foreach_loop_found = False
+
+        else:
+            # Found 'foreach' keyword which means there needs to be a matching 'end'
+            if re.search(r"foreach", line, re.IGNORECASE):
+                foreach_loop_found = True
+
+            # Regular expression pattern to match variables starting with $
+            pattern = r"(?<!\$)(\$(\w+)(\[[^\]]*\])?)(?=(?:[^\]]*\]*))"
+
+            # Find all matches of the pattern in the line
+            matches: Optional[List[Match[str]]] = re.findall(pattern, line)
+
+            if matches:
+                for match in matches:
+                    if match:
+                        VAR_NAME = "$" + match[1]
+                        VAR_SLICE = match[2][1:-1] if match[2] else ""
+
+                        # Within a list refers to a single element
+                        if VAR_SLICE.isdigit():
+                            # This is an edge case for when the user has a variable such as $DATE = 2022-01-01
+                            # We want the user to be able to access it with $DATE or $DATE[0] and the latest
+                            # in python will only take the first '2'
+                            if VAR_SLICE == "0":
+                                if VAR_NAME in ROUTINE_VARS:
+                                    values = eval(  # noqa: S307
+                                        f'ROUTINE_VARS["{VAR_NAME}"]'
+                                    )
+                                    if isinstance(values, list):
+                                        templine = templine.replace(
+                                            match[0],
+                                            eval(f"values[{VAR_SLICE}]"),  # noqa: S307
+                                        )
+                                    else:
+                                        templine = templine.replace(match[0], values)
+                                else:
+                                    return (
+                                        f"[red]Variable {VAR_NAME} not given "
+                                        "for current routine script.[/red]",
+                                        "",
+                                    )
+
+                            # Only enters here when any other index from 0 is used
+                            elif VAR_NAME in ROUTINE_VARS:
+                                variable = eval(  # noqa: S307
+                                    f'ROUTINE_VARS["{VAR_NAME}"]'
+                                )
+                                length_variable = (
+                                    len(variable) if isinstance(variable, list) else 1
+                                )
+
+                                # We use <= because we are using 0 index based lists
+                                if length_variable <= int(VAR_SLICE):
+                                    return (
+                                        f"[red]Variable {VAR_NAME} only has "
+                                        f"{length_variable} elements and there "
+                                        f"was an attempt to access it with index {VAR_SLICE}.[/red]",
+                                        "",
+                                    )
+                                templine = templine.replace(
+                                    match[0],
+                                    variable[int(VAR_SLICE)],
+                                )
+                            else:
+                                return (
+                                    f"[red]Variable {VAR_NAME} not given for current routine script.[/red]",
+                                    "",
+                                )
+
+                        # Involves slicing which is a bit more tricky to use eval on
+                        elif (
+                            ":" in VAR_SLICE
+                            and len(VAR_SLICE.split(":")) == 2
+                            and (
+                                VAR_SLICE.split(":")[0].isdigit()
+                                or VAR_SLICE.split(":")[1].isdigit()
+                            )
+                        ):
+                            slicing_tuple = "slice("
+                            slicing_tuple += (
+                                VAR_SLICE.split(":")[0]
+                                if VAR_SLICE.split(":")[0].isdigit()
+                                else "None"
+                            )
+                            slicing_tuple += ","
+                            slicing_tuple += (
+                                VAR_SLICE.split(":")[1]
+                                if VAR_SLICE.split(":")[1].isdigit()
+                                else "None"
+                            )
+                            slicing_tuple += ")"
+
+                            vars_to_loop = eval(  # noqa: S307
+                                f'ROUTINE_VARS["{VAR_NAME}"][{slicing_tuple}]'
+                            )
+
+                            # Check whether the slicing was successful or not
+                            if vars_to_loop:
+                                templine = templine.replace(
+                                    match[0],
+                                    ",".join(vars_to_loop),
+                                )
+                            else:
+                                return (
+                                    f"[red]The foreach loop cannot run with input: {match[0]}.[/red]",
+                                    "",
+                                )
+
+                        # Just replace value without slicing or list
+                        else:
+                            if VAR_SLICE:
+                                # Check if the string starts with a minus sign
+                                if VAR_SLICE.startswith("-"):
+                                    if not VAR_SLICE[1:].isdigit():
+                                        return (
+                                            f"[red]Index '{VAR_SLICE}' is not a value[/red]",
+                                            "",
+                                        )
+                                    if int(VAR_SLICE) < 0:
+                                        return (
+                                            f"[red]Negative index on {VAR_NAME} is not allowed[/red]",
+                                            "",
+                                        )
+                                if not VAR_SLICE.isdigit():
+                                    return (
+                                        f"[red]Index '{VAR_SLICE}' is not a value[/red]",
+                                        "",
+                                    )
+
+                            if VAR_NAME in ROUTINE_VARS:
+                                value = eval(  # noqa: S307
+                                    f'ROUTINE_VARS["{VAR_NAME}"]'
+                                )
+
+                                # If the value is a list, we want to replace it with the whole list
+                                if isinstance(value, list):
+                                    templine = templine.replace(
+                                        match[0],
+                                        ",".join(value),
+                                    )
+                                else:
+                                    templine = templine.replace(match[0], value)
+
+                            else:
+                                # Check if this is an OpenBB keyword variable like
+                                # 1MONTHAGO,LASTFRIDAY,3YEARSFROMNOW,NEXTTUESDAY
+                                # and decode it into the right date if it exists
+                                potential_date_match = (
+                                    match_and_return_openbb_keyword_date(VAR_NAME)
+                                )
+                                if potential_date_match:
+                                    templine = templine.replace(
+                                        match[0], potential_date_match
+                                    )
+                                else:
+                                    return (
+                                        f"[red]Variable {VAR_NAME} not given for "
+                                        "current routine script.[/red]",
+                                        "",
+                                    )
+
+        lines_with_vars_replaced.append(templine)
+
+    # If this flags ends in True it means that the script routine has a foreach loop that never terminates
+    if foreach_loop_found:
+        return (
+            "[red]The script has a foreach loop that doesn't terminate. "
+            "Add the keyword 'end' to explicitly terminate loop[/red]",
+            "",
+        )
+
+    # Finally the only remaining thing to address are the foreach loops. For that we'll go through
+    # those lines and unroll the arguments that will be iterated by.
+    # Note that the fact that we checked before that the amount of foreach and end matches allow us
+    # to be confident that the script has no clear issues.
+
+    within_foreach = False
+    foreach_lines_loop: List[str] = list()
+
+    parsed_script = ""
+    final_lines = list()
+    varname = "VAR"
+    varused_inside = False
+    for line in lines_with_vars_replaced:
+        # Found 'foreach' header associated with loop
+        match = re.search(
+            r"foreach \$\$([A-Za-z\_]+) in ([A-Za-z0-9,-.]+)", line, re.IGNORECASE
+        )
+        if match:
+            varname = match.group(1)
+            foreach_loop = match.group(2).split(",")
+            within_foreach = True
+
+        # We are inside a loop and this is a line that we will want to replicate,
+        # so we need to temporarily store it until we reach the end
+        elif within_foreach:
+            # Found 'end' keyword which means that the foreach loop has reached the end
+            if re.match(r"^\s*end\s*$", line, re.IGNORECASE):
+                # Now we want to process what we were waiting for before
+
+                # Iterate through main foreach header
+                for var in foreach_loop:
+                    # Iterate through all lines within foreach and end loop
+                    for foreach_line_loop in foreach_lines_loop:
+                        if f"$${varname}" in foreach_line_loop:
+                            final_lines.append(
+                                foreach_line_loop.replace(f"$${varname}", var).strip()
+                            )
+                            varused_inside = True
+                        elif "$$" in foreach_line_loop:
+                            return (
+                                "[red]The script has a foreach loop that iterates through "
+                                f"{','.join(foreach_loop)} with variable $${varname} "
+                                "but another var name is being utilized instead[/red]",
+                                "",
+                            )
+                        else:
+                            final_lines.append(foreach_line_loop.strip())
+
+                if not varused_inside:
+                    session.console.print(
+                        f"The variable {varname} was used in foreach header "
+                        "but it wasn't used inside the loop."
+                    )
+                    varused_inside = False
+
+                # Since this has been processed we reset the foreach loop lines
+                within_foreach = False
+                foreach_lines_loop = list()
+
+            else:
+                foreach_lines_loop.append(line)
+
+        else:
+            final_lines.append(line)
+
+    # If the list is non null, then we want to convert this into a parsed string that is
+    # recognized by the OpenBB Platform CLI
+    if final_lines:
+        parsed_script = f"{'/'.join([line.rstrip() for line in final_lines])}".replace(
+            "//", "/home/"
+        )
+        if parsed_script[0] == "/":
+            # If the user had added a / at the beginning, then it was converted to //home/
+            # and we need to remove it
+            if parsed_script.startswith("//home"):
+                parsed_script = parsed_script[6:]
+        else:
+            # We want the script to start from the home menu, hence we add it if the user
+            # didn't add it
+            parsed_script = "/" + parsed_script
+
+        # If the script finishes with // it means that we converted it to /home/
+        # This means that we are expecting a command to follow, but since this is
+        # the end of the script, we need to remove the trailing /
+        if parsed_script.endswith("/home/"):
+            parsed_script = parsed_script[:-1]
+
+    return "", parsed_script

cli/openbb_cli/controllers/settings_controller.py

@@ -0,0 +1,142 @@
+"""Settings Controller Module."""
+
+import argparse
+from functools import partial, update_wrapper
+from types import MethodType
+from typing import List, Literal, Optional, get_origin
+
+from openbb_cli.config.menu_text import MenuText
+from openbb_cli.controllers.base_controller import BaseController
+from openbb_cli.models.settings import SettingGroups
+from openbb_cli.session import Session
+
+session = Session()
+
+
+class SettingsController(BaseController):
+    """Settings Controller class."""
+
+    _COMMANDS = {
+        v.json_schema_extra.get("command"): {
+            "command": (v.json_schema_extra or {}).get("command"),
+            "group": (v.json_schema_extra or {}).get("group"),
+            "description": v.description,
+            "annotation": v.annotation,
+            "field_name": k,
+        }
+        for k, v in sorted(
+            session.settings.model_fields.items(),
+            key=lambda item: (item[1].json_schema_extra or {}).get("command", ""),
+        )
+        if v.json_schema_extra
+    }
+    CHOICES_COMMANDS: List[str] = list(_COMMANDS.keys())
+    PATH = "/settings/"
+    CHOICES_GENERATION = True
+
+    def __init__(self, queue: Optional[List[str]] = None):
+        """Initialize the Constructor."""
+        super().__init__(queue)
+        for cmd, field in self._COMMANDS.items():
+            group = field.get("group")
+            if group == SettingGroups.feature_flags:
+                self._generate_command(cmd, field, "toggle")
+            elif group == SettingGroups.preferences:
+                self._generate_command(cmd, field, "set")
+        self.update_completer(self.choices_default)
+
+    def print_help(self):
+        """Print help."""
+        mt = MenuText("settings/")
+        mt.add_info("Feature Flags")
+        for k, f in self._COMMANDS.items():
+            if f.get("group") == SettingGroups.feature_flags:
+                mt.add_setting(
+                    name=k,
+                    status=getattr(session.settings, f["field_name"]),
+                    description=f["description"],
+                )
+        mt.add_raw("\n")
+        mt.add_info("Preferences")
+        for k, f in self._COMMANDS.items():
+            if f.get("group") == SettingGroups.preferences:
+                mt.add_cmd(
+                    name=k,
+                    description=f["description"],
+                )
+        session.console.print(text=mt.menu_text, menu="Settings")
+
+    def _generate_command(
+        self, cmd_name: str, field: dict, action_type: Literal["toggle", "set"]
+    ):
+        """Generate command call."""
+
+        def _toggle(self, other_args: List[str], field=field) -> None:
+            """Toggle setting value."""
+            field_name = field["field_name"]
+            parser = argparse.ArgumentParser(
+                formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                prog=field["command"],
+                description=field["description"],
+                add_help=False,
+            )
+            ns_parser, _ = self.parse_simple_args(parser, other_args)
+            if ns_parser:
+                session.settings.set_item(
+                    field_name, not getattr(session.settings, field_name)
+                )
+
+        def _set(self, other_args: List[str], field=field) -> None:
+            """Set preference value."""
+            field_name = field["field_name"]
+            annotation = field["annotation"]
+            command = field["command"]
+            type_ = str if get_origin(annotation) is Literal else annotation
+            choices = None
+            if get_origin(annotation) is Literal:
+                choices = annotation.__args__
+            elif command == "console_style":
+                # To have updated choices for console style
+                choices = session.style.available_styles
+            parser = argparse.ArgumentParser(
+                formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                prog=command,
+                description=field["description"],
+                add_help=False,
+            )
+            parser.add_argument(
+                "-v",
+                "--value",
+                dest="value",
+                action="store",
+                required=False,
+                type=type_,  # type: ignore[arg-type]
+                choices=choices,
+            )
+            ns_parser, _ = self.parse_simple_args(parser, other_args)
+            if ns_parser:
+                if ns_parser.value:
+                    # Console style is applied immediately
+                    if command == "console_style":
+                        session.style.apply(ns_parser.value)
+                    session.settings.set_item(field_name, ns_parser.value)
+                    session.console.print(
+                        f"[info]Current value:[/info] {getattr(session.settings, field_name)}"
+                    )
+                elif not other_args:
+                    session.console.print(
+                        f"[info]Current value:[/info] {getattr(session.settings, field_name)}"
+                    )
+
+        action = None
+        if action_type == "toggle":
+            action = _toggle
+        elif action_type == "set":
+            action = _set
+        else:
+            raise ValueError(f"Action type '{action_type}' not allowed.")
+
+        bound_method = update_wrapper(
+            wrapper=partial(MethodType(action, self), field=field), wrapped=action
+        )
+        setattr(self, f"call_{cmd_name}", bound_method)

cli/openbb_cli/controllers/utils.py

@@ -0,0 +1,1032 @@
+"""Utils."""
+
+import argparse
+import os
+import random
+import re
+import shutil
+import sys
+from contextlib import contextmanager
+from datetime import (
+    datetime,
+)
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import requests
+from openbb_cli.config.constants import AVAILABLE_FLAIRS, ENV_FILE_SETTINGS
+from openbb_cli.session import Session
+from openbb_core.app.model.obbject import OBBject
+from pytz import all_timezones, timezone
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from openbb_charting.core.openbb_figure import OpenBBFigure
+
+# pylint: disable=R1702,R0912
+
+
+# pylint: disable=too-many-statements,no-member,too-many-branches,C0302
+
+session = Session()
+
+
+def remove_file(path: Path) -> bool:
+    """Remove path.
+
+    Parameters
+    ----------
+    path : Path
+        The file path.
+
+    Returns
+    -------
+    bool
+        The status of the removal.
+    """
+    # TODO: Check why module level import leads to circular import.
+    try:
+        if os.path.isfile(path):
+            os.remove(path)
+        elif os.path.isdir(path):
+            shutil.rmtree(path)
+        return True
+    except Exception:
+        session.console.print(
+            f"\n[bold red]Failed to remove {path}"
+            "\nPlease delete this manually![/bold red]"
+        )
+        return False
+
+
+def print_goodbye():
+    """Print a goodbye message when quitting the terminal."""
+    # LEGACY GOODBYE MESSAGES - You'll live in our hearts forever.
+    # "An informed ape, is a strong ape."
+    # "Remember that stonks only go up."
+    # "Diamond hands."
+    # "Apes together strong."
+    # "This is our way."
+    # "Keep the spacesuit ape, we haven't reached the moon yet."
+    # "I am not a cat. I'm an ape."
+    # "We like the terminal."
+    # "...when offered a flight to the moon, nobody asks about what seat."
+
+    text = """
+[param]Thank you for using the OpenBB Platform CLI and being part of this journey.[/param]
+
+We hope you'll find the new OpenBB Platform CLI a valuable tool.
+
+To stay tuned, sign up for our newsletter: [cmds]https://openbb.co/newsletter.[/]
+
+Please feel free to check out our other products:
+
+[bold]OpenBB Workspace[/]:    [cmds]https://openbb.co[/cmds]
+[bold]OpenBB Platform:[/]     [cmds]https://docs.openbb.co/platform[/cmds]
+[bold]OpenBB Bot[/]:          [cmds]https://docs.openbb.co/bot[/cmds]
+    """
+    session.console.print(text)
+
+
+def print_guest_block_msg():
+    """Block guest users from using the cli."""
+    if session.is_local():
+        session.console.print(
+            "[info]You are currently logged as a guest.[/info]\n"
+            "[info]Login to use this feature.[/info]\n\n"
+            "[info]If you don't have an account, you can create one here: [/info]"
+            f"[cmds]{session.settings.HUB_URL + '/register'}\n[/cmds]"
+        )
+
+
+def bootup():
+    """Bootup the cli."""
+    if sys.platform == "win32":
+        # Enable VT100 Escape Sequence for WINDOWS 10 Ver. 1607
+        os.system("")  # nosec # noqa: S605,S607
+
+    try:
+        if os.name == "nt":
+            # pylint: disable=E1101
+            sys.stdin.reconfigure(encoding="utf-8")  # type: ignore
+            # pylint: disable=E1101
+            sys.stdout.reconfigure(encoding="utf-8")  # type: ignore
+    except Exception as e:
+        session.console.print(e, "\n")
+
+
+def welcome_message():
+    """Print the welcome message.
+
+    Prints first welcome message, help and a notification if updates are available.
+    """
+    session.console.print(
+        f"\nWelcome to OpenBB Platform CLI v{session.settings.VERSION}"
+    )
+
+
+def reset(queue: Optional[List[str]] = None):
+    """Reset the CLI.
+
+    Allows for checking code without quitting.
+    """
+    session.console.print("resetting...")
+    debug = session.settings.DEBUG_MODE
+    dev = session.settings.DEV_BACKEND
+
+    try:
+        # remove the hub routines
+        if not session.is_local():
+            remove_file(
+                Path(session.user.preferences.export_directory, "routines", "hub")
+            )
+
+            # if not get_current_user().profile.remember:
+            #     Local.remove(HIST_FILE_PROMPT)
+
+        # we clear all openbb_cli modules from sys.modules
+        for module in list(sys.modules.keys()):
+            parts = module.split(".")
+            if parts[0] == "openbb_cli":
+                del sys.modules[module]
+
+        queue_list = ["/".join(queue) if len(queue) > 0 else ""]  # type: ignore
+        # pylint: disable=import-outside-toplevel
+        # we run the cli again
+        if session.is_local():
+            from openbb_cli.controllers.cli_controller import main
+
+            main(debug, dev, queue_list, module="")  # type: ignore
+        else:
+            from openbb_cli.controllers.cli_controller import launch
+
+            launch(queue=queue_list)
+
+    except Exception as e:
+        session.console.print(f"Unfortunately, resetting wasn't possible: {e}\n")
+        print_goodbye()
+
+
+@contextmanager
+def suppress_stdout():
+    """Suppress the stdout."""
+    with open(os.devnull, "w") as devnull:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = devnull
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+
+def first_time_user() -> bool:
+    """Check whether a user is a first time user.
+
+    A first time user is someone with an empty .env file.
+    If this is true, it also adds an env variable to make sure this does not run again.
+
+    Returns
+    -------
+    bool
+        Whether or not the user is a first time user
+    """
+    if ENV_FILE_SETTINGS.stat().st_size == 0:
+        session.settings.set_item("PREVIOUS_USE", True)
+        return True
+    return False
+
+
+def parse_and_split_input(an_input: str, custom_filters: List) -> List[str]:
+    """Filter and split the input queue.
+
+    Uses regex to filters command arguments that have forward slashes so that it doesn't
+    break the execution of the command queue.
+    Currently handles unix paths and sorting settings for screener menus.
+
+    Parameters
+    ----------
+    an_input : str
+        User input as string
+    custom_filters : List
+        Additional regular expressions to match
+
+    Returns
+    -------
+    List[str]
+        Command queue as list
+    """
+    # Make sure that the user can go back to the root when doing "/"
+    if an_input and an_input == "/":
+        an_input = "home"
+
+    # everything from ` -f ` to the next known extension
+    file_flag = r"(\ -f |\ --file )"
+    up_to = r".*?"
+    known_extensions = r"(\.(xlsx|csv|xls|tsv|json|yaml|ini|openbb|ipynb))"
+    unix_path_arg_exp = f"({file_flag}{up_to}{known_extensions})"
+
+    # Add custom expressions to handle edge cases of individual controllers
+    custom_filter = ""
+    for exp in custom_filters:
+        if exp is not None:
+            custom_filter += f"|{exp}"
+            del exp
+
+    slash_filter_exp = f"({unix_path_arg_exp}){custom_filter}"
+
+    filter_input = True
+    placeholders: Dict[str, str] = {}
+    while filter_input:
+        match = re.search(pattern=slash_filter_exp, string=an_input)
+        if match is not None:
+            placeholder = f"{{placeholder{len(placeholders)+1}}}"
+            placeholders[placeholder] = an_input[
+                match.span()[0] : match.span()[1]  # noqa:E203
+            ]
+            an_input = (
+                an_input[: match.span()[0]]
+                + placeholder
+                + an_input[match.span()[1] :]  # noqa:E203
+            )
+        else:
+            filter_input = False
+
+    commands = an_input.split("/") if "timezone" not in an_input else [an_input]
+
+    for command_num, command in enumerate(commands):
+        if command == commands[-1] == "":
+            return list(filter(None, commands))
+        matching_placeholders = [tag for tag in placeholders if tag in command]
+        if len(matching_placeholders) > 0:
+            for tag in matching_placeholders:
+                commands[command_num] = command.replace(tag, placeholders[tag])
+    return commands
+
+
+def return_colored_value(value: str):
+    """Return the string value based on condition.
+
+    Return it with green, yellow, red or white color based on
+    whether the number is positive, negative, zero or other, respectively.
+
+    Parameters
+    ----------
+    value: str
+        string to be checked
+
+    Returns
+    -------
+    value: str
+        string with color based on value of number if it exists
+    """
+    values = re.findall(r"[-+]?(?:\d*\.\d+|\d+)", value)
+
+    # Finds exactly 1 number in the string
+    if len(values) == 1:
+        if float(values[0]) > 0:
+            return f"[green]{value}[/green]"
+
+        if float(values[0]) < 0:
+            return f"[red]{value}[/red]"
+
+        if float(values[0]) == 0:
+            return f"[yellow]{value}[/yellow]"
+
+    return f"{value}"
+
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+def print_rich_table(  # noqa: PLR0912
+    df: pd.DataFrame,
+    show_index: bool = False,
+    title: str = "",
+    index_name: str = "",
+    headers: Optional[Union[List[str], pd.Index]] = None,
+    floatfmt: Union[str, List[str]] = ".2f",
+    show_header: bool = True,
+    automatic_coloring: bool = False,
+    columns_to_auto_color: Optional[List[str]] = None,
+    rows_to_auto_color: Optional[List[str]] = None,
+    export: bool = False,
+    limit: Optional[int] = 1000,
+    columns_keep_types: Optional[List[str]] = None,
+    use_tabulate_df: bool = True,
+):
+    """Prepare a table from df in rich.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        Dataframe to turn into table
+    show_index: bool
+        Whether to include index
+    title: str
+        Title for table
+    index_name : str
+        Title for index column
+    headers: List[str]
+        Titles for columns
+    floatfmt: Union[str, List[str]]
+        Float number formatting specs as string or list of strings. Defaults to ".2f"
+    show_header: bool
+        Whether to show the header row.
+    automatic_coloring: bool
+        Automatically color a table based on positive and negative values
+    columns_to_auto_color: List[str]
+        Columns to automatically color
+    rows_to_auto_color: List[str]
+        Rows to automatically color
+    export: bool
+        Whether we are exporting the table to a file. If so, we don't want to print it.
+    limit: Optional[int]
+        Limit the number of rows to show.
+    columns_keep_types: Optional[List[str]]
+        Columns to keep their types, i.e. not convert to numeric
+    """
+    if export:
+        return
+
+    MAX_COLS = session.settings.ALLOWED_NUMBER_OF_COLUMNS
+    MAX_ROWS = session.settings.ALLOWED_NUMBER_OF_ROWS
+
+    # Make a copy of the dataframe to avoid SettingWithCopyWarning
+    df = df.copy()
+
+    show_index = not isinstance(df.index, pd.RangeIndex) and show_index
+    #  convert non-str that are not timestamp or int into str
+    # eg) praw.models.reddit.subreddit.Subreddit
+    for col in df.columns:
+        if columns_keep_types is not None and col in columns_keep_types:
+            continue
+        try:
+            if not any(
+                isinstance(df[col].iloc[x], pd.Timestamp)
+                for x in range(min(10, len(df)))
+            ):
+                df[col] = df[col].apply(pd.to_numeric)
+        except (ValueError, TypeError):
+            df[col] = df[col].astype(str)
+
+    def _get_headers(_headers: Union[List[str], pd.Index]) -> List[str]:
+        """Check if headers are valid and return them."""
+        output = _headers
+        if isinstance(_headers, pd.Index):
+            output = list(_headers)
+        if len(output) != len(df.columns):
+            raise ValueError("Length of headers does not match length of DataFrame.")
+        return output  # type: ignore
+
+    if session.settings.USE_INTERACTIVE_DF:
+        df_outgoing = df.copy()
+        # If headers are provided, use them
+        if headers is not None:
+            # We check if headers are valid
+            df_outgoing.columns = _get_headers(headers)
+
+        if show_index and index_name not in df_outgoing.columns:
+            # If index name is provided, we use it
+            df_outgoing.index.name = index_name or "Index"
+            df_outgoing = df_outgoing.reset_index()
+
+        for col in df_outgoing.columns:
+            if col == "":
+                df_outgoing = df_outgoing.rename(columns={col: "  "})
+
+        session._backend.send_table(  # type: ignore  # pylint: disable=protected-access
+            df_table=df_outgoing,
+            title=title,
+            theme=session.user.preferences.table_style,
+        )
+        return
+
+    df = df.copy() if not limit else df.copy().iloc[:limit]
+    if automatic_coloring:
+        if columns_to_auto_color:
+            for col in columns_to_auto_color:
+                # checks whether column exists
+                if col in df.columns:
+                    df[col] = df[col].apply(lambda x: return_colored_value(str(x)))
+        if rows_to_auto_color:
+            for row in rows_to_auto_color:
+                # checks whether row exists
+                if row in df.index:
+                    df.loc[row] = df.loc[row].apply(
+                        lambda x: return_colored_value(str(x))
+                    )
+
+        if columns_to_auto_color is None and rows_to_auto_color is None:
+            df = df.applymap(lambda x: return_colored_value(str(x)))
+
+    exceeds_allowed_columns = len(df.columns) > MAX_COLS
+    exceeds_allowed_rows = len(df) > MAX_ROWS
+
+    if exceeds_allowed_columns:
+        original_columns = df.columns.tolist()
+        trimmed_columns = df.columns.tolist()[:MAX_COLS]
+        df = df[trimmed_columns]
+        trimmed_columns = [
+            col for col in original_columns if col not in trimmed_columns
+        ]
+
+    if exceeds_allowed_rows:
+        n_rows = len(df.index)
+        max_rows = MAX_ROWS
+        df = df[:max_rows]
+        trimmed_rows_count = n_rows - max_rows
+
+    if use_tabulate_df:
+        table = Table(title=title, show_lines=True, show_header=show_header)
+
+        if show_index:
+            table.add_column(index_name)
+
+        if headers is not None:
+            headers = _get_headers(headers)
+            for header in headers:
+                table.add_column(str(header))
+        else:
+            for column in df.columns:
+                table.add_column(str(column))
+
+        if isinstance(floatfmt, list) and len(floatfmt) != len(df.columns):
+            raise (
+                ValueError(
+                    "Length of floatfmt list does not match length of DataFrame columns."
+                )
+            )
+        if isinstance(floatfmt, str):
+            floatfmt = [floatfmt for _ in range(len(df.columns))]
+
+        for idx, values in zip(df.index.tolist(), df.values.tolist()):
+            # remove hour/min/sec from timestamp index - Format: YYYY-MM-DD # make better
+            row_idx = [str(idx)] if show_index else []
+            row_idx += [
+                (
+                    str(x)
+                    if not isinstance(x, float) and not isinstance(x, np.float64)
+                    else (
+                        f"{x:{floatfmt[idx]}}"
+                        if isinstance(floatfmt, list)
+                        else (
+                            f"{x:.2e}"
+                            if 0 < abs(float(x)) <= 0.0001
+                            else f"{x:floatfmt}"
+                        )
+                    )
+                )
+                for idx, x in enumerate(values)
+            ]
+            table.add_row(*row_idx)
+        session.console.print(table)
+    else:
+        session.console.print(df.to_string(col_space=0))
+
+    if exceeds_allowed_columns:
+        session.console.print(
+            f"[yellow]\nAllowed number of columns exceeded ({session.settings.ALLOWED_NUMBER_OF_COLUMNS}).\n"
+            f"The following columns were removed from the output: {', '.join(trimmed_columns)}.\n[/yellow]"
+        )
+
+    if exceeds_allowed_rows:
+        session.console.print(
+            f"[yellow]\nAllowed number of rows exceeded ({session.settings.ALLOWED_NUMBER_OF_ROWS}).\n"
+            f"{trimmed_rows_count} rows were removed from the output.\n[/yellow]"
+        )
+
+    if exceeds_allowed_columns or exceeds_allowed_rows:
+        session.console.print(
+            "Use the `--export` flag to analyse the full output on a file."
+        )
+
+
+def check_non_negative(value) -> int:
+    """Argparse type to check non negative int."""
+    new_value = int(value)
+    if new_value < 0:
+        raise argparse.ArgumentTypeError(f"{value} is negative")
+    return new_value
+
+
+def check_positive(value) -> int:
+    """Argparse type to check positive int."""
+    new_value = int(value)
+    if new_value <= 0:
+        raise argparse.ArgumentTypeError(f"{value} is an invalid positive int value")
+    return new_value
+
+
+def validate_register_key(value: str) -> str:
+    """Validate the register key to ensure it does not contain the reserved word 'OBB'."""
+    if "OBB" in value:
+        raise argparse.ArgumentTypeError(
+            "The register key cannot contain the reserved word 'OBB'."
+        )
+    return str(value)
+
+
+def get_user_agent() -> str:
+    """Get a not very random user agent."""
+    user_agent_strings = [
+        "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.10; rv:86.1) Gecko/20100101 Firefox/86.1",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:86.1) Gecko/20100101 Firefox/86.1",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:82.1) Gecko/20100101 Firefox/82.1",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:86.0) Gecko/20100101 Firefox/86.0",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:86.0) Gecko/20100101 Firefox/86.0",
+        "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.10; rv:83.0) Gecko/20100101 Firefox/83.0",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:84.0) Gecko/20100101 Firefox/84.0",
+    ]
+
+    return random.choice(user_agent_strings)  # nosec # noqa: S311
+
+
+def get_flair() -> str:
+    """Get a flair icon."""
+    current_flair = str(session.settings.FLAIR)
+    flair = AVAILABLE_FLAIRS.get(current_flair, current_flair)
+    return flair
+
+
+def get_dtime() -> str:
+    """Get a datetime string."""
+    dtime = ""
+    if session.settings.USE_DATETIME and get_user_timezone_or_invalid() != "INVALID":
+        dtime = datetime.now(timezone(get_user_timezone())).strftime("%Y %b %d, %H:%M")
+    return dtime
+
+
+def get_flair_and_username() -> str:
+    """Get a flair icon and username."""
+    flair = get_flair()
+    if dtime := get_dtime():
+        dtime = f"{dtime} "
+
+    username = getattr(session.user.profile.hub_session, "username", "")
+    if username:
+        username = f"[{username}] "
+
+    return f"{dtime}{username}{flair}"
+
+
+def is_timezone_valid(user_tz: str) -> bool:
+    """Check whether user timezone is valid.
+
+    Parameters
+    ----------
+    user_tz: str
+        Timezone to check for validity
+
+    Returns
+    -------
+    bool
+        True if timezone provided is valid
+    """
+    return user_tz in all_timezones
+
+
+def get_user_timezone() -> str:
+    """Get user timezone if it is a valid one.
+
+    Returns
+    -------
+    str
+        user timezone based on .env file
+    """
+    return session.settings.TIMEZONE
+
+
+def get_user_timezone_or_invalid() -> str:
+    """Get user timezone if it is a valid one.
+
+    Returns
+    -------
+    str
+        user timezone based on timezone.openbb file or INVALID
+    """
+    user_tz = get_user_timezone()
+    if is_timezone_valid(user_tz):
+        return f"{user_tz}"
+    return "INVALID"
+
+
+def check_file_type_saved(valid_types: Optional[List[str]] = None):
+    """Provide valid types for the user to be able to select.
+
+    Parameters
+    ----------
+    valid_types: List[str]
+        List of valid types to export data
+
+    Returns
+    -------
+    check_filenames: Optional[List[str]]
+        Function that returns list of filenames to export data
+    """
+
+    def check_filenames(filenames: str = "") -> str:
+        """Check if filenames are valid.
+
+        Parameters
+        ----------
+        filenames: str
+            filenames to be saved separated with comma
+
+        Returns
+        ----------
+        str
+            valid filenames separated with comma
+        """
+        if not filenames or not valid_types:
+            return ""
+        valid_filenames = list()
+        for filename in filenames.split(","):
+            if filename.endswith(tuple(valid_types)):
+                valid_filenames.append(filename)
+            else:
+                session.console.print(
+                    f"[red]Filename '{filename}' provided is not valid!\nPlease use one of the following file types:"
+                    f"{','.join(valid_types)}[/red]\n"
+                )
+        return ",".join(valid_filenames)
+
+    return check_filenames
+
+
+def remove_timezone_from_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    """Remove timezone information from a dataframe.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The dataframe to remove timezone information from
+
+    Returns
+    -------
+    pd.DataFrame
+        The dataframe with timezone information removed
+    """
+    date_cols = []
+    index_is_date = False
+
+    # Find columns and index containing date data
+    if (
+        df.index.dtype.kind == "M"
+        and hasattr(df.index.dtype, "tz")
+        and df.index.dtype.tz is not None
+    ):
+        index_is_date = True
+
+    for col, dtype in df.dtypes.items():
+        if dtype.kind == "M" and hasattr(df.index.dtype, "tz") and dtype.tz is not None:
+            date_cols.append(col)
+
+    # Remove the timezone information
+    for col in date_cols:
+        df[col] = df[col].dt.date
+
+    if index_is_date:
+        index_name = df.index.name
+        df.index = df.index.date
+        df.index.name = index_name
+
+    return df
+
+
+def compose_export_path(func_name: str, dir_path: str) -> Path:
+    """Compose export path for data from the terminal.
+
+    Creates a path to a folder and a filename based on conditions.
+
+    Parameters
+    ----------
+    func_name : str
+        Name of the command that invokes this function
+    dir_path : str
+        Path of directory from where this function is called
+
+    Returns
+    -------
+    Path
+        Path variable containing the path of the exported file
+    """
+    now = datetime.now()
+    # Resolving all symlinks and also normalizing path.
+    resolve_path = Path(dir_path).resolve()
+    # Getting the directory names from the path. Instead of using split/replace (Windows doesn't like that)
+    # check if this is done in a main context to avoid saving with openbb_cli
+    if resolve_path.parts[-2] == "openbb_cli":
+        path_cmd = f"{resolve_path.parts[-1]}"
+    else:
+        path_cmd = f"{resolve_path.parts[-2]}_{resolve_path.parts[-1]}"
+
+    default_filename = f"{now.strftime('%Y%m%d_%H%M%S')}_{path_cmd}_{func_name}"
+
+    full_path = Path(session.user.preferences.export_directory) / default_filename
+
+    return full_path
+
+
+def ask_file_overwrite(file_path: Path) -> Tuple[bool, bool]:
+    """Provide a prompt for overwriting existing files.
+
+    Returns two values, the first is a boolean indicating if the file exists and the
+    second is a boolean indicating if the user wants to overwrite the file.
+    """
+    if session.settings.FILE_OVERWRITE:
+        return False, True
+    if session.settings.TEST_MODE:
+        return False, True
+    if file_path.exists():
+        overwrite = input("\nFile already exists. Overwrite? [y/n]: ").lower()
+        if overwrite == "y":
+            file_path.unlink(missing_ok=True)
+            # File exists and user wants to overwrite
+            return True, True
+        # File exists and user does not want to overwrite
+        return True, False
+    # File does not exist
+    return False, True
+
+
+# This is a false positive on pylint and being tracked in pylint #3060
+# pylint: disable=abstract-class-instantiated,too-many-positional-arguments
+def save_to_excel(df, saved_path, sheet_name, start_row=0, index=True, header=True):
+    """Save a Pandas DataFrame to an Excel file.
+
+    Args:
+        df: A Pandas DataFrame.
+        saved_path: The path to the Excel file to save to.
+        sheet_name: The name of the sheet to save the DataFrame to.
+        start_row: The row number to start writing the DataFrame at.
+        index: Whether to write the DataFrame index to the Excel file.
+        header: Whether to write the DataFrame header to the Excel file.
+    """
+    overwrite_options = {
+        "o": "replace",
+        "a": "overlay",
+        "n": "new",
+    }
+
+    if not saved_path.exists():
+        with pd.ExcelWriter(saved_path, engine="openpyxl") as writer:
+            df.to_excel(writer, sheet_name=sheet_name, index=index, header=header)
+
+    else:
+        with pd.ExcelFile(saved_path) as reader:
+            overwrite_option = "n"
+            if sheet_name in reader.sheet_names:
+                overwrite_option = input(
+                    "\nSheet already exists. Overwrite/Append/New? [o/a/n]: "
+                ).lower()
+                start_row = 0
+                if overwrite_option == "a":
+                    existing_df = pd.read_excel(saved_path, sheet_name=sheet_name)
+                    start_row = existing_df.shape[0] + 1
+
+            with pd.ExcelWriter(
+                saved_path,
+                mode="a",
+                if_sheet_exists=overwrite_options[overwrite_option],
+                engine="openpyxl",
+            ) as writer:
+                df.to_excel(
+                    writer,
+                    sheet_name=sheet_name,
+                    startrow=start_row,
+                    index=index,
+                    header=False if overwrite_option == "a" else header,
+                )
+
+
+# This is a false positive on pylint and being tracked in pylint #3060
+# pylint: disable=abstract-class-instantiated,too-many-positional-arguments
+def export_data(
+    export_type: str,
+    dir_path: str,
+    func_name: str,
+    df: pd.DataFrame = pd.DataFrame(),
+    sheet_name: Optional[str] = None,
+    figure: Optional["OpenBBFigure"] = None,
+    margin: bool = True,
+) -> None:
+    """Export data to a file.
+
+    Parameters
+    ----------
+    export_type : str
+        Type of export between: csv,json,xlsx,xls
+    dir_path : str
+        Path of directory from where this function is called
+    func_name : str
+        Name of the command that invokes this function
+    df : pd.Dataframe
+        Dataframe of data to save
+    sheet_name : str
+        If provided.  The name of the sheet to save in excel file
+    figure : Optional[OpenBBFigure]
+        Figure object to save as image file
+    margin : bool
+        Automatically adjust subplot parameters to give specified padding.
+    """
+    if export_type:
+        saved_path = compose_export_path(func_name, dir_path).resolve()
+        saved_path.parent.mkdir(parents=True, exist_ok=True)
+        for exp_type in export_type.split(","):
+            # In this scenario the path was provided, e.g. --export pt.csv, pt.jpg
+            if "." in exp_type:
+                saved_path = saved_path.with_name(exp_type)
+            # In this scenario we use the default filename
+            else:
+                if ".OpenBB_openbb_cli" in saved_path.name:
+                    saved_path = saved_path.with_name(
+                        saved_path.name.replace(".OpenBB_openbb_cli", "OpenBBCLI")
+                    )
+                saved_path = saved_path.with_suffix(f".{exp_type}")
+
+            exists, overwrite = False, False
+            is_xlsx = exp_type.endswith("xlsx")
+            if sheet_name is None and is_xlsx or not is_xlsx:
+                exists, overwrite = ask_file_overwrite(saved_path)
+
+            if exists and not overwrite:
+                existing = len(list(saved_path.parent.glob(saved_path.stem + "*")))
+                saved_path = saved_path.with_stem(f"{saved_path.stem}_{existing + 1}")
+
+            df = df.replace(
+                {
+                    r"\[yellow\]": "",
+                    r"\[/yellow\]": "",
+                    r"\[green\]": "",
+                    r"\[/green\]": "",
+                    r"\[red\]": "",
+                    r"\[/red\]": "",
+                    r"\[magenta\]": "",
+                    r"\[/magenta\]": "",
+                },
+                regex=True,
+            )
+
+            if exp_type.endswith("csv"):
+                df.to_csv(saved_path)
+            elif exp_type.endswith("json"):
+                df.reset_index(drop=True, inplace=True)
+                df.to_json(saved_path)
+            elif exp_type.endswith("xlsx"):
+                # since xlsx does not support datetimes with timezones we need to remove it
+                df = remove_timezone_from_dataframe(df)
+
+                if sheet_name is None:  # noqa: SIM223
+                    df.to_excel(
+                        saved_path,
+                        index=True,
+                        header=True,
+                    )
+                else:
+                    save_to_excel(df, saved_path, sheet_name)
+
+            elif saved_path.suffix in [".jpg", ".png"]:
+                if figure is None:
+                    session.console.print("No plot to export.")
+                    continue
+                figure.show(export_image=saved_path, margin=margin)
+            else:
+                session.console.print("Wrong export file specified.")
+                continue
+
+            if saved_path.exists():
+                session.console.print(f"Saved file: {saved_path}")
+            else:
+                session.console.print(f"Failed to save file: {saved_path}")
+
+        if figure is not None:
+            figure._exported = True  # pylint: disable=protected-access
+
+
+def system_clear():
+    """Clear screen."""
+    os.system("cls||clear")  # nosec # noqa: S605,S607
+
+
+# Write an abstract helper to make requests from a url with potential headers and params
+def request(
+    url: str, method: str = "get", timeout: int = 0, **kwargs
+) -> requests.Response:
+    """Make requests from a url with potential headers and params.
+
+    Parameters
+    ----------
+    url : str
+        Url to make the request to
+    method : str
+        HTTP method to use.  Choose from:
+        delete, get, head, patch, post, put, by default "get"
+    timeout : int
+        How many seconds to wait for the server to send data
+
+    Returns
+    -------
+    requests.Response
+        Request response object
+
+    Raises
+    ------
+    ValueError
+        If invalid method is passed
+    """
+    method = method.lower()
+    if method not in ["delete", "get", "head", "patch", "post", "put"]:
+        raise ValueError(f"Invalid method: {method}")
+    # We want to add a user agent to the request, so check if there are any headers
+    # If there are headers, check if there is a user agent, if not add one.
+    # Some requests seem to work only with a specific user agent, so we want to be able to override it.
+    headers = kwargs.pop("headers", {})
+    timeout = timeout or session.user.preferences.request_timeout
+
+    if "User-Agent" not in headers:
+        headers["User-Agent"] = get_user_agent()
+    func = getattr(requests, method)
+    return func(
+        url,
+        headers=headers,
+        timeout=timeout,
+        **kwargs,
+    )
+
+
+def parse_unknown_args_to_dict(unknown_args: Optional[List[str]]) -> Dict[str, str]:
+    """Parse unknown arguments to a dictionary."""
+    unknown_args_dict = {}
+    if unknown_args:
+        for idx, arg in enumerate(unknown_args):
+            if arg.startswith("--"):
+                if idx + 1 < len(unknown_args):
+                    try:
+                        unknown_args_dict[arg.replace("--", "")] = (
+                            eval(  # noqa: S307, E501 pylint: disable=eval-used
+                                unknown_args[idx + 1]
+                            )
+                        )
+                    except Exception:
+                        unknown_args_dict[arg] = unknown_args[idx + 1]
+                else:
+                    session.console.print(
+                        f"Missing value for argument {arg}. Skipping this argument."
+                    )
+    return unknown_args_dict
+
+
+def handle_obbject_display(
+    obbject: OBBject,
+    chart: bool = False,
+    export: str = "",
+    sheet_name: str = "",
+    **kwargs,
+):
+    """Handle the display of an OBBject."""
+    df: pd.DataFrame = pd.DataFrame()
+    fig: Optional[OpenBBFigure] = None
+    if chart:
+        try:
+            if obbject.chart:
+                obbject.show(**kwargs)
+            else:
+                obbject.charting.to_chart(**kwargs)  # type: ignore
+            if export:
+                fig = obbject.chart.fig  # type: ignore
+                df = obbject.to_dataframe()
+        except Exception as e:
+            session.console.print(f"Failed to display chart: {e}")
+    elif session.settings.USE_INTERACTIVE_DF:
+        obbject.charting.table()  # type: ignore
+    else:
+        df = obbject.to_dataframe()
+        print_rich_table(
+            df=df,
+            show_index=True,
+            title=obbject.extra.get("command", ""),
+            export=bool(export),
+        )
+    if export and not df.empty:
+        if sheet_name and isinstance(sheet_name, list):
+            sheet_name = sheet_name[0]
+
+        func_name = (
+            obbject.extra.get("command", "")
+            .replace("/", "_")
+            .replace(" ", "_")
+            .replace("--", "_")
+        )
+        export_data(
+            export_type=",".join(export),
+            dir_path=os.path.dirname(os.path.abspath(__file__)),
+            func_name=func_name,
+            df=df,
+            sheet_name=sheet_name,
+            figure=fig,
+        )
+    elif export and df.empty:
+        session.console.print("[yellow]No data to export.[/yellow]")

cli/openbb_cli/models/settings.py

@@ -0,0 +1,167 @@
+"""Settings model."""
+
+from enum import Enum
+from typing import Any, Literal
+
+from dotenv import dotenv_values, set_key
+from openbb_cli.config.constants import AVAILABLE_FLAIRS, ENV_FILE_SETTINGS
+from openbb_core.app.version import get_package_version
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pytz import all_timezones
+
+VERSION = get_package_version("openbb-cli")
+
+
+class SettingGroups(Enum):
+    """Setting types."""
+
+    feature_flags = "feature_flag"
+    preferences = "preference"
+
+
+class Settings(BaseModel):
+    """Settings model."""
+
+    # Platform CLI version
+    VERSION: str = VERSION
+
+    # DEVELOPMENT FLAGS
+    TEST_MODE: bool = False
+    DEBUG_MODE: bool = False
+    DEV_BACKEND: bool = False
+
+    # OPENBB
+    HUB_URL: str = "https://my.openbb.co"
+    BASE_URL: str = "https://payments.openbb.co"
+
+    # GENERAL
+    PREVIOUS_USE: bool = False
+
+    # FEATURE FLAGS
+    FILE_OVERWRITE: bool = Field(
+        default=False,
+        description="whether to overwrite Excel files if they already exists",
+        command="overwrite",
+        group=SettingGroups.feature_flags,
+    )
+    SHOW_VERSION: bool = Field(
+        default=True,
+        description="whether to show the version in the bottom right corner",
+        command="version",
+        group=SettingGroups.feature_flags,
+    )
+    USE_INTERACTIVE_DF: bool = Field(
+        default=True,
+        description="display tables in interactive window",
+        command="interactive",
+        group=SettingGroups.feature_flags,
+    )
+    USE_CLEAR_AFTER_CMD: bool = Field(
+        default=False,
+        description="clear console after each command",
+        command="cls",
+        group=SettingGroups.feature_flags,
+    )
+    USE_DATETIME: bool = Field(
+        default=True,
+        description="whether to show the date and time before the flair",
+        command="datetime",
+        group=SettingGroups.feature_flags,
+    )
+    USE_PROMPT_TOOLKIT: bool = Field(
+        default=True,
+        description="enable prompt toolkit (autocomplete and history)",
+        command="promptkit",
+        group=SettingGroups.feature_flags,
+    )
+    ENABLE_EXIT_AUTO_HELP: bool = Field(
+        default=True,
+        description="automatically print help when quitting menu",
+        command="exithelp",
+        group=SettingGroups.feature_flags,
+    )
+    ENABLE_RICH_PANEL: bool = Field(
+        default=True,
+        description="enable colorful rich CLI panel",
+        command="richpanel",
+        group=SettingGroups.feature_flags,
+    )
+    TOOLBAR_HINT: bool = Field(
+        default=True,
+        description="displays usage hints in the bottom toolbar",
+        command="tbhint",
+        group=SettingGroups.feature_flags,
+    )
+    SHOW_MSG_OBBJECT_REGISTRY: bool = Field(
+        default=False,
+        description="show obbject registry message after a new result is added",
+        command="obbject_msg",
+        group=SettingGroups.feature_flags,
+    )
+
+    # PREFERENCES
+    TIMEZONE: Literal[tuple(all_timezones)] = Field(  # type: ignore[valid-type]
+        default="America/New_York",
+        description="pick timezone",
+        command="timezone",
+        group=SettingGroups.preferences,
+    )
+    FLAIR: Literal[tuple(AVAILABLE_FLAIRS)] = Field(  # type: ignore[valid-type]
+        default=":openbb",
+        description="choose flair icon",
+        command="flair",
+        group=SettingGroups.preferences,
+    )
+    N_TO_KEEP_OBBJECT_REGISTRY: int = Field(
+        default=10,
+        description="define the maximum number of obbjects allowed in the registry",
+        command="obbject_res",
+        group=SettingGroups.preferences,
+    )
+    N_TO_DISPLAY_OBBJECT_REGISTRY: int = Field(
+        default=5,
+        description="define the maximum number of cached results to display on the help menu",
+        command="obbject_display",
+        group=SettingGroups.preferences,
+    )
+    RICH_STYLE: str = Field(
+        default="dark",
+        description="apply a custom rich style to the CLI",
+        command="console_style",
+        group=SettingGroups.preferences,
+    )
+    ALLOWED_NUMBER_OF_ROWS: int = Field(
+        default=20,
+        description="number of rows to show (when not using interactive tables).",
+        command="n_rows",
+        group=SettingGroups.preferences,
+    )
+    ALLOWED_NUMBER_OF_COLUMNS: int = Field(
+        default=5,
+        description="number of columns to show (when not using interactive tables).",
+        command="n_cols",
+        group=SettingGroups.preferences,
+    )
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the model."""
+        return f"{self.__class__.__name__}\n\n" + "\n".join(
+            f"{k}: {v}" for k, v in self.model_dump().items()
+        )
+
+    @model_validator(mode="before")
+    @classmethod
+    def from_env(cls, values: dict) -> dict:
+        """Load settings from .env."""
+        settings = {}
+        settings.update(dotenv_values(ENV_FILE_SETTINGS))
+        settings.update(values)
+        filtered = {k.replace("OPENBB_", ""): v for k, v in settings.items()}
+        return filtered
+
+    def set_item(self, key: str, value: Any) -> None:
+        """Set an item in the model and save to .env."""
+        setattr(self, key, value)
+        set_key(str(ENV_FILE_SETTINGS), "OPENBB_" + key, str(value))

cli/openbb_cli/session.py

@@ -0,0 +1,108 @@
+"""Settings module."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from openbb import obb
+from openbb_charting.core.backend import create_backend, get_backend
+from openbb_core.app.model.abstract.singleton import SingletonMeta
+from openbb_core.app.model.charts.charting_settings import ChartingSettings
+from openbb_core.app.model.user_settings import UserSettings as User
+from prompt_toolkit import PromptSession
+
+from openbb_cli.argparse_translator.obbject_registry import Registry
+from openbb_cli.config.completer import CustomFileHistory
+from openbb_cli.config.console import Console
+from openbb_cli.config.constants import HIST_FILE_PROMPT
+from openbb_cli.config.style import Style
+from openbb_cli.models.settings import Settings
+
+
+def _get_backend():
+    """Get the Platform charting backend."""
+    try:
+        return get_backend()
+    except ValueError:
+        # backend might not be created yet
+        charting_settings = ChartingSettings(
+            system_settings=obb.system, user_settings=obb.user  # type: ignore
+        )
+        create_backend(charting_settings)
+        get_backend().start(debug=charting_settings.debug_mode)  # type: ignore
+        return get_backend()
+
+
+class Session(metaclass=SingletonMeta):
+    """Session class."""
+
+    def __init__(self):
+        """Initialize session."""
+
+        self._obb = obb
+        self._settings = Settings()
+        self._style = Style(
+            style=self._settings.RICH_STYLE,
+            directory=Path(self._obb.user.preferences.user_styles_directory),  # type: ignore[union-attr]
+        )
+        self._console = Console(
+            settings=self._settings, style=self._style.console_style
+        )
+        self._prompt_session = self._get_prompt_session()
+        self._obbject_registry = Registry()
+
+        self._backend = _get_backend()
+
+    @property
+    def user(self) -> User:
+        """Get platform user."""
+        return self._obb.user  # type: ignore[union-attr]
+
+    @property
+    def settings(self) -> Settings:
+        """Get CLI settings."""
+        return self._settings
+
+    @property
+    def style(self) -> Style:
+        """Get CLI style."""
+        return self._style
+
+    @property
+    def console(self) -> Console:
+        """Get console."""
+        return self._console
+
+    @property
+    def obbject_registry(self) -> Registry:
+        """Get obbject registry."""
+        return self._obbject_registry
+
+    @property
+    def prompt_session(self) -> Optional[PromptSession]:
+        """Get prompt session."""
+        return self._prompt_session
+
+    def _get_prompt_session(self) -> Optional[PromptSession]:
+        """Initialize prompt session."""
+        try:
+            if sys.stdin.isatty():
+                prompt_session: Optional[PromptSession] = PromptSession(
+                    history=CustomFileHistory(str(HIST_FILE_PROMPT))
+                )
+            else:
+                prompt_session = None
+        except Exception:
+            prompt_session = None
+
+        return prompt_session
+
+    def is_local(self) -> bool:
+        """Check if user is local."""
+        return not bool(self.user.profile.hub_session)
+
+    def max_obbjects_exceeded(self) -> bool:
+        """Check if max obbjects exceeded."""
+        return (
+            len(self.obbject_registry.all) >= self.settings.N_TO_KEEP_OBBJECT_REGISTRY
+        )

cli/openbb_cli/utils/utils.py

@@ -0,0 +1,34 @@
+"""OpenBB Platform CLI utilities."""
+
+import json
+from pathlib import Path
+
+HOME_DIRECTORY = Path.home()
+OPENBB_PLATFORM_DIRECTORY = Path(HOME_DIRECTORY, ".openbb_platform")
+SYSTEM_SETTINGS_PATH = Path(OPENBB_PLATFORM_DIRECTORY, "system_settings.json")
+
+
+def change_logging_sub_app() -> str:
+    """Build OpenBB Platform setting files."""
+    with open(SYSTEM_SETTINGS_PATH) as file:
+        system_settings = json.load(file)
+
+    initial_logging_sub_app = system_settings.get("logging_sub_app", "")
+
+    system_settings["logging_sub_app"] = "cli"
+
+    with open(SYSTEM_SETTINGS_PATH, "w") as file:
+        json.dump(system_settings, file, indent=4)
+
+    return initial_logging_sub_app
+
+
+def reset_logging_sub_app(initial_logging_sub_app: str):
+    """Reset OpenBB Platform setting files."""
+    with open(SYSTEM_SETTINGS_PATH) as file:
+        system_settings = json.load(file)
+
+    system_settings["logging_sub_app"] = initial_logging_sub_app
+
+    with open(SYSTEM_SETTINGS_PATH, "w") as file:
+        json.dump(system_settings, file, indent=4)