[Feature] Delay/Optimize Imports

openbb_platform/core/openbb_core/app/command_runner.py

@@ -8,36 +8,34 @@
 from inspect import Parameter, signature
 from sys import exc_info
 from time import perf_counter_ns
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type
 from warnings import catch_warnings, showwarning, warn
 
 from pydantic import BaseModel, ConfigDict, create_model
 
-from openbb_core.app.logs.logging_service import LoggingService
 from openbb_core.app.model.abstract.error import OpenBBError
 from openbb_core.app.model.abstract.warning import OpenBBWarning, cast_warning
-from openbb_core.app.model.command_context import CommandContext
 from openbb_core.app.model.metadata import Metadata
 from openbb_core.app.model.obbject import OBBject
-from openbb_core.app.model.system_settings import SystemSettings
-from openbb_core.app.model.user_settings import UserSettings
 from openbb_core.app.provider_interface import ExtraParams
-from openbb_core.app.router import CommandMap
-from openbb_core.app.service.system_service import SystemService
-from openbb_core.app.service.user_service import UserService
 from openbb_core.env import Env
 from openbb_core.provider.utils.helpers import maybe_coroutine, run_async
 
+if TYPE_CHECKING:
+    from openbb_core.app.model.system_settings import SystemSettings
+    from openbb_core.app.model.user_settings import UserSettings
+    from openbb_core.app.router import CommandMap
+
 
 class ExecutionContext:
     """Execution context."""
 
     def __init__(
         self,
-        command_map: CommandMap,
+        command_map: "CommandMap",
         route: str,
-        system_settings: SystemSettings,
-        user_settings: UserSettings,
+        system_settings: "SystemSettings",
+        user_settings: "UserSettings",
     ) -> None:
         """Initialize the execution context."""
         self.command_map = command_map
