investing-algorithm-framework 3.7.0__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/domain/order_executor.py

@@ -0,0 +1,112 @@
+from abc import ABC, abstractmethod
+
+from investing_algorithm_framework.domain import Order
+
+
+class OrderExecutor(ABC):
+    """
+    Abstract base class for order executors. The OrderExecutor class is
+    responsible for executing orders in a trading algorithm.
+
+    Attributes:
+        _priority (int): The priority of the order executor compared to
+            other order executors. The lower the number, the higher the
+            priority. The framework will use this priority when searching
+            for an order executor for a specific market.
+        _config (dict): Reference to the application configuration.
+    """
+
+    def __init__(self, priority=1):
+        self._priority = priority
+        self._config = None
+
+    @property
+    def priority(self):
+        """
+        Returns the priority of the order executor.
+        """
+        return self._priority
+
+    @property
+    def config(self):
+        """
+        Returns the configuration of the order executor.
+        This can be used to store any configuration that is needed
+        for the order executor.
+        """
+        return self._config
+
+    @config.setter
+    def config(self, config):
+        """
+        Setter for the app config. This will be used to set a reference
+        to the config of the Application when the app is started.
+        """
+        self._config = config
+
+    @abstractmethod
+    def execute_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Executes an order for a given portfolio. The order executor should
+        create an order on the exchange or broker and return an order object
+        that reflects the order on the exchange or broker. This should be
+        done by setting the external_id of the order to the id of the order
+        on the exchange or broker.
+
+        !Important: This function should not throw an exception if the order
+        is not successfully executed. Instead, it should return an order
+        instance with the status set to OrderStatus.FAILED.
+
+        Args:
+            order: The order to be executed
+            portfolio: The portfolio in which the order will be executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the executed order. The order instance
+            should copy the id of the order that has been provided as a
+        """
+        raise NotImplementedError(
+            "Subclasses must implement this method."
+        )
+
+    @abstractmethod
+    def cancel_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Cancels an order for a given portfolio. The order executor should
+        cancel the order on the exchange or broker and return an order
+        object that reflects the order on the exchange or broker.
+
+        Args:
+            order: The order to be canceled
+            portfolio: The portfolio in which the order was executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the canceled order.
+        """
+        raise NotImplementedError(
+            "Subclasses must implement this method."
+        )
+
+    @abstractmethod
+    def supports_market(self, market):
+        """
+        Checks if the order executor supports the given market.
+
+        Args:
+            market: The market to check
+
+        Returns:
+            bool: True if the order executor supports the market, False
+                otherwise.
+        """
+        raise NotImplementedError(
+            "Subclasses must implement this method."
+        )
+
+    def __repr__(self):
+        """
+        Returns a string representation of the order executor.
+        """
+        return f"{self.__class__.__name__}(priority={self._priority})"

investing_algorithm_framework/domain/portfolio_provider.py

