investing-algorithm-framework 1.5__py3-none-any.whl → 7.25.6__py3-none-any.whl

investing_algorithm_framework/domain/backtesting/combine_backtests.py

@@ -0,0 +1,392 @@
+import logging
+from typing import List
+
+from .backtest_metrics import BacktestMetrics
+from .backtest_summary_metrics import BacktestSummaryMetrics
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+def safe_weighted_mean(values, weights):
+    """
+    Calculate the weighted mean of a list of values,
+    ignoring None values and weights <= 0.
+
+    Args:
+        values (List[float | None]): List of values to average.
+        weights (List[float | None]): Corresponding weights for the values.
+
+    Returns:
+        float | None: The weighted mean, or None if no valid values.
+    """
+    vals = [(v, w) for v, w in zip(values, weights) if
+            v is not None and w is not None and w > 0]
+    if not vals:
+        return None
+    total_weight = sum(w for _, w in vals)
+    return sum(
+        v * w for v, w in vals
+    ) / total_weight if total_weight > 0 else None
+
+
+def _compound_percentage_returns(percentages):
+    """
+    Compound percentage returns across multiple periods.
+
+    For example, if period 1 has 10% return and period 2 has 5% return,
+    the compounded return is: (1 + 0.10) * (1 + 0.05) - 1 = 15.5%
+    NOT simply 10% + 5% = 15%
+
+    Args:
+        percentages (List[float | None]): List of percentage returns
+            (as whole numbers, e.g., 10 for 10%).
+
+    Returns:
+        float | None: The compounded percentage return, or None if no
+            valid percentages.
+    """
+    valid_percentages = [p for p in percentages if p is not None]
+    if not valid_percentages:
+        return None
+
+    # Convert percentages to decimals, compound, then convert back
+    compounded = 1.0
+    for pct in valid_percentages:
+        compounded *= (1 + pct / 100)
+
+    # Convert back to percentage
+    return (compounded - 1) * 100
+
+
+def combine_backtests(backtests):
+    """
+    Combine multiple backtests into a single backtest by aggregating
+    their results.
+
+    Args:
+        backtests (List[Backtest]): List of Backtest instances to combine.
+
+    Returns:
+        Backtest: A new Backtest instance representing the combined results.
+    """
+    backtest_metrics = []
+    backtest_runs = []
+    algorithm_id = None
+
+    for backtest in backtests:
+        if algorithm_id is None:
+            algorithm_id = backtest.algorithm_id
+        elif algorithm_id != backtest.algorithm_id:
+            raise ValueError(
+                "All backtests must belong to the same algorithm id"
+                "to be combined."
+            )
+
+        backtest_runs += backtest.get_all_backtest_runs()
+        backtest_metrics += backtest.get_all_backtest_metrics()
+
+    summary = generate_backtest_summary_metrics(backtest_metrics)
+
+    metadata = None
+    risk_free_rate = None
+
+    # Check if there are duplicate backtest runs
+    unique_date_ranges = set()
+    for backtest in backtests:
+        for run in backtest.get_all_backtest_runs():
+            date_range = (run.backtest_start_date, run.backtest_end_date)
+            if date_range in unique_date_ranges:
+                logger.warning(
+                    "Duplicate backtest run detected for date range: "
+                    f"{date_range} when combining backtests."
+                )
+            unique_date_ranges.add(date_range)
+
+    # Merge all metadata dictionaries
+    metadata = {}
+    for backtest in backtests:
+        if backtest.metadata:
+            metadata.update(backtest.metadata)
+
+    # Get the first risk-free rate
+    for backtest in backtests:
+        if backtest.risk_free_rate is not None:
+            risk_free_rate = backtest.risk_free_rate
+            break
+    from .backtest import Backtest
+
+    backtest = Backtest(
+        algorithm_id=algorithm_id,
+        backtest_summary=summary,
+        metadata=metadata,
+        risk_free_rate=risk_free_rate,
+        backtest_runs=backtest_runs
+    )
+    return backtest
+
+
+def generate_backtest_summary_metrics(
+    backtest_metrics: List[BacktestMetrics]
+) -> BacktestSummaryMetrics:
+    """
+    Combine multiple BacktestMetrics into a single BacktestSummaryMetrics
+    by aggregating their results.
+
+    The aggregation logic follows these principles:
+    - Absolute values (gains, losses, growth): summed across periods
+    - Percentage returns: compounded across periods (not summed)
+    - Ratios (Sharpe, Sortino, etc.): weighted average by time period
+    - Trade-based metrics (win rate, avg trade return): weighted by trade count
+    - Max drawdown: worst (minimum) value across all periods
+    - Counts (number of trades): summed
+
+    Args:
+        backtest_metrics (List[BacktestMetrics]): List of BacktestMetrics
+            instances to combine.
+
+    Returns:
+        BacktestSummaryMetrics: A new BacktestSummaryMetrics instance
+            representing the combined results.
+    """
+    if not backtest_metrics:
+        return BacktestSummaryMetrics()
+
+    # Filter out None metrics
+    valid_metrics = [b for b in backtest_metrics if b is not None]
+    if not valid_metrics:
+        return BacktestSummaryMetrics()
+
+    # === ABSOLUTE VALUES (summed) ===
+    total_net_gain = sum(
+        b.total_net_gain for b in valid_metrics
+        if b.total_net_gain is not None
+    )
+    total_loss = sum(
+        b.gross_loss for b in valid_metrics
+        if b.gross_loss is not None
+    )
+    total_growth = sum(
+        b.total_growth for b in valid_metrics
+        if b.total_growth is not None
+    )
+
+    # === PERCENTAGE RETURNS (compounded, not summed) ===
+    # Compound returns: (1 + r1) * (1 + r2) * ... - 1
+    # For percentages stored as whole numbers (e.g., 10 for 10%)
+    total_net_gain_percentage = _compound_percentage_returns(
+        [b.total_net_gain_percentage for b in valid_metrics]
+    )
+    total_loss_percentage = _compound_percentage_returns(
+        [b.total_loss_percentage for b in valid_metrics]
+    )
+    total_growth_percentage = _compound_percentage_returns(
+        [b.total_growth_percentage for b in valid_metrics]
+    )
+
+    # === AVERAGES (weighted by time) ===
+    average_total_net_gain = safe_weighted_mean(
+        [b.total_net_gain for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    average_total_net_gain_percentage = safe_weighted_mean(
+        [b.total_net_gain_percentage for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    average_total_loss = safe_weighted_mean(
+        [b.gross_loss for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    average_total_loss_percentage = safe_weighted_mean(
+        [b.total_loss_percentage for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    average_growth = safe_weighted_mean(
+        [b.total_growth for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    average_growth_percentage = safe_weighted_mean(
+        [b.total_growth_percentage for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+
+    # === RISK-ADJUSTED RATIOS (weighted by time) ===
+    cagr = safe_weighted_mean(
+        [b.cagr for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    sharpe_ratio = safe_weighted_mean(
+        [b.sharpe_ratio for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    sortino_ratio = safe_weighted_mean(
+        [b.sortino_ratio for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    calmar_ratio = safe_weighted_mean(
+        [b.calmar_ratio for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    annual_volatility = safe_weighted_mean(
+        [b.annual_volatility for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+
+    # === PROFIT FACTOR (recalculated from totals, not averaged) ===
+    # profit_factor = total_gross_profit / total_gross_loss
+    total_gross_profit = sum(
+        b.gross_profit for b in valid_metrics
+        if hasattr(b, 'gross_profit') and b.gross_profit is not None
+    )
+    total_gross_loss_abs = abs(sum(
+        b.gross_loss for b in valid_metrics
+        if b.gross_loss is not None
+    ))
+    if total_gross_loss_abs > 0:
+        profit_factor = total_gross_profit / total_gross_loss_abs
+    else:
+        # Fallback to weighted average if we can't calculate from totals
+        profit_factor = safe_weighted_mean(
+            [b.profit_factor for b in valid_metrics],
+            [b.total_number_of_days for b in valid_metrics]
+        )
+
+    # === MAX DRAWDOWN (worst value = minimum,
+    # since drawdowns are negative) ===
+    drawdowns = [b.max_drawdown for b in valid_metrics
+                 if b.max_drawdown is not None]
+    max_drawdown = min(drawdowns) if drawdowns else None
+
+    max_drawdown_duration = max(
+        (b.max_drawdown_duration for b in valid_metrics
+         if b.max_drawdown_duration is not None), default=None
+    )
+
+    # === TRADE FREQUENCY (weighted by time) ===
+    trades_per_year = safe_weighted_mean(
+        [b.trades_per_year for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+
+    # === WIN RATE (weighted by number of closed trades, not time) ===
+    win_rate = safe_weighted_mean(
+        [b.win_rate for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+    current_win_rate = safe_weighted_mean(
+        [b.current_win_rate for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+
+    # === WIN/LOSS RATIO (weighted by number of closed trades) ===
+    win_loss_ratio = safe_weighted_mean(
+        [b.win_loss_ratio for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+    current_win_loss_ratio = safe_weighted_mean(
+        [b.current_win_loss_ratio for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+
+    # === TRADE COUNTS (summed) ===
+    number_of_trades = sum(
+        b.number_of_trades for b in valid_metrics
+        if b.number_of_trades is not None
+    )
+    number_of_trades_closed = sum(
+        b.number_of_trades_closed for b in valid_metrics
+        if b.number_of_trades_closed is not None
+    )
+
+    # === EXPOSURE (weighted by time) ===
+    cumulative_exposure = safe_weighted_mean(
+        [b.cumulative_exposure for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+    exposure_ratio = safe_weighted_mean(
+        [b.exposure_ratio for b in valid_metrics],
+        [b.total_number_of_days for b in valid_metrics]
+    )
+
+    # === AVERAGE TRADE RETURN (weighted by total trades) ===
+    average_trade_return = safe_weighted_mean(
+        [b.average_trade_return for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+    average_trade_return_percentage = safe_weighted_mean(
+        [b.average_trade_return_percentage for b in valid_metrics],
+        [b.number_of_trades_closed for b in valid_metrics]
+    )
+
+    # === AVERAGE TRADE LOSS (weighted by losing trades) ===
+    # We need to estimate losing trade count from win_rate if not available
+    losing_trade_weights = []
+    for b in valid_metrics:
+        if b.number_of_trades_closed is not None and b.win_rate is not None:
+            losing_trades = b.number_of_trades_closed * (1 - b.win_rate / 100)
+            losing_trade_weights.append(losing_trades)
+        else:
+            losing_trade_weights.append(b.number_of_trades_closed or 0)
+
+    average_trade_loss = safe_weighted_mean(
+        [b.average_trade_loss for b in valid_metrics],
+        losing_trade_weights
+    )
+    average_trade_loss_percentage = safe_weighted_mean(
+        [b.average_trade_loss_percentage for b in valid_metrics],
+        losing_trade_weights
+    )
+
+    # === AVERAGE TRADE GAIN (weighted by winning trades) ===
+    winning_trade_weights = []
+    for b in valid_metrics:
+        if b.number_of_trades_closed is not None and b.win_rate is not None:
+            winning_trades = b.number_of_trades_closed * (b.win_rate / 100)
+            winning_trade_weights.append(winning_trades)
+        else:
+            winning_trade_weights.append(b.number_of_trades_closed or 0)
+
+    average_trade_gain = safe_weighted_mean(
+        [b.average_trade_gain for b in valid_metrics],
+        winning_trade_weights
+    )
+    average_trade_gain_percentage = safe_weighted_mean(
+        [b.average_trade_gain_percentage for b in valid_metrics],
+        winning_trade_weights
+    )
+    return BacktestSummaryMetrics(
+        total_net_gain=total_net_gain,
+        total_net_gain_percentage=total_net_gain_percentage,
+        average_net_gain=average_total_net_gain,
+        average_net_gain_percentage=average_total_net_gain_percentage,
+        total_loss=total_loss,
+        total_loss_percentage=total_loss_percentage,
+        average_loss=average_total_loss,
+        average_loss_percentage=average_total_loss_percentage,
+        total_growth=total_growth,
+        total_growth_percentage=total_growth_percentage,
+        average_growth=average_growth,
+        average_growth_percentage=average_growth_percentage,
+        cagr=cagr,
+        sharpe_ratio=sharpe_ratio,
+        sortino_ratio=sortino_ratio,
+        calmar_ratio=calmar_ratio,
+        profit_factor=profit_factor,
+        annual_volatility=annual_volatility,
+        max_drawdown=max_drawdown,
+        max_drawdown_duration=max_drawdown_duration,
+        trades_per_year=trades_per_year,
+        win_rate=win_rate,
+        current_win_rate=current_win_rate,
+        win_loss_ratio=win_loss_ratio,
+        current_win_loss_ratio=current_win_loss_ratio,
+        number_of_trades=number_of_trades,
+        number_of_trades_closed=number_of_trades_closed,
+        cumulative_exposure=cumulative_exposure,
+        exposure_ratio=exposure_ratio,
+        average_trade_return=average_trade_return,
+        average_trade_return_percentage=average_trade_return_percentage,
+        average_trade_loss=average_trade_loss,
+        average_trade_loss_percentage=average_trade_loss_percentage,
+        average_trade_gain=average_trade_gain,
+        average_trade_gain_percentage=average_trade_gain_percentage
+    )

investing_algorithm_framework/domain/config.py

@@ -1,8 +1,6 @@
 import logging
-import os
 from enum import Enum
 
-from .constants import RESOURCE_DIRECTORY, BACKTEST_DATA_DIRECTORY_NAME
 from .exceptions import OperationalException
 
 logger = logging.getLogger("investing_algorithm_framework")
@@ -15,6 +13,7 @@ class Environment(Enum):
     DEV = 'DEV'
     PROD = 'PROD'
     TEST = 'TEST'
+    BACKTEST = 'BACKTEST'
 
     # Static factory method to convert
     # a string to environment
@@ -52,137 +51,61 @@ class Environment(Enum):
             return other == self.value
 
 
-class Config(dict):
-    ENVIRONMENT = Environment.PROD.value
-    LOG_LEVEL = 'DEBUG'
-    APP_DIR = os.path.abspath(os.path.dirname(__file__))
-    PROJECT_ROOT = os.path.abspath(os.path.join(APP_DIR, os.pardir))
-    DEBUG_TB_INTERCEPT_REDIRECTS = False
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
-    CACHE_TYPE = 'simple'  # Can be "memcached", "redis", etc.
-    CORS_ORIGIN_WHITELIST = [
-        'http://0.0.0.0:4100',
-        'http://localhost:4100',
-        'http://0.0.0.0:8000',
-        'http://localhost:8000',
-        'http://0.0.0.0:4200',
-        'http://localhost:4200',
-        'http://0.0.0.0:4000',
-        'http://localhost:4000',
-    ]
-    RESOURCE_DIRECTORY = os.getenv(RESOURCE_DIRECTORY)
-    SCHEDULER_API_ENABLED = True
-    CHECK_PENDING_ORDERS = True
-    SQLITE_ENABLED = True
-    SQLITE_INITIALIZED = False
-    BACKTEST_DATA_DIRECTORY_NAME = "backtest_data"
-
-    def __init__(self, resource_directory=None):
-        super().__init__()
-
-        if resource_directory is not None:
-            self.RESOURCE_DIRECTORY = resource_directory
-
-        super().__init__(vars(self.__class__))
-
-    # def __setitem__(self, key, item):
-    #     self.__dict__[key] = item
-    #
-    # def __getitem__(self, key):
-    #     return self.__dict__[key]
-    #
-    # def __repr__(self):
-    #     return repr(self.__dict__)
-    #
-    # def __len__(self):
-    #     return len(self.__dict__)
-    #
-    # def __delitem__(self, key):
-    #     del self.__dict__[key]
-    #
-    # def clear(self):
-    #     return self.__dict__.clear()
-    #
-    # def copy(self):
-    #     return self.__dict__.copy()
-    #
-    # def has_key(self, k):
-    #     return k in self.__dict__
-    #
-    # def update(self, *args, **kwargs):
-    #     return self.__dict__.update(*args, **kwargs)
-    #
-    # def keys(self):
-    #     return self.__dict__.keys()
-    #
-    # def values(self):
-    #     return self.__dict__.values()
-    #
-    # def items(self):
-    #     return self.__dict__.items()
-    #
-    # def pop(self, *args):
-    #     return self.__dict__.pop(*args)
-    #
-    # def __cmp__(self, dict_):
-    #     return self.__cmp__(self.__dict__, dict_)
-    #
-    # def __contains__(self, item):
-    #     return item in self.__dict__
-    #
-    # def __iter__(self):
-    #     return iter(self.__dict__)
-
-    def __str__(self):
-        field_strings = []
-
-        for attribute_key in self:
-
-            if attribute_key.isupper():
-                field_strings.append(
-                    f'{attribute_key}='
-                    f'{self[attribute_key]!r}'
-                )
-
-        return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-    def get(self, key: str, default=None):
-        """
-        Mimics the dict get() functionality
-        """
-
-        try:
-            return self[key]
-        # Ignore exception
-        except Exception:
-            pass
-
-        return default
-
-    def set(self, key: str, value) -> None:
-        self[key] = value
-
-    @staticmethod
-    def from_dict(dictionary):
-        config = Config()
-
-        for attribute_key in dictionary:
-
-            if attribute_key:
-                config.set(attribute_key, dictionary[attribute_key])
-                config[attribute_key] = dictionary[attribute_key]
-
-        return config
-
-
-class TestConfig(Config):
-    ENVIRONMENT = Environment.TEST.value
-    TESTING = True
-    DATABASE_CONFIG = {'DATABASE_NAME': "test"}
-    LOG_LEVEL = "INFO"
-
-
-class DevConfig(Config):
-    ENVIRONMENT = Environment.DEV.value
-    DATABASE_CONFIG = {'DATABASE_NAME': "dev"}
-    LOG_LEVEL = "INFO"
+DEFAULT_LOGGING_CONFIG = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'default': {
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        },
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'formatter': 'default',
+        },
+        'file': {
+            'class': 'logging.FileHandler',
+            'formatter': 'default',
+            'filename': 'app_logs.log',
+        },
+    },
+    'loggers': {  # Make sure to add a 'loggers' section
+        'investing_algorithm_framework': {  # Define your logger here
+            'level': 'INFO',  # Set the desired level
+            'handlers': ['console', 'file'],  # Use these handlers
+            'propagate': False,
+        },
+    },
+    'root': {  # Optional: Root logger configuration
+        'level': 'WARNING',  # Root logger defaults to WARNING
+        'handlers': ['console', 'file'],
+    },
+}
+
+AWS_LAMBDA_LOGGING_CONFIG = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'default': {
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        },
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'formatter': 'default',
+        },
+    },
+    'loggers': {  # Make sure to add a 'loggers' section
+        'investing_algorithm_framework': {  # Define your logger here
+            'level': 'INFO',  # Set the desired level
+            'handlers': ['console'],  # Use these handlers
+            'propagate': False,
+        },
+    },
+    'root': {  # Optional: Root logger configuration
+        'level': 'WARNING',  # Root logger defaults to WARNING
+        'handlers': ['console'],
+    },
+}

investing_algorithm_framework/domain/constants.py

@@ -1,5 +1,4 @@
 # Framework constants
-FRAMEWORK_NAME = 'FRAMEWORK_NAME'
 ENVIRONMENT = "ENVIRONMENT"
 STATELESS = "STATELESS"
 
@@ -8,64 +7,46 @@ DATABASE_CONFIG = 'DATABASE_CONFIG'
 DATABASE_NAME = 'DATABASE_NAME'
 DATABASE_TYPE = 'DATABASE_TYPE'
 DATABASE_DIRECTORY_PATH = 'DATABASE_DIRECTORY_PATH'
+DATABASE_DIRECTORY_NAME = 'DATABASE_DIRECTORY_NAME'
 DATABASE_URL = 'DATABASE_URL'
 DEFAULT_DATABASE_NAME = "database"
 
+APPLICATION_DIRECTORY = "APP_DIR"
 RESOURCE_DIRECTORY = "RESOURCE_DIRECTORY"
 BACKTEST_DATA_DIRECTORY_NAME = "BACKTEST_DATA_DIRECTORY_NAME"
+DATA_DIRECTORY = "DATA_DIRECTORY"
 LOG_LEVEL = 'LOG_LEVEL'
 BASE_DIR = 'BASE_DIR'
 SQLALCHEMY_DATABASE_URI = 'SQLALCHEMY_DATABASE_URI'
-SQLITE_INITIALIZED = "SQLITE_INITIALIZED"
 SQLALCHEMY_INITIALIZED = "SQLALCHEMY_INITIALIZED"
+APP_MODE = "APP_MODE"
 
 
-BINANCE = "BINANCE"
-
-IDENTIFIER_QUERY_PARAM = "identifier"
-TARGET_SYMBOL_QUERY_PARAM = "target_symbol"
-TRADING_SYMBOL_QUERY_PARAM = "trading_symbol"
-ORDER_SIDE_QUERY_PARAM = "order_size"
-STATUS_QUERY_PARAM = "status"
-POSITION_SYMBOL_QUERY_PARAM = "position"
-SYMBOL_QUERY_PARAM = "symbol"
-TIME_FRAME_QUERY_PARAM = "time_frame"
-
-RESERVED_IDENTIFIERS = [
-    BINANCE
-]
-
-BINANCE_API_KEY = "binance_api_key"
-BINANCE_SECRET_KEY = "binance_secret_key"
-
 CHECK_PENDING_ORDERS = "CHECK_PENDING_ORDERS"
 RUN_STRATEGY = "RUN_STRATEGY"
 
 # Configuration
-TRADING_SYMBOL = "TRADING_SYMBOL"
-CCXT_ENABLED = "CCXT_ENABLED"
-API_KEY = "API_KEY"
-SECRET_KEY = "SECRET_KEY"
-MARKET = "MARKET"
-TRACK_PORTFOLIO_FROM = "TRACK_PORTFOLIO_FROM"
-SQLITE_ENABLED = "SQLITE_ENABLED"
-PORTFOLIOS = "PORTFOLIOS"
-STRATEGIES = "STRATEGIES"
-APPLICATION_CONFIGURED = "APPLICATION_CONFIGURED"
-ACTION = "ACTION"
-
 DEFAULT_PER_PAGE_VALUE = 10
 DEFAULT_PAGE_VALUE = 1
 ITEMIZE = 'itemize'
 ITEMIZED = 'itemized'
 PAGE = 'page'
 PER_PAGE = 'per_page'
-
-DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
-DATETIME_FORMAT_BACKTESTING = "%Y-%m-%d:%H:%M"
-CCXT_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
+DATETIME_FORMAT_BACKTESTING = "%Y-%m-%d-%H-%M"
+CCXT_DATETIME_FORMAT_WITH_TIMEZONE = "%Y-%m-%dT%H:%M:%S.%fZ"
+CCXT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S.%f"
+DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
 BACKTESTING_FLAG = "BACKTESTING"
-BACKTESTING_INDEX_DATETIME = "BACKTESTING_INDEX_DATETIME"
+INDEX_DATETIME = "INDEX_DATETIME"
+LAST_SNAPSHOT_DATETIME = "LAST_SNAPSHOT_DATETIME"
 BACKTESTING_START_DATE = "BACKTESTING_START_DATE"
+BACKTESTING_END_DATE = "BACKTESTING_END_DATE"
+BACKTESTING_INITIAL_AMOUNT = "BACKTESTING_INITIAL_AMOUNT"
 TICKER_DATA_TYPE = "TICKER"
 OHLCV_DATA_TYPE = "OHLCV"
+CURRENT_UTC_DATETIME = "CURRENT_UTC_DATETIME"
+SNAPSHOT_INTERVAL = "SNAPSHOT_INTERVAL"
+DATETIME_FORMAT = "DATETIME_FORMAT"
+DATETIME_FORMAT_FILE_NAME = "DATETIME_FORMAT_FILE_NAME"
+# Deployment
+AWS_S3_STATE_BUCKET_NAME = "AWS_S3_STATE_BUCKET_NAME"