openbb-cli 1.2.0__tar.gz → 1.3.0__tar.gz

{openbb_cli-1.2.0 → openbb_cli-1.3.0}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: openbb-cli
-Version: 1.2.0
+Version: 1.3.0
 Summary: Investment Research for Everyone, Anywhere.
 License: AGPL-3.0-only
 Author: OpenBB
 Author-email: hello@openbb.co
-Requires-Python: >=3.9.21,<3.14
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: openbb[all] (>=4.5.0,<5.0.0)
+Requires-Dist: openbb[all] (>=4.6.0,<5.0.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: prompt-toolkit (>=3.0.50,<4.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
@@ -61,33 +61,7 @@ Which should result in the following output:
 
 ![image](https://github.com/OpenBB-finance/OpenBB/assets/48914296/f606bb6e-fa00-4fc8-bad2-8269bb4fc38e)
 
-## API keys
+## Documentation
 
-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"
-  }
-}
-```
+View the user documentation for this package [here](https://docs.openbb.co/cli)
 

{openbb_cli-1.2.0 → openbb_cli-1.3.0}/README.md

@@ -36,32 +36,6 @@ Which should result in the following output:
 
 ![image](https://github.com/OpenBB-finance/OpenBB/assets/48914296/f606bb6e-fa00-4fc8-bad2-8269bb4fc38e)
 
-## API keys
+## Documentation
 
-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"
-  }
-}
-```
+View the user documentation for this package [here](https://docs.openbb.co/cli)

{openbb_cli-1.2.0 → openbb_cli-1.3.0}/openbb_cli/argparse_translator/argparse_argument.py

@@ -2,10 +2,7 @@
 
 from typing import (
     Any,
-    List,
     Literal,
-    Optional,
-    Tuple,
 )
 
 from pydantic import BaseModel, model_validator
@@ -22,9 +19,9 @@ class ArgparseArgumentModel(BaseModel):
     default: Any
     required: bool
     action: Literal["store_true", "store"]
-    help: Optional[str]
-    nargs: Optional[Literal["+"]]
-    choices: Optional[Tuple]
+    help: str | None
+    nargs: Literal["+"] | None
+    choices: tuple | None
 
     @model_validator(mode="after")  # type: ignore
     @classmethod
@@ -60,4 +57,4 @@ class ArgparseArgumentGroupModel(BaseModel):
     """Pydantic model for a custom argument group."""
 
     name: str
-    arguments: List[ArgparseArgumentModel]
+    arguments: list[ArgparseArgumentModel]

{openbb_cli-1.2.0 → openbb_cli-1.3.0}/openbb_cli/argparse_translator/argparse_class_processor.py

@@ -1,7 +1,7 @@
 """Module for the ArgparseClassProcessor class."""
 
 import inspect
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
 # TODO: this needs to be done differently
 from openbb_core.app.static.container import Container
@@ -16,13 +16,13 @@ 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] = {}
+    _reference: dict[str, Any] = {}
 
     def __init__(
         self,
-        target_class: Type,
+        target_class: type,
         add_help: bool = False,
-        reference: Optional[Dict[str, Any]] = None,
+        reference: dict[str, Any] | None = None,
     ):
         """
         Initialize the ArgparseClassProcessor.
@@ -34,10 +34,10 @@ class ArgparseClassProcessor:
         add_help : Optional[bool]
             Whether to add help to the ArgparseTranslators.
         """
-        self._target_class: Type = target_class
+        self._target_class: type = target_class
         self._add_help: bool = add_help
-        self._translators: Dict[str, ArgparseTranslator] = {}
-        self._paths: Dict[str, str] = {}
+        self._translators: dict[str, ArgparseTranslator] = {}
+        self._paths: dict[str, str] = {}
 
         ArgparseClassProcessor._reference = reference or {}
 
@@ -48,7 +48,7 @@ class ArgparseClassProcessor:
         self._build_paths(target=self._target_class)
 
     @property
-    def translators(self) -> Dict[str, ArgparseTranslator]:
+    def translators(self) -> dict[str, ArgparseTranslator]:
         """
         Get the ArgparseTranslators associated with the target class.
 
@@ -60,7 +60,7 @@ class ArgparseClassProcessor:
         return self._translators
 
     @property
-    def paths(self) -> Dict[str, str]:
+    def paths(self) -> dict[str, str]:
         """
         Get the paths associated with the target class.
 
@@ -72,7 +72,7 @@ class ArgparseClassProcessor:
         return self._paths
 
     @classmethod
-    def _custom_groups_from_reference(cls, class_name: str, function_name: str) -> Dict:
+    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:
@@ -85,7 +85,7 @@ class ArgparseClassProcessor:
         cls,
         target: type,
         add_help: bool = False,
-    ) -> Dict[str, ArgparseTranslator]:
+    ) -> dict[str, ArgparseTranslator]:
         methods = {}
 
         for name, member in inspect.getmembers(target):