@@ -0,0 +1,118 @@
+from typing import Union
+from abc import ABC, abstractmethod
+
+from investing_algorithm_framework.domain import Order, Position
+
+
+class PortfolioProvider(ABC):
+    """
+    Abstract base class for portfolio providers. The PortfolioProvider class
+    is responsible for managing and providing access to trading portfolios.
+
+    Attributes:
+        _priority (int): The priority of the portfolio provider compared to
+            other portfolio providers. The lower the number, the higher the
+            priority. The framework will use this priority when searching
+            for a portfolio provider for a specific symbol or market.
+        _config (dict): Reference to the application configuration.
+    """
+
+    def __init__(self, priority=1):
+        self._priority = priority
+        self._config = None
+
+    @property
+    def priority(self):
+        """
+        Returns the priority of the portfolio provider.
+        """
+        return self._priority
+
+    @priority.setter
+    def priority(self, value: int):
+        """
+        Sets the priority of the portfolio provider.
+        """
+        self._priority = value
+
+    @property
+    def config(self):
+        """
+        Returns the configuration of the order executor.
+        This can be used to store any configuration that is needed
+        for the order executor.
+        """
+        return self._config
+
+    @config.setter
+    def config(self, config):
+        """
+        Setter for the app config. This will be used to set a reference
+        to the config of the Application when the app is started.
+        """
+        self._config = config
+
+    @abstractmethod
+    def get_order(
+        self, portfolio, order, market_credential
+    ) -> Union[Order, None]:
+        """
+        Function to get an order from the exchange or broker. The returned
+        should be an order object that reflects the current state of the
+        order on the exchange or broker.
+
+        !IMPORTANT: This function should return None if the order is
+        not found or if the order is not available on the
+        exchange or broker. Please do not throw an exception if the
+        order is not found.
+
+        Args:
+            portfolio: Portfolio object
+            order: Order object from the database
+            market_credential: Market credential object
+
+        Returns:
+            Order: Order object reflecting the order on the exchange or broker
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    @abstractmethod
+    def get_position(
+        self, portfolio, symbol, market_credential
+    ) -> Union[Position, None]:
+        """
+        Function to get the position for a given symbol in the portfolio.
+        The returned position should be an object that reflects the current
+        state of the position on the exchange or broker.
+
+        !IMPORTANT: This function should return None if the position is
+        not found or if the position is not available on the
+        exchange or broker. Please do not throw an exception if the
+        position is not found.
+
+        Args:
+            portfolio: Portfolio object
+            symbol: Symbol object
+            market_credential: MarketCredential object
+
+        Returns:
+            float: Position for the given symbol in the portfolio
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    @abstractmethod
+    def supports_market(self, market) -> bool:
+        """
+        Function to check if the market is supported by the portfolio
+        provider.
+
+        Args:
+            market: Market object
+
+        Returns:
+            bool: True if the market is supported, False otherwise
+        """
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(priority={self.priority})"

investing_algorithm_framework/domain/services/__init__.py

@@ -1,18 +1,11 @@
 from .market_credential_service import MarketCredentialService
-from .market_data_sources import MarketDataSource, TickerMarketDataSource, \
-    OHLCVMarketDataSource, OrderBookMarketDataSource, BacktestMarketDataSource
-from .market_service import MarketService
 from .portfolios import AbstractPortfolioSyncService
 from .rounding_service import RoundingService
+from .state_handler import StateHandler
 
 __all__ = [
-    "MarketDataSource",
-    "TickerMarketDataSource",
-    "OHLCVMarketDataSource",
-    "OrderBookMarketDataSource",
-    "BacktestMarketDataSource",
-    "MarketService",
     "MarketCredentialService",
     "AbstractPortfolioSyncService",
     "RoundingService",
+    "StateHandler",
 ]

investing_algorithm_framework/domain/services/portfolios/portfolio_sync_service.py

@@ -5,11 +5,5 @@ class AbstractPortfolioSyncService:
     def sync_unallocated(self, portfolio):
         pass
 
-    def sync_positions(self, portfolio):
-        pass
-
     def sync_orders(self, portfolio):
         pass
-
-    def sync_trades(self, portfolio):
-        pass

investing_algorithm_framework/domain/services/state_handler.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+
+
+class StateHandler(ABC):
+    """
+    Abstract base class for state handlers.
+
+    This class defines the
+    interface for state handlers, which are responsible for
+    saving and loading state information.
+    """
+
+    @abstractmethod
+    def initialize(self):
+        """
+        Initialize the state handler.
+        """
+        pass
+
+    @abstractmethod
+    def save(self, target_directory: str):
+        """
+        Save the state to the specified directory.
+
+        Args:
+            target_directory (str): Directory to save the state
+        """
+        pass
+
+    @abstractmethod
+    def load(self, target_directory: str):
+        """
+        Load the state from the specified directory.
+
+        Args:
+            target_directory (str): Directory to load the state
+        """
+        pass

investing_algorithm_framework/domain/strategy.py

@@ -1,4 +1,4 @@
-from .models import TradingTimeFrame, TradingDataType, TimeUnit
+from .models import TimeUnit
 
 
 class Strategy:
@@ -11,9 +11,6 @@ class Strategy:
         worker_id=None,
         symbols=None,
         limit=None,