@@ -104,10 +102,13 @@ def merge_args_and_kwargs(
     def update_command_context(
         func: Callable,
         kwargs: Dict[str, Any],
-        system_settings: SystemSettings,
-        user_settings: UserSettings,
+        system_settings: "SystemSettings",
+        user_settings: "UserSettings",
     ) -> Dict[str, Any]:
         """Update the command context with the available user and system settings."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.model.command_context import CommandContext
+
         argcount = func.__code__.co_argcount
         if "cc" in func.__code__.co_varnames[:argcount]:
             kwargs["cc"] = CommandContext(
@@ -281,6 +282,9 @@ async def _execute_func(
         kwargs: Dict[str, Any],
     ) -> OBBject:
         """Execute a function and return the output."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.logs.logging_service import LoggingService
+
         user_settings = execution_context.user_settings
         system_settings = execution_context.system_settings
 
@@ -403,50 +407,60 @@ class CommandRunner:
 
     def __init__(
         self,
-        command_map: Optional[CommandMap] = None,
-        system_settings: Optional[SystemSettings] = None,
-        user_settings: Optional[UserSettings] = None,
+        command_map: Optional["CommandMap"] = None,
+        system_settings: Optional["SystemSettings"] = None,
+        user_settings: Optional["UserSettings"] = None,
     ) -> None:
         """Initialize the command runner."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.router import CommandMap
+        from openbb_core.app.service.system_service import SystemService
+        from openbb_core.app.service.user_service import UserService
+
         self._command_map = command_map or CommandMap()
         self._system_settings = system_settings or SystemService().system_settings
         self._user_settings = user_settings or UserService.read_from_file()
 
     def init_logging_service(self) -> None:
         """Initialize the logging service."""
+        # pylint: disable=import-outside-toplevel
+        from openbb_core.app.logs.logging_service import LoggingService
+
         _ = LoggingService(
             system_settings=self._system_settings, user_settings=self._user_settings
         )
 
     @property
-    def command_map(self) -> CommandMap:
+    def command_map(self) -> "CommandMap":
         """Command map."""
         return self._command_map
 
     @property
-    def system_settings(self) -> SystemSettings:
+    def system_settings(self) -> "SystemSettings":
         """System settings."""
         return self._system_settings
 
     @property
-    def user_settings(self) -> UserSettings:
+    def user_settings(self) -> "UserSettings":
         """User settings."""
         return self._user_settings
 
     @user_settings.setter
-    def user_settings(self, user_settings: UserSettings) -> None:
+    def user_settings(self, user_settings: "UserSettings") -> None:
         self._user_settings = user_settings
 
     # pylint: disable=W1113
     async def run(
         self,
         route: str,
-        user_settings: Optional[UserSettings] = None,
+        user_settings: Optional["UserSettings"] = None,
         /,
         *args,
         **kwargs,
     ) -> OBBject:
         """Run a command and return the OBBject as output."""
+        # pylint: disable=import-outside-toplevel
+
         self._user_settings = user_settings or self._user_settings
 
         execution_context = ExecutionContext(
@@ -462,7 +476,7 @@ async def run(
     def sync_run(
         self,
         route: str,
-        user_settings: Optional[UserSettings] = None,
+        user_settings: Optional["UserSettings"] = None,
         /,
         *args,
         **kwargs,

openbb_platform/core/openbb_core/app/logs/formatters/formatter_with_exceptions.py

@@ -1,9 +1,6 @@
 """Logging Formatter that includes formatting of Exceptions."""
 
 import logging
-import re
-from copy import deepcopy
-from pathlib import Path
 
 from openbb_core.app.logs.models.logging_settings import LoggingSettings
 
@@ -46,6 +43,9 @@ def extract_log_extra(record: logging.LogRecord):
     @staticmethod
     def mock_ipv4(text: str) -> str:
         """Mock IPv4 addresses in the text."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         pattern = r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
         replacement = " FILTERED_IP "
         text_mocked = re.sub(pattern, replacement, text)
@@ -55,6 +55,9 @@ def mock_ipv4(text: str) -> str:
     @staticmethod
     def mock_email(text: str) -> str:
         """Mock email addresses in the text."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
         replacement = " FILTERED_EMAIL "
         text_mocked = re.sub(pattern, replacement, text)
@@ -64,6 +67,9 @@ def mock_email(text: str) -> str:
     @staticmethod
     def mock_password(text: str) -> str:
         """Mock passwords in the text."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         pattern = r'("password": ")[^"]+'
         replacement = r"\1 FILTERED_PASSWORD "
         text_mocked = re.sub(pattern, replacement, text)
@@ -72,6 +78,9 @@ def mock_password(text: str) -> str:
     @staticmethod
     def mock_flair(text: str) -> str:
         """Mock flair in the text."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         pattern = r'("FLAIR": "\[)(.*?)\]'
         replacement = r"\1 FILTERED_FLAIR ]"
         text_mocked = re.sub(pattern, replacement, text)
@@ -81,6 +90,9 @@ def mock_flair(text: str) -> str:
     @staticmethod
     def mock_home_directory(text: str) -> str:
         """Mock home directory in the text."""
+        # pylint: disable=import-outside-toplevel
+        from pathlib import Path
+
         user_home_directory = str(Path.home().as_posix())
         text_mocked = text.replace("\\", "/").replace(
             user_home_directory, "MOCKING_USER_PATH"
@@ -134,6 +146,9 @@ def __init__(
     @property
     def settings(self) -> LoggingSettings:
         """Get the settings."""
+        # pylint: disable=import-outside-toplevel
+        from copy import deepcopy
+
         return deepcopy(self.__settings)
 
     @settings.setter

openbb_platform/core/openbb_core/app/logs/handlers/posthog_handler.py

@@ -2,8 +2,6 @@
 
 import json
 import logging
-import re
-from copy import deepcopy
 from enum import Enum
 from typing import Any, Dict
 
@@ -28,15 +26,19 @@ class AllowedEvents(Enum):
 
     def __init__(self, settings: LoggingSettings):
         """Initialize Posthog Handler."""
+
         super().__init__()
         self._settings = settings
         self.logged_in = False
-        posthog.api_key = "phc_6FXLqu4uW9yxfyN8DpPdgzCdlYXOmIWdMGh6GnBgJLX"  # pragma: allowlist secret
-        posthog.host = "https://app.posthog.com"
+        posthog.api_key = "phc_6FXLqu4uW9yxfyN8DpPdgzCdlYXOmIWdMGh6GnBgJLX"  # pragma: allowlist secret  # noqa
+        posthog.host = "https://app.posthog.com"  # noqa
 
     @property
     def settings(self) -> LoggingSettings:
         """Get logging settings."""
+        # pylint: disable=import-outside-toplevel
+        from copy import deepcopy
+
         return deepcopy(self._settings)
 
     @settings.setter
@@ -78,6 +80,9 @@ def identify(self) -> None:
 
     def log_to_dict(self, log_info: str) -> dict:
         """Log to dict."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         log_regex = r"(STARTUP|CMD|ERROR): (.*)"
         log_dict: Dict[str, Any] = {}
 
@@ -88,6 +93,9 @@ def log_to_dict(self, log_info: str) -> dict:
 
     def send(self, record: logging.LogRecord):
         """Send log record to Posthog."""
+        # pylint: disable=import-outside-toplevel
+        import re
+
         level_name = logging.getLevelName(record.levelno)
         log_line = FormatterWithExceptions.filter_log_line(text=record.getMessage())
 

openbb_platform/core/openbb_core/app/model/charts/charting_settings.py

@@ -1,24 +1,36 @@
 """Charting settings."""
 
+import importlib
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from openbb_core.app.logs.utils.utils import get_app_id
-from openbb_core.app.model.system_settings import SystemSettings
-from openbb_core.app.model.user_settings import UserSettings
 from openbb_core.env import Env
 
+if TYPE_CHECKING:
+    from openbb_core.app.model.system_settings import SystemSettings
+    from openbb_core.app.model.user_settings import UserSettings
+
 
 # pylint: disable=too-many-instance-attributes
 class ChartingSettings:
     """Charting settings."""
 
     def __init__(
         self,
-        user_settings: Optional[UserSettings] = None,
-        system_settings: Optional[SystemSettings] = None,
+        user_settings: Optional["UserSettings"] = None,
+        system_settings: Optional["SystemSettings"] = None,
     ):
         """Initialize charting settings."""
+        user_settings_module = importlib.import_module(
+            "openbb_core.app.model.user_settings", "UserSettings"
+        )
+        system_settings_module = importlib.import_module(
+            "openbb_core.app.model.system_settings", "SystemSettings"
+        )
+
+        UserSettings = user_settings_module.UserSettings
+        SystemSettings = system_settings_module.SystemSettings
         user_settings = user_settings or UserSettings()
         system_settings = system_settings or SystemSettings()
 

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

@@ -86,10 +86,10 @@ def load(self) -> BaseModel:
         # We load providers first to give them priority choosing credential names
         self.from_providers()
         self.from_obbject()
-        model = create_model(  # type: ignore
+        model = create_model(
             "Credentials",
             __config__=ConfigDict(validate_assignment=True, populate_by_name=True),
-            **self.format_credentials(),
+            **self.format_credentials(),  # type: ignore
         )
         model.origins = self.credentials
         return model

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

@@ -1,11 +1,8 @@
 """Metadata model."""
 
 from datetime import datetime
-from inspect import isclass
 from typing import Any, Dict, Optional, Sequence, Union
 
-import numpy as np
-import pandas as pd
 from pydantic import BaseModel, Field, field_validator
 
 from openbb_core.provider.abstract.data import Data
@@ -41,6 +38,11 @@ def scale_arguments(cls, v):
         containing the type and the columns. If the type is not one of the previous, the
         value is kept or trimmed to 80 characters.
         """
+        # pylint: disable=import-outside-toplevel
+        from inspect import isclass  # noqa
+        from numpy import ndarray  # noqa
+        from pandas import DataFrame, Series  # noqa
+
         arguments: Dict[str, Any] = {}
         for item in ["provider_choices", "standard_params", "extra_params"]:
             arguments[item] = {}
@@ -72,7 +74,7 @@ def scale_arguments(cls, v):
                     }
 
                 # DataFrame
-                elif isinstance(arg_val, pd.DataFrame):
+                elif isinstance(arg_val, DataFrame):
                     df_columns = (
                         list(arg_val.index.names) + arg_val.columns.tolist()
                         if any(index is not None for index in list(arg_val.index.names))
@@ -85,7 +87,7 @@ def scale_arguments(cls, v):
 
                 # List[DataFrame]
                 elif isinstance(arg_val, list) and issubclass(
-                    type(arg_val[0]), pd.DataFrame
+                    type(arg_val[0]), DataFrame
                 ):
                     ldf_columns = [
                         (
@@ -101,14 +103,14 @@ def scale_arguments(cls, v):
                     }
 
                 # Series
-                elif isinstance(arg_val, pd.Series):
+                elif isinstance(arg_val, Series):
                     new_arg_val = {
                         "type": f"{type(arg_val).__name__}",
                         "columns": list(arg_val.index.names) + [arg_val.name],
                     }
 
                 # List[Series]
-                elif isinstance(arg_val, list) and isinstance(arg_val[0], pd.Series):
+                elif isinstance(arg_val, list) and isinstance(arg_val[0], Series):
                     ls_columns = [
                         (
                             list(series.index.names) + [series.name]
@@ -125,7 +127,7 @@ def scale_arguments(cls, v):
                     }
 
                 # ndarray
-                elif isinstance(arg_val, np.ndarray):
+                elif isinstance(arg_val, ndarray):
                     new_arg_val = {
                         "type": f"{type(arg_val).__name__}",
                         "columns": list(arg_val.dtype.names or []),