{openbb_cli-1.2.0 → openbb_cli-1.3.0}/openbb_cli/argparse_translator/argparse_translator.py

@@ -3,16 +3,12 @@
 import argparse
 import inspect
 import re
+from collections.abc import Callable
 from copy import deepcopy
 from typing import (
+    Annotated,
     Any,
-    Callable,
-    Dict,
-    List,
     Literal,
-    Optional,
-    Tuple,
-    Type,
     Union,
     get_args,
     get_origin,
@@ -21,7 +17,6 @@ from typing import (
 
 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,
@@ -46,8 +41,8 @@ class ArgparseTranslator:
     def __init__(
         self,
         func: Callable,
-        custom_argument_groups: Optional[List[ArgparseArgumentGroupModel]] = None,
-        add_help: Optional[bool] = True,
+        custom_argument_groups: list[ArgparseArgumentGroupModel] | None = None,
+        add_help: bool | None = True,
     ):
         """
         Initialize the ArgparseTranslator.
@@ -59,7 +54,7 @@ class ArgparseTranslator:
         self.func = func
         self.signature = inspect.signature(func)
         self.type_hints = get_type_hints(func)
-        self.provider_parameters: Dict[str, List[str]] = {}
+        self.provider_parameters: dict[str, list[str]] = {}
 
         self._parser = argparse.ArgumentParser(
             prog=func.__name__,
@@ -82,9 +77,7 @@ class ArgparseTranslator:
     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:
+        def _update_providers(input_string: str, new_provider: list[str | None]) -> str:
             pattern = r"\(provider:\s*(.*?)\)"
             providers = re.findall(pattern, input_string)
             providers.extend(new_provider)
@@ -159,119 +152,192 @@ class ArgparseTranslator:
     @staticmethod
     def _build_description(func_doc: str) -> str:
         """Build the description of the argparse program from the function docstring."""
-        patterns = ["openbb\n        ======", "Parameters\n        ----------"]
+        # Remove only the Examples section and the openbb header if present
+        patterns_to_remove = [
+            (r"openbb\n\s+={3,}\n", ""),  # Remove openbb header
+            (r"\n\s*Examples\n\s*-{3,}\n.*", ""),  # Remove Examples section to end
+        ]
+
+        for pattern, replacement in patterns_to_remove:
+            func_doc = re.sub(pattern, replacement, func_doc, flags=re.DOTALL)
+
+        # Clean up type annotations in docstrings
+        def clean_type_annotation(type_str: str) -> str:
+            """Clean up a single type annotation."""
+            # First, handle the pipe union syntax: type1 | type2 -> type1 or type2
+            # Do this FIRST before other transformations
+            type_str = re.sub(r"\s*\|\s*", " or ", type_str)
 
-        if func_doc:
-            for pattern in patterns:
-                if pattern in func_doc:
-                    func_doc = func_doc[: func_doc.index(pattern)].strip()
-                    break
+            # Handle Annotated[type, ...] -> type
+            type_str = re.sub(r"Annotated\[([^,\]]+)(?:,\s*[^\]]+)?\]", r"\1", type_str)
 
-        return func_doc
+            # Handle Union[type1, type2, ...] -> type1 or type2 or ...
+            type_str = re.sub(
+                r"Union\[([^\]]+)\]",
+                lambda m: " or ".join(m.group(1).split(", ")),
+                type_str,
+            )
+
+            # Handle Optional[type] -> type or None
+            type_str = re.sub(r"Optional\[([^\]]+)\]", r"\1 or None", type_str)
+
+            # Deduplicate "or" separated types
+            parts = [p.strip() for p in type_str.split(" or ")]
+
+            # Remove duplicates while preserving order (case-insensitive)
+            seen = set()
+            unique_parts = []
+            for part in parts:
+                part_lower = part.lower()
+                if part_lower not in seen:
+                    seen.add(part_lower)
+                    unique_parts.append(part)
+
+            # If None is present, move it to the end
+            if "None" in unique_parts:
+                unique_parts.remove("None")
+                unique_parts.append("None")
+
+            type_str = " or ".join(unique_parts)
+
+            return type_str
+
+        # Process each line that contains a type annotation (format: "name : type")
+        lines = func_doc.split("\n")
+        cleaned_lines = []
+
+        for line in lines:
+            # Match lines with type annotations (parameter_name : type_annotation)
+            if ":" in line and not line.strip().startswith("#"):
+                # Split only on the first colon to preserve any colons in the description
+                parts = line.split(":", 1)
+                if len(parts) == 2:
+                    param_name = parts[0]
+                    rest = parts[1].strip()
+
+                    # Extract the type part (everything before the first real description line)
+                    # Type annotations typically don't contain spaces at the start of continuation lines
+                    type_match = re.match(r"^([^\n]+?)(?:\n\s{4,}|\s{2,}|$)", rest)
+                    if type_match:
+                        type_part = type_match.group(1).strip()
+                        description_part = rest[len(type_match.group(1)) :]
+
+                        # Clean the type annotation
+                        cleaned_type = clean_type_annotation(type_part)
+
+                        # Reconstruct the line
+                        if description_part:
+                            cleaned_lines.append(
+                                f"{param_name}: {cleaned_type}{description_part}"
+                            )
+                        else:
+                            cleaned_lines.append(f"{param_name}: {cleaned_type}")
+                        continue
+
+            cleaned_lines.append(line)
+
+        func_doc = "\n".join(cleaned_lines)
+
+        return func_doc.strip()
 
     @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:
+    def _get_action_type(
+        self, param: inspect.Parameter
+    ) -> Literal["store_true", "store"]:
         """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)
-        ):
+        origin = get_origin(param_type)
+        args = get_args(param_type)
+
+        if param_type is bool:
+            return "store_true"
+
+        if origin is Union and bool in args:
+            return "store_true"
+
+        # Special case for Optional[bool] which is Union[bool, None]
+        if origin is Union and bool in args and type(None) in args:
             return "store_true"
