investing-algorithm-framework 7.19.14__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/positions/__init__.py

@@ -0,0 +1,4 @@
+from .position_size import PositionSize
+
+
+__all__ = ["PositionSize"]

investing_algorithm_framework/domain/positions/position_size.py

@@ -0,0 +1,41 @@
+from typing import Optional
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+
+class PositionSize:
+    """
+    Defines how much capital to allocate to a specific symbol.
+    """
+
+    def __init__(
+        self,
+        symbol: str,
+        percentage_of_portfolio: Optional[float] = None,
+        fixed_amount: Optional[float] = None
+    ):
+        self.symbol = symbol
+        self.percentage_of_portfolio = percentage_of_portfolio
+        self.fixed_amount = fixed_amount
+
+    def get_size(self, portfolio, asset_price) -> float:
+        """
+        Calculate size in currency/units.
+        """
+        if self.fixed_amount is not None:
+            return self.fixed_amount
+        elif self.percentage_of_portfolio is not None:
+            total_value = portfolio.get_unallocated() + portfolio.allocated
+            return total_value * (self.percentage_of_portfolio / 100)
+        else:
+            raise OperationalException(
+                "A position size object must have either a fixed amount or a "
+                "percentage of the portfolio defined."
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"PositionSize(symbol={self.symbol}, "
+            f"percentage_of_portfolio={self.percentage_of_portfolio}, "
+            f"fixed_amount={self.fixed_amount})"
+        )

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/stateless_actions.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class StatelessActions(Enum):
+    RUN_STRATEGY = 'RUN_STRATEGY'
+    CHECK_PENDING_ORDERS = 'CHECK_PENDING_ORDERS'
+    PING = 'PING'

investing_algorithm_framework/domain/strategy.py

@@ -0,0 +1,44 @@
+from .models import TimeUnit
+
+
+class Strategy:
+
+    def __init__(
+        self,
+        market=None,
+        time_unit=None,
+        interval=None,
+        worker_id=None,
+        symbols=None,
+        limit=None,
+    ):
+        self._market = market
+        self._time_unit = TimeUnit.from_value(time_unit).value
+        self._interval = interval
+        self._symbols = symbols
+        self._limit = limit
+        self._worker_id = worker_id
+
+    @property
+    def market(self):
+        return self._market
+
+    @property
+    def time_unit(self):
+        return self._time_unit
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @property
+    def symbols(self):
+        return self._symbols
+
+    @property
+    def limit(self):
+        return self._limit
+
+    @property
+    def worker_id(self):
+        return self._worker_id

investing_algorithm_framework/domain/utils/__init__.py

@@ -0,0 +1,27 @@
+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 .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',
+    '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

@@ -0,0 +1,104 @@
+import csv
+import shutil
+import tempfile
+from typing import Dict, List
+
+from ..exceptions import OperationalException
+
+
+# Function to add column headers to csv
+def add_column_headers_to_csv(file_name: str, column_names: List[str]) -> None:
+
+    # Open file in append mode
+    with open(file_name, 'a+', newline='') as write_obj:
+
+        # Create a writer object from csv module
+        csv_writer = csv.writer(write_obj)
+
+        # Add the columns
+        csv_writer.writerow(column_names)
+
+
+# Function to append dict as a row to csv
+def append_dict_as_row_to_csv(
+        file_name: str, dict_data: Dict, field_names: List[str]
+) -> None:
+    result_dict = {field: dict_data[field] for field in field_names}
+
+    # Open file in append mode
+    with open(file_name, 'a', newline='') as write_obj:
+        # Create a writer object from csv module
+        dict_writer = csv.DictWriter(write_obj, fieldnames=field_names)
+        # Add dictionary as wor in the csv
+        dict_writer.writerow(result_dict)
+
+
+def get_total_amount_of_rows(file_path: str):
+    file = open(file_path)
+    reader = csv.reader(file)
+    rows_count = len(list(reader))
+    file.close()
+    return rows_count
+
+
+# Function to convert a csv to a list of data_provider
+def csv_to_list(csv_path: str, strip_column_headers: bool = False) -> List:
+    data = []
+    with open(csv_path, "r") as csv_f:
+        reader = csv.reader(csv_f, delimiter=',')
+
+        for row in reader:
+
+            if row:  # avoid blank lines
+                data.append(row)
+
+    # Delete columns
+    if strip_column_headers:
+        del data[0]
+
+    return data
+
+
+# Function to remove a row of a csv corresponding to a particular index
+def remove_row(csv_path: str, row_index: int) -> None:
+
+    if row_index < 0:
+        raise OperationalException('Negative index number')
+
+    _, temp_file = tempfile.mkstemp(suffix='.csv')
+
+    with open(csv_path, 'r') as inf, open(temp_file, 'w') as out_f:
+        writer = csv.writer(out_f)
+        index = 0
+
+        for row in csv.reader(inf):
+
+            # Copy every row except the index row
+            if index != row_index:
+                writer.writerow(row)
+
+            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)