Qubx 1.1.2.dev11__tar.gz → 1.1.2.dev13__tar.gz

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.2.dev11
+Version: 1.1.2.dev13
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.2.dev11'
-__version_tuple__ = version_tuple = (1, 1, 2, 'dev11')
+__version__ = version = '1.1.2.dev13'
+__version_tuple__ = version_tuple = (1, 1, 2, 'dev13')
 
 __commit_id__ = commit_id = None

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/emitters/prometheus.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Literal, Optional
 from prometheus_client import REGISTRY, Counter, Gauge, Summary, push_to_gateway
 
 from qubx import logger
-from qubx.core.basics import Signal, dt_64
+from qubx.core.basics import Instrument, Signal, dt_64
 from qubx.core.interfaces import IAccountViewer, IStrategyContext
 from qubx.emitters.base import BaseMetricEmitter
 
@@ -180,6 +180,7 @@ class PrometheusMetricEmitter(BaseMetricEmitter):
         value: float,
         tags: dict[str, Any] | None = None,
         timestamp: dt_64 | None = None,
+        instrument: Instrument | None = None,
         metric_type: MetricType = "gauge",
     ) -> None:
         """
@@ -192,8 +193,8 @@ class PrometheusMetricEmitter(BaseMetricEmitter):
             timestamp: Optional timestamp for the metric (ignored in Prometheus)
             metric_type: Type of metric (gauge, counter, summary)
         """
-        # Add metric type to tags
-        merged_tags = self._merge_tags(tags)
+        # Merge tags with instrument decomposed into symbol/exchange/asset/quote
+        merged_tags = self._merge_tags(tags, instrument)
         merged_tags["metric_type"] = metric_type
 
         # Call the implementation

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/loggers/__init__.py

@@ -8,10 +8,12 @@ from qubx.loggers.csv import CsvFileLogsWriter
 from qubx.loggers.factory import create_logs_writer
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.loggers.mongo import MongoDBLogsWriter
+from qubx.loggers.postgres import PostgresLogsWriter
 
 __all__ = [
     "CsvFileLogsWriter",
     "InMemoryLogsWriter",
     "MongoDBLogsWriter",
+    "PostgresLogsWriter",
     "create_logs_writer",
 ]

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/loggers/factory.py

@@ -5,12 +5,14 @@ from qubx.core.loggers import LogsWriter
 from qubx.loggers.csv import CsvFileLogsWriter
 from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.loggers.mongo import MongoDBLogsWriter
+from qubx.loggers.postgres import PostgresLogsWriter
 
 # Registry of logs writer types
 LOGS_WRITER_REGISTRY: dict[str, Type[LogsWriter]] = {
     "CsvFileLogsWriter": CsvFileLogsWriter,
     "MongoDBLogsWriter": MongoDBLogsWriter,
     "InMemoryLogsWriter": InMemoryLogsWriter,
+    "PostgresLogsWriter": PostgresLogsWriter,
 }
 
 

qubx-1.1.2.dev13/src/qubx/loggers/postgres.py