+
         return "store"
 
-    def _get_type_and_choices(  # noqa: PLR0912 # pylint: disable=too-many-return-statements, too-many-branches, too-many-statements
+    def _get_type_and_choices(
         self, param: inspect.Parameter
-    ) -> Tuple[Type[Any], Tuple[Any, ...]]:
+    ) -> 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
+
+        def get_base_type(  # pylint: disable=R0911 #  noqa:PLR0911
+            t: Any,
+        ) -> type:
+            """Recursively find the base type for argparse."""
+            origin = get_origin(t)
+            args = get_args(t)
+
+            if origin is Union or "types.UnionType" in str(type(t)):
+                non_none_args = [a for a in args if a is not type(None)]
+                if len(non_none_args) == 1:
+                    return get_base_type(non_none_args[0])
+                # For Union[A, B, C], check for bool first, then default to str
+                if bool in non_none_args:
+                    return bool
+                # If we have multiple types including str, prefer str as it's most flexible
+                if str in non_none_args:
+                    return str
+                # Otherwise, try to get the first concrete type
+                for arg in non_none_args:
+                    if arg not in (type(None), Any):
+                        return get_base_type(arg)
+                return str
+            if origin is Literal:
+                return type(args[0]) if args else str
+            if origin is list:
+                return get_base_type(args[0]) if args else Any  # type: ignore
+            if t is Any:
+                return str
+            # Handle actual type objects (like datetime.date)
+            if isinstance(t, type):
+                return t
+            return str
+
+        def get_choices(t: Any) -> tuple:
+            """Recursively find the choices for argparse."""
+            origin = get_origin(t)
+            args = get_args(t)
+
+            if origin is Union or "types.UnionType" in str(type(t)):
+                non_none_args = [a for a in args if a is not type(None)]
+                all_choices: list = []
+                for arg in non_none_args:
+                    all_choices.extend(get_choices(arg))
+                return tuple(set(all_choices))
+            if origin is Literal:
+                return args
+            if origin is list and args:
+                return get_choices(args[0])
+            return ()
+
+        param_type_hint = self.type_hints[param.name]
+
+        base_type = get_base_type(param_type_hint)
+        choices = get_choices(param_type_hint)
+
         custom_choices = self._get_argument_custom_choices(param)
