openbb-cli 1.0.0__tar.gz → 1.0.2__tar.gz

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openbb-cli
-Version: 1.0.0
+Version: 1.0.2
 Summary: Investment Research for Everyone, Anywhere.
 Home-page: https://openbb.co
 License: AGPL-3.0-only
@@ -12,7 +12,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: openbb[all] (>=4.2.0,<5.0.0)
+Requires-Dist: openbb-core (>=1.2.4,<2.0.0)
+Requires-Dist: openbb[all] (>=4.2.1,<5.0.0)
 Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
 Requires-Dist: prompt-toolkit (>=3.0.16,<4.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
@@ -33,11 +34,11 @@ Description-Content-Type: text/markdown
 
 ## Overview
 
-The OpenBB CLI is a command line interface that wraps [OpenBB Platform](https://docs.openbb.co/platform).
+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 automate data collection via OpenBB Routine Scripts.
 
-Find the most complete documentation, examples, and usage guides for the OpenBB Platform CLI [here](https://my.openbb.co/app/cli).
+Find the most complete documentation, examples, and usage guides for the OpenBB Platform CLI [here](https://docs.openbb.co/cli).
 
 ## Installation
 
@@ -47,9 +48,9 @@ The command below provides access to the all the available OpenBB extensions beh
 pip install openbb-cli
 ```
 
-> Note: Find the most complete installation hints and tips [here](https://my.openbb.co/app/cli/installation).
+> 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 CLI by running the following command:
+After the installation is complete, you can deploy the OpenBB Platform CLI by running the following command:
 
 ```bash
 openbb

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/README.md

@@ -10,11 +10,11 @@
 
 ## Overview
 
-The OpenBB CLI is a command line interface that wraps [OpenBB Platform](https://docs.openbb.co/platform).
+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 automate data collection via OpenBB Routine Scripts.
 
-Find the most complete documentation, examples, and usage guides for the OpenBB Platform CLI [here](https://my.openbb.co/app/cli).
+Find the most complete documentation, examples, and usage guides for the OpenBB Platform CLI [here](https://docs.openbb.co/cli).
 
 ## Installation
 
@@ -24,9 +24,9 @@ The command below provides access to the all the available OpenBB extensions beh
 pip install openbb-cli
 ```
 
-> Note: Find the most complete installation hints and tips [here](https://my.openbb.co/app/cli/installation).
+> 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 CLI by running the following command:
+After the installation is complete, you can deploy the OpenBB Platform CLI by running the following command:
 
 ```bash
 openbb

openbb_cli-1.0.2/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]

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/argparse_translator/argparse_class_processor.py

@@ -1,19 +1,19 @@
+"""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,
-    ReferenceToCustomArgumentsProcessor,
+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.
-    """
+    """Process a target class to create ArgparseTranslators for its methods."""
 
     # reference variable used to create custom groups for the ArgpaseTranslators
     _reference: Dict[str, Any] = {}
@@ -77,7 +77,7 @@ class ArgparseClassProcessor:
         reference = {route: cls._reference[route]} if route in cls._reference else {}
         if not reference:
             return {}
-        rp = ReferenceToCustomArgumentsProcessor(reference)
+        rp = ReferenceToArgumentsProcessor(reference)
         return rp.custom_groups.get(route, {})  # type: ignore
 
     @classmethod
@@ -92,7 +92,6 @@ class ArgparseClassProcessor:
             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,

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/argparse_translator/argparse_translator.py

@@ -1,8 +1,9 @@
+"""Module for translating a function into an argparse program."""
+
 import argparse
 import inspect
 import re
 from copy import deepcopy
-from enum import Enum
 from typing import (
     Any,
     Callable,
@@ -19,184 +20,37 @@ from typing import (
 )
 
 from openbb_core.app.model.field import OpenBBField
-from pydantic import BaseModel, model_validator
+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 ArgparseActionType(Enum):
-    store = "store"
-    store_true = "store_true"
-
-
-class CustomArgument(BaseModel):
-
-    name: str
-    type: Optional[Any]
-    dest: str
-    default: Any
-    required: bool
-    action: Literal["store_true", "store"]
-    help: str
-    nargs: Optional[Literal["+"]]
-    choices: Optional[Tuple]
-
-    @model_validator(mode="after")  # type: ignore
-    @classmethod
-    def validate_action(cls, values: "CustomArgument"):
-        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: "CustomArgument"):
-        if values.action == "store_true":
-            values.type = None
-            values.nargs = None
-            values.choices = None
-        return values
-
-    # override
-    def model_dump(self, **kwargs):
-
-        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 CustomArgumentGroup(BaseModel):
-    name: str
-    arguments: List[CustomArgument]
-
-
-class ReferenceToCustomArgumentsProcessor:
-    def __init__(self, reference: Dict[str, Dict]):
-        """Initializes the ReferenceToCustomArgumentsProcessor."""
-        self.reference = reference
-        self.custom_groups: Dict[str, List[CustomArgumentGroup]] = {}
-
-        self.build_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 = ()
-
-        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(
-                        CustomArgument(
-                            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 = CustomArgumentGroup(name=provider, arguments=custom_arguments)
-
-                if route not in self.custom_groups:
-                    self.custom_groups[route] = []
-
-                self.custom_groups[route].append(group)
-
-
 class ArgparseTranslator:
+    """Class to translate a function into an argparse program."""
+
     def __init__(
         self,
         func: Callable,
-        custom_argument_groups: Optional[List[CustomArgumentGroup]] = None,
+        custom_argument_groups: Optional[List[ArgparseArgumentGroupModel]] = None,
         add_help: Optional[bool] = True,
     ):
         """
-        Initializes the ArgparseTranslator.
+        Initialize the ArgparseTranslator.
 
         Args:
             func (Callable): The function to translate into an argparse program.
@@ -228,45 +82,6 @@ class ArgparseTranslator:
     def _handle_argument_in_groups(self, argument, group):
         """Handle the argument and add it to the parser."""
 
-        def _in_group(arg, group_title):
-            for action_group in self._parser._action_groups:
-                if action_group.title == group_title:
-                    for action in action_group._group_actions:
-                        opts = action.option_strings
-                        if (opts and opts[0] == arg) or action.dest == arg:
-                            return True
-            return False
-
-        def _remove_argument(arg) -> List[Optional[str]]:
-            groups_w_arg = []
-
-            # remove the argument from the parser
-            for action in self._parser._actions:
-                opts = action.option_strings
-                if (opts and opts[0] == arg) or action.dest == arg:
-                    self._parser._remove_action(action)
-                    break
-
-            # remove from all groups
-            for action_group in self._parser._action_groups:
-                for action in action_group._group_actions:
-                    opts = action.option_strings
-                    if (opts and opts[0] == arg) or action.dest == arg:
-                        action_group._group_actions.remove(action)
-                        groups_w_arg.append(action_group.title)
-
-            # remove from _action_groups dict
-            self._parser._option_string_actions.pop(f"--{arg}", None)
-
-            return groups_w_arg
-
-        def _get_arg_choices(arg) -> Tuple:
-            for action in self._parser._actions:
-                opts = action.option_strings
-                if (opts and opts[0] == arg) or action.dest == arg:
-                    return tuple(action.choices or ())
-            return ()
-
         def _update_providers(
             input_string: str, new_provider: List[Optional[str]]
         ) -> str:
@@ -288,23 +103,27 @@ class ArgparseTranslator:
             kwargs = argument.model_dump(exclude={"name"}, exclude_none=True)
             model_choices = kwargs.get("choices", ()) or ()
             # extend choices
-            choices = tuple(set(_get_arg_choices(argument.name) + model_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(argument.name, group_title="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(argument.name, group_title="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(
@@ -312,9 +131,16 @@ class ArgparseTranslator:
                             )
                 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(argument.name)
+            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
@@ -322,16 +148,17 @@ class ArgparseTranslator:
                 kwargs["choices"] = choices  # update choices
             # add provider info to the help
             kwargs["help"] = _update_providers(argument.help or "", groups_w_arg)
-            self._parser.add_argument(f"--{argument.name}", **kwargs)
+            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:
-        """Builds the description of the argparse program from the function docstring."""
-
+        """Build the description of the argparse program from the function docstring."""
         patterns = ["openbb\n        ======", "Parameters\n        ----------"]
 
         if func_doc:
@@ -344,31 +171,34 @@ class ArgparseTranslator:
 
     @staticmethod
     def _param_is_default(param: inspect.Parameter) -> bool:
-        """Returns True if the parameter has a default value."""
+        """Return True if the parameter has a default value."""
         return param.default != inspect.Parameter.empty
 
     def _get_action_type(self, param: inspect.Parameter) -> str:
-        """Returns the argparse action type for the given parameter."""
+        """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 == bool:
-            return ArgparseActionType.store_true.value
-        return ArgparseActionType.store.value
+        if param_type == bool or (
+            type_origin is Union and bool in get_args(param_type)
+        ):
+            return "store_true"
+        return "store"
 
     def _get_type_and_choices(
         self, param: inspect.Parameter
     ) -> Tuple[Type[Any], Tuple[Any, ...]]:
-        """Returns the type and choices for the given parameter."""
+        """Return the type and choices for the given parameter."""
         param_type = self.type_hints[param.name]
         type_origin = get_origin(param_type)
 
-        choices = ()
+        choices: tuple[Any, ...] = ()
 
         if type_origin is Literal:
             choices = get_args(param_type)
             param_type = type(choices[0])  # type: ignore
 
-        if type_origin is list:  # TODO: dict should also go here
+        if type_origin is list:
             param_type = get_args(param_type)[0]
 
             if get_origin(param_type) is Literal:
@@ -416,32 +246,26 @@ class ArgparseTranslator:
 
     @classmethod
     def _get_argument_custom_help(cls, param: inspect.Parameter) -> Optional[str]:
-        """Returns the help annotation for the given parameter."""
+        """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
         )
-        if not help_annotation:
-            # try to get it from the docstring
-            pass
         return help_annotation
 
     @classmethod
     def _get_argument_custom_choices(cls, param: inspect.Parameter) -> Optional[str]:
-        """Returns the help annotation for the given parameter."""
+        """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
         )
-        if not choices_annotation:
-            # try to get it from the docstring
-            pass
         return choices_annotation
 
     def _get_nargs(self, param: inspect.Parameter) -> Optional[str]:
-        """Returns the nargs annotation for the given parameter."""
+        """Return the nargs annotation for the given parameter."""
         param_type = self.type_hints[param.name]
         origin = get_origin(param_type)
 
@@ -456,11 +280,8 @@ class ArgparseTranslator:
         return None
 
     def _generate_argparse_arguments(self, parameters) -> None:
-        """Generates the argparse arguments from the function parameters."""
+        """Generate the argparse arguments from the function parameters."""
         for param in parameters.values():
-            # TODO : how to handle kwargs?
-            # it's possible to add unknown arguments when parsing as follows:
-            # args, unknown_args = parser.parse_known_args()
             if param.name == "kwargs":
                 continue
 
@@ -508,32 +329,27 @@ class ArgparseTranslator:
 
             required = not self._param_is_default(param)
 
-            kwargs = {
-                "type": param_type,
-                "dest": param.name,
-                "default": param.default,
-                "required": required,
-                "action": self._get_action_type(param),
-                "help": self._get_argument_custom_help(param),
-                "nargs": self._get_nargs(param),
-            }
-
-            if choices:
-                kwargs["choices"] = choices
-
-            if param_type == bool:
-                # store_true action does not accept the below kwargs
-                kwargs.pop("type")
-                kwargs.pop("nargs")
+            argument = ArgparseArgumentModel(
+                name=param.name,
+                type=param_type,
+                dest=param.name,
+                default=param.default,
+                required=required,
+                action=self._get_action_type(param),
+                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"--{param.name}",
+                    f"--{argument.name}",
                     **kwargs,
                 )
             else:
                 self._parser.add_argument(
-                    f"--{param.name}",
+                    f"--{argument.name}",
                     **kwargs,
                 )
 
@@ -559,7 +375,6 @@ class ArgparseTranslator:
         # 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():
-            # TODO : how to handle kwargs?
             if param.name == "kwargs":
                 continue
             param_type, _ = self._get_type_and_choices(param)
@@ -574,7 +389,7 @@ class ArgparseTranslator:
         parsed_args: Optional[argparse.Namespace] = None,
     ) -> Any:
         """
-        Executes the original function with the parsed arguments.
+        Execute the original function with the parsed arguments.
 
         Args:
             parsed_args (Optional[argparse.Namespace], optional): The parsed arguments. Defaults to None.
@@ -605,7 +420,7 @@ class ArgparseTranslator:
 
     def parse_args_and_execute(self) -> Any:
         """
-        Parses the arguments and executes the original function.
+        Parse the arguments and executes the original function.
 
         Returns:
             Any: The return value of the original function.
@@ -615,7 +430,7 @@ class ArgparseTranslator:
 
     def translate(self) -> Callable:
         """
-        Wraps the original function with an argparse program.
+        Wrap the original function with an argparse program.
 
         Returns:
             Callable: The original function wrapped with an argparse program.

openbb_cli-1.0.2/openbb_cli/argparse_translator/reference_processor.py

@@ -0,0 +1,137 @@
+"""Module for the ReferenceToArgumentsProcessor class."""
+
+from typing import (
+    Any,
+    Dict,
+    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)

openbb_cli-1.0.2/openbb_cli/argparse_translator/utils.py

@@ -0,0 +1,71 @@
+"""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:
+            if hasattr(action, "optional_choices"):
+                return action.optional_choices
+    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)

openbb_cli-1.0.2/openbb_cli/cli.py

@@ -0,0 +1,23 @@
+"""OpenBB Platform CLI entry point."""
+
+import sys
+
+
+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__":
+    main()

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/controllers/base_controller.py

@@ -4,6 +4,7 @@ import argparse
 import difflib
 import os
 import re
+import shlex
 from abc import ABCMeta, abstractmethod
 from datetime import datetime
 from pathlib import Path
@@ -240,7 +241,7 @@ class BaseController(metaclass=ABCMeta):
         else:
             try:
                 (known_args, other_args) = self.parser.parse_known_args(
-                    an_input.split()
+                    shlex.split(an_input)
                 )
             except Exception as exc:
                 raise SystemExit from exc
@@ -742,13 +743,15 @@ class BaseController(metaclass=ABCMeta):
 
             if export_allowed == "raw_data_only":
                 choices_export = ["csv", "json", "xlsx"]
-                help_export = "Export raw data into csv, json, xlsx"
+                help_export = "Export raw data into csv, json or xlsx."
             elif export_allowed == "figures_only":
-                choices_export = ["png", "jpg", "pdf", "svg"]
-                help_export = "Export figure into png, jpg, pdf, svg "
+                choices_export = ["png", "jpg"]
+                help_export = "Export figure into png or jpg."
             else:
-                choices_export = ["csv", "json", "xlsx", "png", "jpg", "pdf", "svg"]
-                help_export = "Export raw data into csv, json, xlsx and figure into png, jpg, pdf, svg "
+                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",
@@ -798,11 +801,31 @@ class BaseController(metaclass=ABCMeta):
             return None
 
         try:
-            # If the user uses a comma separated list of arguments, split them
-            for index, arg in enumerate(other_args):
-                if "," in arg:
-                    parts = arg.split(",")
-                    other_args[index : index + 1] = parts
+            # 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)
 
@@ -811,7 +834,7 @@ class BaseController(metaclass=ABCMeta):
                 "raw_data_and_figures",
             ]:
                 ns_parser.is_image = any(
-                    ext in ns_parser.export for ext in ["png", "svg", "jpg", "pdf"]
+                    ext in ns_parser.export for ext in ["png", "jpg"]
                 )
 
         except SystemExit:

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/controllers/base_platform_controller.py

@@ -154,11 +154,10 @@ class PlatformController(BaseController):
 
                     obbject = translator.execute_func(parsed_args=ns_parser)
                     df: pd.DataFrame = pd.DataFrame()
-                    fig: OpenBBFigure = None
+                    fig: Optional[OpenBBFigure] = None
                     title = f"{self.PATH}{translator.func.__name__}"
 
                     if obbject:
-
                         if isinstance(obbject, OBBject):
                             if session.max_obbjects_exceeded() and obbject.results:
                                 session.obbject_registry.remove()

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/controllers/choices.py

@@ -56,13 +56,15 @@ def __mock_parse_known_args_and_warn(
 
         if export_allowed == "raw_data_only":
             choices_export = ["csv", "json", "xlsx"]
-            help_export = "Export raw data into csv, json, xlsx"
+            help_export = "Export raw data into csv, json or xlsx."
         elif export_allowed == "figures_only":
-            choices_export = ["png", "jpg", "pdf", "svg"]
-            help_export = "Export figure into png, jpg, pdf, svg "
+            choices_export = ["png", "jpg"]
+            help_export = "Export figure into png or jpg."
         else:
-            choices_export = ["csv", "json", "xlsx", "png", "jpg", "pdf", "svg"]
-            help_export = "Export raw data into csv, json, xlsx and figure into png, jpg, pdf, svg "
+            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",

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/controllers/cli_controller.py

@@ -355,7 +355,7 @@ class CLIController(BaseController):
             "--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(",")],
+            type=str,
         )
         parser.add_argument(
             "-e",
@@ -431,17 +431,22 @@ class CLIController(BaseController):
                 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 ns_parser.routine_args:
-                    script_inputs = (
-                        ns_parser.routine_args
-                        if "," not in ns_parser.routine_args
-                        else ns_parser.routine_args.split(",")
+                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 ns_parser.routine_args else None,
+                    raw_lines=raw_lines, script_inputs=script_inputs
                 )
 
                 # If there err output is not an empty string then it means there was an
@@ -546,7 +551,6 @@ def run_cli(jobs_cmds: Optional[List[str]] = None, test_mode=False):
         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

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/controllers/utils.py

@@ -901,7 +901,7 @@ def export_data(
                 else:
                     save_to_excel(df, saved_path, sheet_name)
 
-            elif saved_path.suffix in [".jpg", ".pdf", ".png", ".svg"]:
+            elif saved_path.suffix in [".jpg", ".png"]:
                 if figure is None:
                     Session().console.print("No plot to export.")
                     continue
@@ -910,7 +910,10 @@ def export_data(
                 Session().console.print("Wrong export file specified.")
                 continue
 
-            Session().console.print(f"Saved file: {saved_path}")
+            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

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/openbb_cli/models/settings.py

@@ -1,17 +1,20 @@
-"""Settings model"""
+"""Settings model."""
 
 from typing import Any
 
 from dotenv import dotenv_values, set_key
 from openbb_cli.config.constants import ENV_FILE_SETTINGS
+from openbb_core.app.version import get_package_version
 from pydantic import BaseModel, ConfigDict, model_validator
 
+VERSION = get_package_version("openbb-cli")
+
 
 class Settings(BaseModel):
     """Settings model."""
 
     # Platform CLI version
-    VERSION: str = "1.0.0"
+    VERSION: str = VERSION
 
     # DEVELOPMENT FLAGS
     TEST_MODE: bool = False

{openbb_cli-1.0.0 → openbb_cli-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openbb-cli"
-version = "1.0.0"
+version = "1.0.2"
 description = "Investment Research for Everyone, Anywhere."
 authors = ["OpenBB <hello@openbb.co>"]
 packages = [{ include = "openbb_cli" }]
@@ -17,16 +17,14 @@ openbb = 'openbb_cli.cli:main'
 python = "^3.8.1,<3.12"
 
 # OpenBB dependencies
-openbb = { version = "^4.2.0", extras = ["all"] }
+openbb = { version = "^4.2.1", extras = ["all"] }
 
-# Terminal dependencies
+# CLI dependencies
 prompt-toolkit = "^3.0.16"
 rich = "^13"
 python-dotenv = "^1.0.0"
 openpyxl = "^3.1.2"
-
-[tool.poetry.group.dev.dependencies]
-openbb-devtools = "^1.1.3"
+openbb-core = "^1.2.4"
 
 [build-system]
 requires = ["setuptools<65.5.0", "poetry-core>=1.0.0"]

openbb_cli-1.0.0/openbb_cli/cli.py

@@ -1,20 +0,0 @@
-"""OpenBB Platform CLI entry point."""
-
-import sys
-
-from openbb_cli.config.setup import bootstrap
-from openbb_cli.controllers.cli_controller import launch
-
-
-def main():
-    """Use the main entry point for the OpenBB CLI."""
-    bootstrap()
-
-    dev = "--dev" in sys.argv[1:]
-    debug = "--debug" in sys.argv[1:]
-
-    launch(dev, debug)
-
-
-if __name__ == "__main__":
-    main()