-        trading_data_type=None,
-        trading_data_types=None,
-        trading_time_frame=None,
     ):
         self._market = market
         self._time_unit = TimeUnit.from_value(time_unit).value
@@ -22,19 +19,6 @@ class Strategy:
         self._limit = limit
         self._worker_id = worker_id
 
-        if trading_data_type is not None:
-            self._trading_data_type = TradingDataType \
-                .from_value(trading_data_type)
-
-        if trading_data_types is not None:
-            trading_data_types = [TradingDataType.from_value(trading_data_type)
-                                  for trading_data_type in trading_data_types]
-            self._trading_data_types = trading_data_types
-
-        if trading_time_frame is not None:
-            self._trading_time_frame = TradingTimeFrame \
-                .from_value(trading_time_frame)
-
     @property
     def market(self):
         return self._market
@@ -55,18 +39,6 @@ class Strategy:
     def limit(self):
         return self._limit
 
-    @property
-    def trading_data_type(self):
-        return self._trading_data_type
-
-    @property
-    def trading_data_types(self):
-        return self._trading_data_types
-
-    @property
-    def trading_time_frame(self):
-        return self._trading_time_frame
-
     @property
     def worker_id(self):
         return self._worker_id

investing_algorithm_framework/domain/utils/__init__.py

@@ -1,22 +1,27 @@
-from .backtesting import pretty_print_backtest, load_backtest_report, \
-    pretty_print_backtest_reports_evaluation, load_backtest_reports
 from .csv import get_total_amount_of_rows, append_dict_as_row_to_csv, \
     add_column_headers_to_csv, csv_to_list, load_csv_into_dict
-from .random import random_string
+from .random import random_string, random_number
 from .stoppable_thread import StoppableThread
 from .synchronized import synchronized
+from .polars import convert_polars_to_pandas
+from .dates import is_timezone_aware, sync_timezones, get_timezone
+from .jupyter_notebook_detection import is_jupyter_notebook
+from .custom_tqdm import tqdm
 
 __all__ = [
     'synchronized',
     'StoppableThread',
     'random_string',
+    'random_number',
     'get_total_amount_of_rows',
     'append_dict_as_row_to_csv',
     'add_column_headers_to_csv',
     'csv_to_list',
-    'pretty_print_backtest',
-    'pretty_print_backtest_reports_evaluation',
     'load_csv_into_dict',
-    'load_backtest_report',
-    'load_backtest_reports',
+    'convert_polars_to_pandas',
+    'is_timezone_aware',
+    'sync_timezones',
+    'get_timezone',
+    'is_jupyter_notebook',
+    'tqdm'
 ]

investing_algorithm_framework/domain/utils/custom_tqdm.py

@@ -0,0 +1,22 @@
+from tqdm.notebook import tqdm as tqdm_notebook
+from tqdm import tqdm as tqdm_terminal
+
+from .jupyter_notebook_detection import is_jupyter_notebook
+
+
+def tqdm(*args, **kwargs):
+    """
+    Returns a tqdm progress bar that adapts to the
+    environment (Jupyter Notebook or terminal).
+
+    Args:
+        *args: Positional arguments for tqdm.
+        **kwargs: Keyword arguments for tqdm.
+
+    Returns:
+        tqdm object: A tqdm progress bar.
+    """
+    if is_jupyter_notebook():
+        return tqdm_notebook(*args, **kwargs)
+    else:
+        return tqdm_terminal(*args, **kwargs)

investing_algorithm_framework/domain/utils/dates.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+from typing import Optional
+import pytz
+
+
+def is_timezone_aware(dt: datetime) -> bool:
+    """
+    Check if a datetime object is timezone-aware.
+
+    Args:
+        dt (datetime): The datetime object to check.
+
+    Returns:
+        bool: True if the datetime is timezone-aware, False otherwise.
+    """
+    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None
+
+
+def get_timezone(dt: datetime) -> Optional[pytz.tzinfo.BaseTzInfo]:
+    """
+    Returns the timezone info from a datetime object.
+
+    Args:
+        dt (datetime): The datetime object to check.
+
+    Returns:
+        pytz timezone info if available, otherwise None.
+    """
+    if dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None:
+        return dt.tzinfo
+    return None
+
+
+def sync_timezones(reference_dt: datetime, naive_dt: datetime) -> datetime:
+    """
+    Synchronize a naive datetime with the timezone of a reference datetime.
+
+    Args:
+        reference_dt (datetime): A timezone-aware datetime to
+            use as a reference.
+        naive_dt (datetime): A naive datetime to be synchronized.
+
+    Returns:
+        Datetime: A timezone-aware datetime that matches the
+            timezone of the reference.
+    """
+    tz = get_timezone(reference_dt)
+
+    if tz is None:
+        return naive_dt
+
+    # Check if tz has a localize method (pytz)
+    if hasattr(tz, 'localize'):
+        return tz.localize(naive_dt)
+    else:
+        # fallback (e.g., zoneinfo or other)
+        return naive_dt.replace(tzinfo=tz)

investing_algorithm_framework/domain/utils/jupyter_notebook_detection.py

@@ -0,0 +1,19 @@
+def is_jupyter_notebook():
+    """
+    Check if the code is running in a Jupyter Notebook environment.
+
+    Returns:
+        bool: True if running in a Jupyter Notebook, False otherwise.
+    """
+    try:
+        # Check for the presence of the 'IPython' module
+        from IPython import get_ipython
+        return 'IPKernelApp' in get_ipython().config
+    except ImportError:
+        return False
+    except AttributeError:
+        # If get_ipython() does not have 'config', it is not a Jupyter Notebook
+        return False
+    except Exception:
+        # Catch any other exceptions and return False
+        return False

investing_algorithm_framework/domain/utils/polars.py

@@ -0,0 +1,53 @@
+import pandas as pd
+from polars import DataFrame as PolarsDataFrame
+
+
+def convert_polars_to_pandas(
+    data: PolarsDataFrame,
+    remove_duplicates=True,
+    add_index=True,
+    add_datetime_column=True,
+    datetime_column_name="Datetime"
+):
+    """
+    Function to convert polars dataframe to pandas dataframe.
+
+    The function will set the index to the datetime column. The reason
+    for this is that You can filter with clean, readable code in a faster way
+    then with filtering on a column that is not the index.
+
+    Args:
+        data:Polars Dataframe - The original polars dataframe
+        remove_duplicates: Boolean - If set to true, all duplicate
+        dates will be removed from the dataframe
+        add_index: Boolean - If set to true, an index will
+            be added to the dataframe
+        add_datetime_column: Boolean - If set to true, a datetime
+            column will be added to the dataframe
+        datetime_column_name: String - the column name that has the
+            datetime object. By default this is set to column name Datetime
+            This is only used if add_index is set to True
+
+    Returns:
+        DataFrame: Pandas DataFrame that has been converted
+          from a Polars DataFrame
+    """
+
+    if not isinstance(data, PolarsDataFrame):
+        raise ValueError("Data must be a Polars DataFrame")
+
+    df = data.to_pandas().copy()
+
+    if add_datetime_column and datetime_column_name not in df.columns:
+        df[datetime_column_name] = pd.to_datetime(df.index)
+
+    # Ensure datetime column is datetime type
+    df[datetime_column_name] = pd.to_datetime(df[datetime_column_name])
+
+    if remove_duplicates:
+        df = df.drop_duplicates(subset=datetime_column_name, keep="first")
+
+    if add_index:
+        df.set_index(datetime_column_name, inplace=True)
+
+    return df

investing_algorithm_framework/domain/utils/random.py

@@ -3,6 +3,16 @@ import string
 
 
 def random_string(n, spaces: bool = False):
+    """
+    Function to generate a random string of n characters.
+
+    Args:
+        n: number of characters
+        spaces: if True, include spaces in the string
+
+    Returns:
+        str: Random string of n characters
+    """
 
     if spaces:
         return ''.join(
@@ -10,3 +20,22 @@ def random_string(n, spaces: bool = False):
         )
 
     return ''.join(random.choice(string.ascii_lowercase) for _ in range(n))