@@ -0,0 +1,216 @@
+from multiprocessing.pool import ThreadPool
+from typing import Any
+
+from psycopg import sql
+from psycopg.types.json import Jsonb
+from psycopg_pool import ConnectionPool
+
+from qubx import logger
+from qubx.core.loggers import LogsWriter
+
+# Column definitions for each log type: (column_name, sql_type)
+_TABLE_SCHEMAS: dict[str, list[tuple[str, str]]] = {
+    "positions": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("symbol", "TEXT NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("market_type", "TEXT NOT NULL"),
+        ("pnl_quoted", "DOUBLE PRECISION"),
+        ("funding_pnl_quoted", "DOUBLE PRECISION"),
+        ("realized_pnl_quoted", "DOUBLE PRECISION"),
+        ("quantity", "DOUBLE PRECISION"),
+        ("notional", "DOUBLE PRECISION"),
+        ("avg_position_price", "DOUBLE PRECISION"),
+        ("current_price", "DOUBLE PRECISION"),
+        ("market_value_quoted", "DOUBLE PRECISION"),
+        ("commissions_quoted", "DOUBLE PRECISION"),
+    ],
+    "portfolio": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("symbol", "TEXT NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("market_type", "TEXT NOT NULL"),
+        ("pnl_quoted", "DOUBLE PRECISION"),
+        ("quantity", "DOUBLE PRECISION"),
+        ("realized_pnl_quoted", "DOUBLE PRECISION"),
+        ("avg_position_price", "DOUBLE PRECISION"),
+        ("current_price", "DOUBLE PRECISION"),
+        ("market_value_quoted", "DOUBLE PRECISION"),
+        ("exchange_time", "TIMESTAMPTZ"),
+        ("commissions_quoted", "DOUBLE PRECISION"),
+        ("cumulative_funding", "DOUBLE PRECISION"),
+    ],
+    "executions": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("symbol", "TEXT NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("market_type", "TEXT NOT NULL"),
+        ("side", "TEXT NOT NULL"),
+        ("filled_qty", "DOUBLE PRECISION"),
+        ("price", "DOUBLE PRECISION"),
+        ("commissions", "DOUBLE PRECISION"),
+        ("commissions_quoted", "TEXT"),
+        ("order_id", "TEXT"),
+        ("order_type", "TEXT"),
+    ],
+    "signals": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("symbol", "TEXT NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("market_type", "TEXT NOT NULL"),
+        ("signal", "TEXT"),
+        ("reference_price", "DOUBLE PRECISION"),
+        ("price", "DOUBLE PRECISION"),
+        ("take", "DOUBLE PRECISION"),
+        ("stop", "DOUBLE PRECISION"),
+        ("group_name", "TEXT"),
+        ("comment", "TEXT"),
+        ("service", "BOOLEAN"),
+        ("options", "JSONB"),
+    ],
+    "targets": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("symbol", "TEXT NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("market_type", "TEXT NOT NULL"),
+        ("target_position", "DOUBLE PRECISION"),
+        ("entry_price", "DOUBLE PRECISION"),
+        ("take_price", "DOUBLE PRECISION"),
+        ("stop_price", "DOUBLE PRECISION"),
+        ("options", "JSONB"),
+    ],
+    "balance": [
+        ("timestamp", "TIMESTAMPTZ NOT NULL"),
+        ("exchange", "TEXT NOT NULL"),
+        ("currency", "TEXT NOT NULL"),
+        ("total", "DOUBLE PRECISION"),
+        ("locked", "DOUBLE PRECISION"),
+    ],
+}
+
+# Mapping from log data dict keys to column names (only where they differ)
+_COLUMN_RENAMES: dict[str, dict[str, str]] = {
+    "signals": {"group": "group_name"},
+}
+
+# Columns that use JSONB type and need Jsonb() wrapper
+_JSONB_COLUMNS: set[str] = {
+    name for schema in _TABLE_SCHEMAS.values() for name, col_type in schema if col_type == "JSONB"
+}
+
+
+def _table_name(prefix: str, log_type: str) -> str:
+    return f"{prefix}_{log_type}"
+
+
+class PostgresLogsWriter(LogsWriter):
+    """
+    PostgreSQL implementation of LogsWriter interface.
+    Writes log data to typed PostgreSQL tables asynchronously using psycopg v3 and a connection pool.
+    """
+
+    def __init__(
+        self,
+        account_id: str,
+        strategy_id: str,
+        run_id: str,
+        postgres_uri: str = "postgresql://localhost:5432/qubx_logs",
+        table_prefix: str = "qubx_logs",
+        pool_size: int = 4,
+    ) -> None:
+        super().__init__(account_id, strategy_id, run_id)
+        self.table_prefix = table_prefix
+        self._pool = ConnectionPool(postgres_uri, min_size=1, max_size=pool_size)
+        self._thread_pool = ThreadPool(pool_size)
+        self._ensure_tables()
+
+    def _ensure_tables(self) -> None:
+        with self._pool.connection() as conn:
+            with conn.cursor() as cur:
+                for log_type, columns in _TABLE_SCHEMAS.items():
+                    tname = _table_name(self.table_prefix, log_type)
+                    col_defs = ",\n    ".join(f"{name} {col_type}" for name, col_type in columns)
+                    cur.execute(
+                        sql.SQL(
+                            """
+                            CREATE TABLE IF NOT EXISTS {table} (
+                                id BIGSERIAL PRIMARY KEY,
+                                run_id TEXT NOT NULL,
+                                account_id TEXT NOT NULL,
+                                strategy_name TEXT NOT NULL,
+                                created_at TIMESTAMPTZ DEFAULT NOW(),
+                                {columns}
+                            )
+                            """
+                        ).format(
+                            table=sql.Identifier(tname),
+                            columns=sql.SQL(col_defs),
+                        )
+                    )
+                    # Index on strategy_name + timestamp for common queries
+                    idx_name = f"idx_{tname}_strategy_ts"
+                    cur.execute(
+                        sql.SQL("CREATE INDEX IF NOT EXISTS {idx} ON {table} (strategy_name, timestamp)").format(
+                            idx=sql.Identifier(idx_name),
+                            table=sql.Identifier(tname),
+                        )
+                    )
+            conn.commit()
+
+    def _remap_keys(self, log_type: str, row: dict[str, Any]) -> dict[str, Any]:
+        renames = _COLUMN_RENAMES.get(log_type)
+        if not renames:
+            return row
+        return {renames.get(k, k): v for k, v in row.items()}
+
+    def _do_write(self, log_type: str, data: list[dict[str, Any]]) -> None:
+        tname = _table_name(self.table_prefix, log_type)
+        schema_cols = [name for name, _ in _TABLE_SCHEMAS[log_type]]
+        meta_cols = ["run_id", "account_id", "strategy_name"]
+        all_cols = meta_cols + schema_cols
+
+        rows = []
+        for raw_row in data:
+            row = self._remap_keys(log_type, raw_row)
+            values = [self.run_id, self.account_id, self.strategy_id]
+            for col in schema_cols:
+                val = row.get(col)
+                # Convert numpy datetime / stringified timestamps
+                if col in ("timestamp", "exchange_time") and val is not None:
+                    val = str(val)
+                # Convert signal value to string
+                if col == "signal" and val is not None:
+                    val = str(val)
+                # Wrap dicts in Jsonb for JSONB columns
+                if col in _JSONB_COLUMNS and isinstance(val, dict):
+                    val = Jsonb(val)
+                values.append(val)
+            rows.append(tuple(values))
+
+        col_ids = sql.SQL(", ").join(sql.Identifier(c) for c in all_cols)
+        placeholders = sql.SQL(", ").join(sql.Placeholder() * len(all_cols))
+        query = sql.SQL("INSERT INTO {table} ({cols}) VALUES ({vals})").format(
+            table=sql.Identifier(tname),
+            cols=col_ids,
+            vals=placeholders,
+        )
+
+        try:
+            with self._pool.connection() as conn:
+                with conn.cursor() as cur:
+                    cur.executemany(query, rows)
+                conn.commit()
+        except Exception:
+            logger.exception(f"PostgresLogsWriter: failed to write {len(rows)} rows to {tname}")
+
+    def write_data(self, log_type: str, data: list[dict[str, Any]]) -> None:
+        if data:
+            self._thread_pool.apply_async(self._do_write, (log_type, data))
+
+    def flush_data(self) -> None:
+        pass
+
+    def close(self) -> None:
+        self._thread_pool.close()
+        self._thread_pool.join()
+        self._pool.close()

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/restorers/balance.py

