investing-algorithm-framework 1.5__py3-none-any.whl → 7.25.6__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

@@ -0,0 +1,11 @@
+from .market_credential_service import MarketCredentialService
+from .portfolios import AbstractPortfolioSyncService
+from .rounding_service import RoundingService
+from .state_handler import StateHandler
+
+__all__ = [
+    "MarketCredentialService",
+    "AbstractPortfolioSyncService",
+    "RoundingService",
+    "StateHandler",
+]

investing_algorithm_framework/domain/services/market_credential_service.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from investing_algorithm_framework.domain import MarketCredential
+
+
+class MarketCredentialService(ABC):
+    """
+    This class is responsible for managing the market credentials of the app.
+    """
+    @abstractmethod
+    def add(self, market_data_credential: MarketCredential):
+        """
+        Add a market credential in the repository
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def add_all(self, market_data_credentials: List[MarketCredential]):
+        """
+        Add a list of market credentials in the repository
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get(self, market) -> Optional[MarketCredential]:
+        """
+        Get a market credential from the repository
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_all(self) -> List[MarketCredential]:
+        """
+        Get all market credentials from the repository
+        """
+        raise NotImplementedError()

investing_algorithm_framework/domain/services/portfolios/__init__.py

@@ -0,0 +1,5 @@
+from .portfolio_sync_service import AbstractPortfolioSyncService
+
+__all__ = [
+    "AbstractPortfolioSyncService"
+]

investing_algorithm_framework/domain/services/portfolios/portfolio_sync_service.py

@@ -0,0 +1,9 @@
+class AbstractPortfolioSyncService:
+    """
+    Service to sync the portfolio with the exchange.
+    """
+    def sync_unallocated(self, portfolio):
+        pass
+
+    def sync_orders(self, portfolio):
+        pass

investing_algorithm_framework/domain/services/rounding_service.py

@@ -0,0 +1,27 @@
+import decimal
+
+
+class RoundingService:
+    """
+    Service to round numbers to a certain amount of decimals.
+    It will always round down.
+    """
+
+    @staticmethod
+    def round_down(value, amount_of_decimals):
+
+        if RoundingService.count_decimals(value) <= amount_of_decimals:
+            return value
+
+        with decimal.localcontext() as ctx:
+            d = decimal.Decimal(value)
+            ctx.rounding = decimal.ROUND_DOWN
+            return float(round(d, amount_of_decimals))
+
+    @staticmethod
+    def count_decimals(number):
+        decimal_str = str(number)
+        if '.' in decimal_str:
+            return len(decimal_str.split('.')[1])
+        else:
+            return 0

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,17 +1,27 @@
-from .random import random_string
+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, random_number
 from .stoppable_thread import StoppableThread
 from .synchronized import synchronized
-from .csv import get_total_amount_of_rows, append_dict_as_row_to_csv, \
-    add_column_headers_to_csv, csv_to_list
-from .backtesting import pretty_print_backtest
+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'
+    'load_csv_into_dict',
+    'convert_polars_to_pandas',
+    'is_timezone_aware',
+    'sync_timezones',
+    'get_timezone',
+    'is_jupyter_notebook',
+    'tqdm'
 ]

investing_algorithm_framework/domain/utils/csv.py

@@ -80,3 +80,25 @@ def remove_row(csv_path: str, row_index: int) -> None:
             index += 1
 
     shutil.move(temp_file, csv_path)
+
+
+def load_csv_into_dict(file_path) -> Dict:
+    """
+      Load a CSV file into a dictionary.
+
+      Args:
+          file_path (str): Path to the CSV file.
+
+      Returns:
+          dict: Dictionary containing the data loaded from the CSV file.
+      """
+    data_dict = {}
+
+    with open(file_path, 'r', newline='', encoding='utf-8') as csvfile:
+        csv_reader = csv.DictReader(csvfile)
+
+        for row in csv_reader:
+            for key, value in row.items():
+                data_dict[key] = value
+
+    return data_dict

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)))