-        if custom_choices and param_type is not bool:
+        if custom_choices:
             choices = tuple(custom_choices)
 
-        return param_type, choices
+        if base_type is bool:
+            choices = ()
+
+        return base_type, choices
 
     @staticmethod
     def _split_annotation(
-        base_annotation: Type[Any], custom_annotation_type: Type
-    ) -> Tuple[Type[Any], List[Any]]:
+        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, []
@@ -283,7 +349,7 @@ class ArgparseTranslator:
         ]
 
     @classmethod
-    def _get_argument_custom_help(cls, param: inspect.Parameter) -> Optional[str]:
+    def _get_argument_custom_help(cls, param: inspect.Parameter) -> str | None:
         """Return the help annotation for the given parameter."""
         base_annotation = param.annotation
         _, custom_annotations = cls._split_annotation(base_annotation, OpenBBField)
@@ -293,7 +359,7 @@ class ArgparseTranslator:
         return help_annotation
 
     @classmethod
-    def _get_argument_custom_choices(cls, param: inspect.Parameter) -> Optional[str]:
+    def _get_argument_custom_choices(cls, param: inspect.Parameter) -> str | None:
         """Return the help annotation for the given parameter."""
         base_annotation = param.annotation
         _, custom_annotations = cls._split_annotation(base_annotation, OpenBBField)
@@ -302,7 +368,7 @@ class ArgparseTranslator:
         )
         return choices_annotation
 
-    def _get_nargs(self, param: inspect.Parameter) -> Optional[str]:
+    def _get_nargs(self, param: inspect.Parameter) -> Literal["+"] | None:
         """Return the nargs annotation for the given parameter."""
         param_type = self.type_hints[param.name]
         origin = get_origin(param_type)
@@ -339,7 +405,7 @@ class ArgparseTranslator:
                 sig = inspect.signature(param_type)
 
                 # add help to the annotation
-                annotated_parameters: List[inspect.Parameter] = []
+                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}",
@@ -400,9 +466,9 @@ class ArgparseTranslator:
                 )
 
     @staticmethod
-    def _unflatten_args(args: dict) -> Dict[str, Any]:
+    def _unflatten_args(args: dict) -> dict[str, Any]:
         """Unflatten the args that were flattened by the custom types."""
-        result: Dict[str, Any] = {}
+        result: dict[str, Any] = {}
         for key, value in args.items():
             if SEP in key:
                 parts = key.split(SEP)
@@ -416,7 +482,7 @@ class ArgparseTranslator:
                 result[key] = value
         return result
 
-    def _update_with_custom_types(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    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
@@ -432,7 +498,7 @@ class ArgparseTranslator:
 
     def execute_func(
         self,
-        parsed_args: Optional[argparse.Namespace] = None,
+        parsed_args: argparse.Namespace | None = None,
     ) -> Any:
         """
         Execute the original function with the parsed arguments.
@@ -447,7 +513,7 @@ class ArgparseTranslator:
         kwargs = self._unflatten_args(vars(parsed_args))
         kwargs = self._update_with_custom_types(kwargs)
         provider = kwargs.get("provider")
-        provider_args: List = []
+        provider_args: list = []
         if provider and provider in self.provider_parameters:
             provider_args = self.provider_parameters[provider]
         else: