live market websocket and monitoring wallets

strategies/base_strategy.py

@@ -0,0 +1,73 @@
+from abc import ABC, abstractmethod
+import pandas as pd
+import json
+import os
+import logging
+from datetime import datetime, timezone
+import sqlite3
+
+class BaseStrategy(ABC):
+    """
+    An abstract base class that defines the blueprint for all trading strategies.
+    It provides common functionality like loading data and saving status.
+    """
+    
+    def __init__(self, strategy_name: str, params: dict, log_level: str):
+        self.strategy_name = strategy_name
+        self.params = params
+        self.coin = params.get("coin", "N/A")
+        self.timeframe = params.get("timeframe", "N/A")
+        self.db_path = os.path.join("_data", "market_data.db")
+        self.status_file_path = os.path.join("_data", f"strategy_status_{self.strategy_name}.json")
+        
+        # --- ADDED: State variables required for status reporting ---
+        self.current_signal = "INIT"
+        self.last_signal_change_utc = None
+        self.signal_price = None
+
+        # This will be set up by the child class after it's initialized
+        # setup_logging(log_level, f"Strategy-{self.strategy_name}")
+        # logging.info(f"Initializing with parameters: {self.params}")
+
+    def load_data(self) -> pd.DataFrame:
+        """Loads historical data for the configured coin and timeframe."""
+        table_name = f"{self.coin}_{self.timeframe}"
+        
+        # Dynamically determine the number of candles needed based on all possible period parameters
+        periods = [v for k, v in self.params.items() if 'period' in k or '_ma' in k or 'slow' in k]
+        limit = max(periods) + 50 if periods else 500
+
+        try:
+            with sqlite3.connect(f"file:{self.db_path}?mode=ro", uri=True) as conn:
+                query = f'SELECT * FROM "{table_name}" ORDER BY datetime_utc DESC LIMIT {limit}'
+                df = pd.read_sql(query, conn, parse_dates=['datetime_utc'])
+                if df.empty: return pd.DataFrame()
+                df.set_index('datetime_utc', inplace=True)
+                df.sort_index(inplace=True)
+                return df
+        except Exception as e:
+            logging.error(f"Failed to load data from table '{table_name}': {e}")
+            return pd.DataFrame()
+
+    @abstractmethod
+    def calculate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        The core logic of the strategy. Must be implemented by child classes.
+        """
+        pass
+
+    def _save_status(self):
+        """Saves the current strategy state to its JSON file."""
+        status = {
+            "strategy_name": self.strategy_name,
+            "current_signal": self.current_signal,
+            "last_signal_change_utc": self.last_signal_change_utc,
+            "signal_price": self.signal_price,
+            "last_checked_utc": datetime.now(timezone.utc).isoformat()
+        }
+        try:
+            with open(self.status_file_path, 'w', encoding='utf-8') as f:
+                json.dump(status, f, indent=4)
+        except IOError as e:
+            logging.error(f"Failed to write status file for {self.strategy_name}: {e}")
+

strategies/ma_cross_strategy.py

@@ -0,0 +1,35 @@
+import pandas as pd
+from strategies.base_strategy import BaseStrategy
+import logging
+
+class MaCrossStrategy(BaseStrategy):
+    """
+    A strategy based on a fast Simple Moving Average (SMA) crossing
+    a slow SMA.
+    """
+    def calculate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
+        # Support multiple naming conventions: some configs use 'fast'/'slow'
+        # while others use 'short_ma'/'long_ma'. Normalize here so both work.
+        fast_ma_period = self.params.get('short_ma') or self.params.get('fast') or 0
+        slow_ma_period = self.params.get('long_ma') or self.params.get('slow') or 0
+        
+        # If parameters are missing, return a neutral signal frame.
+        if not fast_ma_period or not slow_ma_period:
+            logging.warning(f"Missing MA period parameters (fast={fast_ma_period}, slow={slow_ma_period}).")
+            df['signal'] = 0
+            return df
+
+        if len(df) < slow_ma_period:
+            logging.warning(f"Not enough data for MA periods {fast_ma_period}/{slow_ma_period}. Need {slow_ma_period}, have {len(df)}.")
+            df['signal'] = 0
+            return df
+            
+        df['fast_sma'] = df['close'].rolling(window=fast_ma_period).mean()
+        df['slow_sma'] = df['close'].rolling(window=slow_ma_period).mean()
+        
+        # Signal is 1 for Golden Cross (fast > slow), -1 for Death Cross
+        df['signal'] = 0
+        df.loc[df['fast_sma'] > df['slow_sma'], 'signal'] = 1
+        df.loc[df['fast_sma'] < df['slow_sma'], 'signal'] = -1
+        
+        return df

strategies/single_sma_strategy.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from strategies.base_strategy import BaseStrategy
+import logging
+
+class SingleSmaStrategy(BaseStrategy):
+    """
+    A strategy based on the price crossing a single Simple Moving Average (SMA).
+    """
+    def calculate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
+        sma_period = self.params.get('sma_period', 0)
+        
+        if not sma_period or len(df) < sma_period:
+            logging.warning(f"Not enough data for SMA period {sma_period}. Need {sma_period}, have {len(df)}.")
+            df['signal'] = 0
+            return df
+            
+        df['sma'] = df['close'].rolling(window=sma_period).mean()
+        
+        # Signal is 1 when price is above SMA, -1 when below
+        df['signal'] = 0
+        df.loc[df['close'] > df['sma'], 'signal'] = 1
+        df.loc[df['close'] < df['sma'], 'signal'] = -1
+        
+        return df