@@ -6,10 +6,11 @@ from various sources.
 """
 
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 import pandas as pd
+from psycopg import Connection, sql
 from pymongo import MongoClient
 
 from qubx import logger
@@ -207,3 +208,75 @@ class MongoDBBalanceRestorer(IBalanceRestorer):
         except Exception as e:
             logger.error(f"Error restoring balances from MongoDB: {e}")
             return []
+
+
+class PostgresBalanceRestorer(IBalanceRestorer):
+    """
+    Balance restorer that reads account balances from PostgreSQL tables
+    written by PostgresLogsWriter.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        connection: Connection,
+        table_name: str = "qubx_logs_balance",
+    ):
+        self.strategy_name = strategy_name
+        self.connection = connection
+        self.table_name = table_name
+
+    def restore_balances(self) -> list[AssetBalance]:
+        try:
+            now = datetime.now(timezone.utc)
+            lookup_range = now - timedelta(days=7)
+
+            with self.connection.cursor() as cur:
+                # Find latest run_id
+                cur.execute(
+                    sql.SQL(
+                        "SELECT run_id FROM {table} WHERE strategy_name = %s AND timestamp >= %s "
+                        "ORDER BY timestamp DESC LIMIT 1"
+                    ).format(table=sql.Identifier(self.table_name)),
+                    (self.strategy_name, lookup_range),
+                )
+                row = cur.fetchone()
+                if not row:
+                    logger.warning("No balance logs found in PostgreSQL for given filters.")
+                    return []
+
+                latest_run_id = row[0]
+                logger.info(f"Restoring balances from PostgreSQL for run_id: {latest_run_id}")
+
+                # Get latest balance per (exchange, currency)
+                cur.execute(
+                    sql.SQL(
+                        "SELECT DISTINCT ON (exchange, currency) "
+                        "exchange, currency, total, locked "
+                        "FROM {table} "
+                        "WHERE strategy_name = %s AND run_id = %s AND timestamp >= %s "
+                        "ORDER BY exchange, currency, timestamp DESC"
+                    ).format(table=sql.Identifier(self.table_name)),
+                    (self.strategy_name, latest_run_id, lookup_range),
+                )
+
+                balances: list[AssetBalance] = []
+                for exchange, currency, total, locked in cur.fetchall():
+                    if not currency:
+                        continue
+                    total = total or 0.0
+                    locked = locked or 0.0
+                    balances.append(
+                        AssetBalance(
+                            exchange=exchange,
+                            currency=currency,
+                            total=total,
+                            locked=locked,
+                            free=total - locked,
+                        )
+                    )
+
+                return balances
+        except Exception as e:
+            logger.error(f"Error restoring balances from PostgreSQL: {e}")
+            return []

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/restorers/factory.py

