investing-algorithm-framework 7.19.14__py3-none-any.whl

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

@@ -0,0 +1,41 @@
+import random
+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(
+            random.choice(string.ascii_lowercase + ' ') for _ in range(n)
+        )
+
+    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/domain/utils/signatures.py

@@ -0,0 +1,17 @@
+import hashlib
+import hmac
+
+
+# Function to create a sha256 signature
+def create_sha256_signature(secret_key: str, params: str):
+
+    # Encode the secret key
+    byte_secret_key = bytearray()
+    byte_secret_key.extend(map(ord, secret_key))
+
+    # Encode the params
+    encoded_params = params.encode()
+
+    # Create signature
+    return hmac.new(byte_secret_key, encoded_params, hashlib.sha256)\
+        .hexdigest()

investing_algorithm_framework/domain/utils/stoppable_thread.py

@@ -0,0 +1,26 @@
+import threading
+
+
+class StoppableThread(threading.Thread):
+    """Thread class with a stop() method. The thread itself has to check
+    regularly for the stopped() condition."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._stop_event = threading.Event()
+        self.done = False
+        self._name = None
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+
+    def stop(self):
+        self._stop_event.set()
+
+    def stopped(self):
+        return self._stop_event.is_set()

investing_algorithm_framework/domain/utils/synchronized.py

@@ -0,0 +1,12 @@
+import functools
+import threading
+
+
+def synchronized(function):
+    lock = threading.Lock()
+
+    @functools.wraps(function)
+    def wrapper(self, *args, **kwargs):
+        with lock:
+            return function(self, *args, **kwargs)
+    return wrapper

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

investing_algorithm_framework/infrastructure/__init__.py

@@ -0,0 +1,50 @@
+from .database import setup_sqlalchemy, Session, \
+    create_all_tables, clear_db
+from .models import SQLPortfolio, SQLOrder, SQLPosition, \
+    SQLPortfolioSnapshot, SQLPositionSnapshot, SQLTrade, \
+    SQLTradeTakeProfit, SQLTradeStopLoss
+from .repositories import SQLOrderRepository, SQLPositionRepository, \
+    SQLPortfolioRepository, SQLTradeRepository, \
+    SQLPortfolioSnapshotRepository, SQLPositionSnapshotRepository, \
+    SQLTradeTakeProfitRepository, SQLTradeStopLossRepository, \
+    SQLOrderMetadataRepository
+from .services import AzureBlobStorageStateHandler, AWSS3StorageStateHandler
+from .data_providers import CSVOHLCVDataProvider, get_default_data_providers, \
+    get_default_ohlcv_data_providers, CCXTOHLCVDataProvider, \
+    PandasOHLCVDataProvider
+from .order_executors import CCXTOrderExecutor, BacktestOrderExecutor
+from .portfolio_providers import CCXTPortfolioProvider
+
+__all__ = [
+    "clear_db",
+    "create_all_tables",
+    "SQLPositionRepository",
+    "SQLPortfolioRepository",
+    "SQLOrderRepository",
+    "SQLPortfolioSnapshotRepository",
+    "SQLPositionSnapshotRepository",
+    "setup_sqlalchemy",
+    "Session",
+    "SQLPortfolio",
+    "SQLTrade",
+    "SQLOrder",
+    "SQLPosition",
+    "SQLPortfolioSnapshot",
+    "SQLPositionSnapshot",
+    "AzureBlobStorageStateHandler",
+    "SQLTradeRepository",
+    "SQLTradeTakeProfit",
+    "SQLTradeStopLoss",
+    "SQLTradeTakeProfitRepository",
+    "SQLTradeStopLossRepository",
+    "SQLOrderMetadataRepository",
+    "CSVOHLCVDataProvider",
+    "CCXTOrderExecutor",
+    "CCXTPortfolioProvider",
+    "get_default_data_providers",
+    "get_default_ohlcv_data_providers",
+    "AWSS3StorageStateHandler",
+    "CCXTOHLCVDataProvider",
+    "BacktestOrderExecutor",
+    "PandasOHLCVDataProvider",
+]

investing_algorithm_framework/infrastructure/data_providers/__init__.py

@@ -0,0 +1,36 @@
+from .ccxt import CCXTOHLCVDataProvider
+from .csv import CSVOHLCVDataProvider
+from .pandas import PandasOHLCVDataProvider
+
+
+def get_default_data_providers():
+    """
+    Function to get the default data providers.
+
+    Returns:
+        list: List of default data providers.
+    """
+    return [
+        CCXTOHLCVDataProvider(),
+    ]
+
+
+def get_default_ohlcv_data_providers():
+    """
+    Function to get the default OHLCV data providers.
+
+    Returns:
+        list: List of default OHLCV data providers.
+    """
+    return [
+        CCXTOHLCVDataProvider(),
+    ]
+
+
+__all__ = [
+    'CSVOHLCVDataProvider',
+    'CCXTOHLCVDataProvider',
+    'get_default_data_providers',
+    'get_default_ohlcv_data_providers',
+    'PandasOHLCVDataProvider',
+]