+
+
+def random_number(n, variable_size: bool = False):
+    """
+    Function to generate a random number of n digits.
+
+    Args:
+        n: number of digits
+        variable_size: if True, the number of digits will be variable
+            between 1 and n
+
+    Returns:
+        int: Random number of n digits
+    """
+
+    if variable_size:
+        n = random.randint(1, n)
+
+    return int(''.join(random.choice(string.digits) for _ in range(n)))

investing_algorithm_framework/download_data.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from dateutil import parser
+from datetime import timezone, datetime
+import pandas
+import polars
+from typing import Union
+from investing_algorithm_framework.services import DataProviderService, \
+    ConfigurationService, MarketCredentialService
+from investing_algorithm_framework.infrastructure import \
+    get_default_data_providers
+from investing_algorithm_framework.domain import DataSource, \
+    OperationalException, DataType
+
+
+def download(
+    symbol: str,
+    market: str = None,
+    date: Union[datetime, str] = None,
+    time_frame: str = None,
+    data_type: Union[str, DataType] = DataType.OHLCV,
+    start_date: Union[datetime, str] = None,
+    end_date: Union[datetime, str] = None,
+    window_size: int = 200,
+    pandas: bool = True,
+    save: bool = True,
+    storage_path: Union[str, Path] = None,
+) -> Union[pandas.DataFrame, polars.DataFrame]:
+    """
+    Download market data from the specified source. This function
+    uses the MarketDataSourceService to get the data provider
+    for the given set of parameters.
+
+    Args:
+        symbol (str): The symbol to download data for.
+        market (str): The market to download data from.
+        data_type (str): The type of data to
+            download (e.g., "ohlcv", "ticker").
+        start_date (str): The start date for the data download.
+        end_date (str): The end date for the data download.
+        window_size (int): The size of the data window.
+        pandas (bool): Whether to return the data as a pandas DataFrame.
+        save (bool): Whether to save the downloaded data.
+        storage_path (str): The directory to save the downloaded data.
+        time_frame (str): The time frame for the data download.
+        date (str): The date for the data download.
+        window_size (int): The size of the data window.
+        pandas (bool): Whether to return the data as a pandas DataFrame.
+
+    Returns:
+        None
+    """
+    configuration_service = ConfigurationService()
+    market_credential_service = MarketCredentialService()
+    data_provider_service = DataProviderService(
+        default_data_providers=get_default_data_providers(),
+        configuration_service=configuration_service,
+        market_credential_service=market_credential_service,
+    )
+
+    if start_date is not None and isinstance(start_date, str):
+        start_date = parser.parse(start_date)
+        start_date = start_date.replace(tzinfo=timezone.utc)
+
+    if end_date is not None and isinstance(end_date, str):
+        end_date = parser.parse(end_date)
+        end_date = end_date.replace(tzinfo=timezone.utc)
+
+    if date is not None and isinstance(date, str):
+        date = parser.parse(date)
+        date = date.replace(tzinfo=timezone.utc)
+
+    # Check if all the datetime parameters are in UTC
+    if date is not None \
+            and (date.tzinfo is None or date.tzinfo != timezone.utc):
+        raise OperationalException("Date must be a UTC datetime object")
+
+    if start_date is not None \
+            and (
+                start_date.tzinfo is None or start_date.tzinfo != timezone.utc
+            ):
+        raise OperationalException("Start date must be a UTC datetime object")
+
+    if end_date is not None \
+            and (end_date.tzinfo is None or end_date.tzinfo != timezone.utc):
+        raise OperationalException("End date must be a UTC datetime object")
+
+    data_source = DataSource(
+        symbol=symbol,
+        market=market,
+        data_type=data_type,
+        time_frame=time_frame,
+        date=date,
+        start_date=start_date,
+        end_date=end_date,
+        window_size=window_size,
+        pandas=pandas,
+        save=save,
+        storage_path=storage_path
+    )
+    data_provider_service.index_data_providers(
+        data_sources=[data_source]
+    )
+    return data_provider_service.get_data(
+        data_source=data_source,
+        date=date,
+        start_date=start_date,
+        end_date=end_date,
+    )