@@ -8,16 +8,17 @@ based on configuration.
 from typing import Type
 
 from qubx.core.lookups import LookupsManager
-from qubx.restorers.balance import CsvBalanceRestorer, MongoDBBalanceRestorer
+from qubx.restorers.balance import CsvBalanceRestorer, MongoDBBalanceRestorer, PostgresBalanceRestorer
 from qubx.restorers.interfaces import IBalanceRestorer, IPositionRestorer, ISignalRestorer, IStateRestorer
-from qubx.restorers.position import CsvPositionRestorer, MongoDBPositionRestorer
-from qubx.restorers.signal import CsvSignalRestorer, MongoDBSignalRestorer
-from qubx.restorers.state import CsvStateRestorer, MongoDBStateRestorer
+from qubx.restorers.position import CsvPositionRestorer, MongoDBPositionRestorer, PostgresPositionRestorer
+from qubx.restorers.signal import CsvSignalRestorer, MongoDBSignalRestorer, PostgresSignalRestorer
+from qubx.restorers.state import CsvStateRestorer, MongoDBStateRestorer, PostgresStateRestorer
 
 # Registry of position restorer types
 POSITION_RESTORER_REGISTRY: dict[str, Type[IPositionRestorer]] = {
     "CsvPositionRestorer": CsvPositionRestorer,
     "MongoDBPositionRestorer": MongoDBPositionRestorer,
+    "PostgresPositionRestorer": PostgresPositionRestorer,
 }
 
 
@@ -25,6 +26,7 @@ POSITION_RESTORER_REGISTRY: dict[str, Type[IPositionRestorer]] = {
 SIGNAL_RESTORER_REGISTRY: dict[str, Type[ISignalRestorer]] = {
     "CsvSignalRestorer": CsvSignalRestorer,
     "MongoDBSignalRestorer": MongoDBSignalRestorer,
+    "PostgresSignalRestorer": PostgresSignalRestorer,
 }
 
 
@@ -32,6 +34,7 @@ SIGNAL_RESTORER_REGISTRY: dict[str, Type[ISignalRestorer]] = {
 BALANCE_RESTORER_REGISTRY: dict[str, Type[IBalanceRestorer]] = {
     "CsvBalanceRestorer": CsvBalanceRestorer,
     "MongoDBBalanceRestorer": MongoDBBalanceRestorer,
+    "PostgresBalanceRestorer": PostgresBalanceRestorer,
 }
 
 
@@ -39,6 +42,7 @@ BALANCE_RESTORER_REGISTRY: dict[str, Type[IBalanceRestorer]] = {
 STATE_RESTORER_REGISTRY: dict[str, Type[IStateRestorer]] = {
     "CsvStateRestorer": CsvStateRestorer,
     "MongoDBStateRestorer": MongoDBStateRestorer,
+    "PostgresStateRestorer": PostgresStateRestorer,
 }
 
 

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/restorers/position.py

@@ -6,11 +6,12 @@ for restoring positions from various sources.
 """
 
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import cast
 
 import pandas as pd
+from psycopg import Connection, sql
 from pymongo import MongoClient
 
 from qubx import logger
@@ -250,3 +251,87 @@ class MongoDBPositionRestorer(IPositionRestorer):
         except Exception as e:
             logger.error(f"Error restoring positions from MongoDB: {e}")
             return {}
+
+
+class PostgresPositionRestorer(IPositionRestorer):
+    """
+    Position restorer that reads positions from PostgreSQL tables
+    written by PostgresLogsWriter.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        connection: Connection,
+        table_name: str = "qubx_logs_positions",
+    ):
+        self.strategy_name = strategy_name
+        self.connection = connection
+        self.table_name = table_name
+
+    def restore_positions(self) -> dict[Instrument, Position]:
+        try:
+            now = datetime.now(timezone.utc)
+            lookup_range = now - timedelta(days=7)
+
+            with self.connection.cursor() as cur:
+                # Find latest run_id
+                cur.execute(
+                    sql.SQL(
+                        "SELECT run_id FROM {table} WHERE strategy_name = %s AND timestamp >= %s "
+                        "ORDER BY timestamp DESC LIMIT 1"
+                    ).format(table=sql.Identifier(self.table_name)),
+                    (self.strategy_name, lookup_range),
+                )
+                row = cur.fetchone()
+                if not row:
+                    logger.warning("No position logs found in PostgreSQL for given filters.")
+                    return {}
+
+                latest_run_id = row[0]
+                logger.info(f"Restoring positions from PostgreSQL for run_id: {latest_run_id}")
+
+                # Get latest position per instrument
+                cur.execute(
+                    sql.SQL(
+                        "SELECT DISTINCT ON (symbol, exchange, market_type) "
+                        "symbol, exchange, market_type, quantity, avg_position_price, "
+                        "realized_pnl_quoted, current_price, funding_pnl_quoted, commissions_quoted, timestamp "
+                        "FROM {table} "
+                        "WHERE strategy_name = %s AND run_id = %s AND timestamp >= %s "
+                        "ORDER BY symbol, exchange, market_type, timestamp DESC"
+                    ).format(table=sql.Identifier(self.table_name)),
+                    (self.strategy_name, latest_run_id, lookup_range),
+                )
+
+                positions: dict[Instrument, Position] = {}
+                for log in cur.fetchall():
+                    symbol, exchange, market_type, quantity, avg_price, r_pnl, current_price, funding, commissions, ts = log
+
+                    if not (symbol and exchange and market_type):
+                        continue
+
+                    instrument = lookup.find_symbol(exchange, symbol)
+                    if instrument is None:
+                        logger.warning(f"Instrument not found for {symbol} on {exchange}")
+                        continue
+
+                    position = Position(
+                        instrument=instrument,
+                        quantity=cast(float, quantity or 0.0),
+                        pos_average_price=cast(float, avg_price or 0.0),
+                        r_pnl=cast(float, r_pnl or 0.0),
+                        cumulative_funding=cast(float, funding or 0.0),
+                        commissions=cast(float, commissions or 0.0),
+                    )
+
+                    if current_price is not None:
+                        timestamp = recognize_time(ts)
+                        position.update_market_price(timestamp, current_price, 1.0)
+
+                    positions[instrument] = position
+
+                return positions
+        except Exception as e:
+            logger.error(f"Error restoring positions from PostgreSQL: {e}")
+            return {}

{qubx-1.1.2.dev11 → qubx-1.1.2.dev13}/src/qubx/restorers/signal.py

@@ -10,6 +10,7 @@ from datetime import datetime, timedelta
 from pathlib import Path
 
 import pandas as pd
+from psycopg import Connection, sql
 from pymongo import MongoClient
 from pymongo.command_cursor import CommandCursor
 
@@ -374,3 +375,119 @@ class MongoDBSignalRestorer(ISignalRestorer):
                 f"Error restoring {log_type} data from MongoDB::{self.collection_name} for {self.strategy_name} : {e}"
             )
             return None
+
+
+class PostgresSignalRestorer(ISignalRestorer):
+    """
+    Signal restorer that reads signals and targets from PostgreSQL tables
+    written by PostgresLogsWriter.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        connection: Connection,
+        signals_table_name: str = "qubx_logs_signals",
+        targets_table_name: str = "qubx_logs_targets",
+        max_restored_records: int = 20,
+    ):
+        self.strategy_name = strategy_name
+        self.connection = connection
+        self.signals_table_name = signals_table_name
+        self.targets_table_name = targets_table_name
+        self.max_restored_records = max_restored_records
+
+    def restore_signals(self) -> dict[Instrument, list[Signal]]:
+        logger.info(f"Restoring latest {self.max_restored_records} signals per symbol from PostgreSQL")
+        result: dict[Instrument, list[Signal]] = {}
+
+        rows = self._load_data(self.signals_table_name)
+        if rows is None:
+            return result
+
+        for log in rows:
+            try:
+                instrument = lookup.find_symbol(log["exchange"], log["symbol"])
+                if instrument is None:
+                    logger.warning(f"Instrument not found for {log['symbol']} on {log['exchange']}")
+                    continue
+
+                signal_value = log.get("signal")
+                if signal_value is not None:
+                    signal_value = float(signal_value)
+
+                if signal_value is None:
+                    logger.warning(f"Missing signal for log: {log}")
+                    continue
+
+                price = log.get("price") or log.get("reference_price")
+                options = log.get("options") or {}
+
+                signal = Signal(
+                    time=recognize_time(log["timestamp"]),
+                    instrument=instrument,
+                    signal=signal_value,
+                    price=price,
+                    stop=None,
+                    take=None,
+                    reference_price=log.get("reference_price"),
+                    group=log.get("group_name", ""),
+                    comment=log.get("comment", ""),
+                    options=options,
+                    is_service=log.get("service", False),
+                )
+
+                result.setdefault(instrument, []).append(signal)
+            except Exception as e:
+                logger.exception(f"Failed to process signal row: {e}")
+
+        return result
+
+    def restore_targets(self) -> dict[Instrument, list[TargetPosition]]:
+        logger.info(f"Restoring latest {self.max_restored_records} targets per symbol from PostgreSQL")
+        result: dict[Instrument, list[TargetPosition]] = {}
+
+        rows = self._load_data(self.targets_table_name)
+        if rows is None:
+            return result
+
+        for log in rows:
+            try:
+                instrument = lookup.find_symbol(log["exchange"], log["symbol"])
+                if instrument is None:
+                    logger.warning(f"Instrument not found for {log['symbol']} on {log['exchange']}")
+                    continue
+
+                target = TargetPosition(
+                    time=recognize_time(log["timestamp"]),
+                    instrument=instrument,
+                    target_position_size=float(log["target_position"]),
+                    entry_price=log.get("entry_price"),
+                    stop_price=log.get("stop_price"),
+                    take_price=log.get("take_price"),
+                    options=log.get("options") or {},
+                )
+
+                result.setdefault(instrument, []).append(target)
+            except Exception as e:
+                logger.exception(f"Failed to process target row: {e}")
+
+        return result
+
+    def _load_data(self, table_name: str) -> list[dict] | None:
+        try:
+            query = sql.SQL(
+                "SELECT * FROM ("
+                "  SELECT *, ROW_NUMBER() OVER ("
+                "    PARTITION BY symbol, exchange, market_type ORDER BY timestamp DESC"
+                "  ) AS rn FROM {table} WHERE strategy_name = %s"
+                ") sub WHERE rn <= %s ORDER BY symbol, exchange, market_type, timestamp DESC"
+            ).format(table=sql.Identifier(table_name))
+
+            with self.connection.cursor() as cur:
+                cur.execute(query, (self.strategy_name, self.max_restored_records))
+                columns = [desc.name for desc in cur.description]
+                return [dict(zip(columns, row)) for row in cur.fetchall()]
+        except Exception as e:
+            logger.error(f"Error restoring data from PostgreSQL::{table_name} for {self.strategy_name}: {e}")
+            return None