mtcli 3.8.0.dev14__tar.gz → 3.8.0.dev15__tar.gz

{mtcli-3.8.0.dev14 → mtcli-3.8.0.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli
-Version: 3.8.0.dev14
+Version: 3.8.0.dev15
 Summary: Aplicativo CLI para exibir gráficos do MetaTrader 5 screen reader friendly
 License-Expression: MIT
 License-File: LICENSE

{mtcli-3.8.0.dev14 → mtcli-3.8.0.dev15}/mtcli/commands/backfill.py

@@ -1,68 +1,70 @@
-"""
-Comando CLI: backfill
-
-Responsável por carregar histórico de ticks do MetaTrader5
-para o banco SQLite do mtcli utilizando o BackfillEngine.
-
-Fluxo:
-
-BackfillEngine
-      ↓
-TickRepository
-      ↓
-SQLite
-
-Opcionalmente os ticks também podem ser publicados no TickBus
-para que plugins consumam o fluxo histórico.
-"""
-
-import click
-
-from mtcli.marketdata.backfill_engine import BackfillEngine
-from mtcli.marketdata.tick_bus import TickBus
-from mtcli.marketdata.tick_repository import TickRepository
-
-
-@click.command()
-@click.argument("symbol")
-@click.option(
-    "--days",
-    default=5,
-    show_default=True,
-    help="Número de dias de histórico a carregar caso não exista histórico local.",
-)
-def backfill(symbol: str, days: int):
-    """
-    Executa backfill histórico de ticks.
-
-    Este comando baixa ticks históricos diretamente do MetaTrader5
-    e os grava no banco local SQLite do mtcli.
-
-    O processo é incremental:
-
-    - se já existirem ticks no banco, o backfill continua do último tick
-    - caso contrário, carrega o número de dias definido em --days
-
-    Examples
-    --------
-
-    Carregar 5 dias:
-
-        mt fill WINJ26
-
-    Carregar 30 dias:
-
-        mt fill WINJ26 --days 30
-    """
-
-    # Event bus (permite que plugins consumam os ticks históricos)
-    bus = TickBus()
-
-    # Repositório de persistência
-    repo = TickRepository()
-
-    # Engine de backfill
-    engine = BackfillEngine(symbol, bus, repo)
-
-    # Executa o carregamento histórico
-    engine.run(days)
+"""
+Comando CLI: backfill
+
+Responsável por carregar histórico de ticks do MetaTrader5
+para o banco SQLite do mtcli utilizando o BackfillEngine.
+
+Fluxo:
+
+BackfillEngine
+      ↓
+TickBus
+      ↓
+TickWriter
+      ↓
+TickRepository
+      ↓
+SQLite
+"""
+
+import click
+
+from mtcli.marketdata.backfill import BackfillEngine
+from mtcli.marketdata.tick_bus import TickBus
+from mtcli.marketdata.tick_repository import TickRepository
+from mtcli.marketdata.tick_writer import TickWriter
+
+
+@click.command()
+@click.argument("symbol")
+@click.option(
+    "--days",
+    default=5,
+    show_default=True,
+    help="Número de dias de histórico a carregar caso não exista histórico local.",
+)
+def backfill(symbol: str, days: int):
+    """
+    Executa backfill histórico de ticks.
+
+    Este comando baixa ticks históricos diretamente do MetaTrader5
+    e os grava no banco local SQLite do mtcli.
+
+    O processo é incremental:
+
+    - se já existirem ticks no banco, o backfill continua do último tick
+    - caso contrário, carrega o número de dias definido em --days
+
+    Examples
+    --------
+
+    Carregar 5 dias:
+
+        mt fill WINJ26
+
+    Carregar 30 dias:
+
+        mt fill WINJ26 --days 30
+    """
+
+    bus = TickBus()
+
+    repo = TickRepository()
+
+    writer = TickWriter(symbol, repo)
+
+    bus.subscribe(writer)
+
+    engine = BackfillEngine(symbol, bus, repo)
+
+    engine.run(days)

mtcli-3.8.0.dev15/mtcli/marketdata/backfill.py

@@ -0,0 +1,166 @@
+"""
+BackfillEngine
+
+Carrega ticks históricos do MetaTrader5 de forma determinística
+utilizando paginação por janelas de tempo.
+
+Vantagens sobre copy_ticks_from():
+
+• evita duplicação
+• evita buracos de ticks
+• não entra em loop
+• desempenho previsível
+• seguro para reexecução (idempotente)
+
+Arquitetura:
+
+MT5
+ ↓
+BackfillEngine
+ ↓
+TickBus
+ ↓
+Subscribers (TickWriter, plugins, etc)
+"""
+
+import datetime
+import MetaTrader5 as mt5
+
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+
+logger = setup_logger(__name__)
+
+
+class BackfillEngine:
+    """
+    Engine responsável pelo carregamento histórico de ticks.
+    """
+
+    WINDOW_MINUTES = 10
+
+    def __init__(self, symbol, tick_bus, repository):
+
+        self.symbol = symbol
+        self.tick_bus = tick_bus
+        self.repository = repository
+
+        self.last_time_msc = None
+
+    # ---------------------------------------------------------
+
+    def _get_last_stored(self):
+
+        last = self.repository._get_last_tick_msc(self.symbol)
+
+        if last:
+            logger.info(
+                "Backfill retomando do último tick armazenado: %s",
+                last,
+            )
+
+        return last
+
+    # ---------------------------------------------------------
+
+    def run(self, days=5):
+
+        logger.info(
+            "Backfill iniciado (%s) — até %s dias de histórico",
+            self.symbol,
+            days,
+        )
+
+        with mt5_conexao():
+
+            mt5.symbol_select(self.symbol, True)
+
+            now = datetime.datetime.now()
+
+            last = self._get_last_stored()
+
+            if last:
+
+                self.last_time_msc = last
+
+                start = datetime.datetime.fromtimestamp(
+                    (last + 1) / 1000
+                )
+
+            else:
+
+                start = now - datetime.timedelta(days=days)
+
+            end = now
+
+            total_loaded = 0
+
+            while start < end:
+
+                chunk_end = start + datetime.timedelta(
+                    minutes=self.WINDOW_MINUTES
+                )
+
+                if chunk_end > end:
+                    chunk_end = end
+
+                ticks = mt5.copy_ticks_range(
+                    self.symbol,
+                    start,
+                    chunk_end,
+                    mt5.COPY_TICKS_ALL,
+                )
+
+                if ticks is None or len(ticks) == 0:
+
+                    start = chunk_end
+                    continue
+
+                # ---------------------------------------------
+                # filtro extra de segurança
+                # ---------------------------------------------
+
+                if self.last_time_msc:
+
+                    mask = ticks["time_msc"] > self.last_time_msc
+                    ticks = ticks[mask]
+
+                    if len(ticks) == 0:
+
+                        start = chunk_end
+                        continue
+
+                # ---------------------------------------------
+                # publica ticks
+                # ---------------------------------------------
+
+                self.tick_bus.publish_many(ticks)
+
+                last_msc = int(ticks["time_msc"][-1])
+
+                if last_msc == self.last_time_msc:
+
+                    logger.warning(
+                        "Proteção de loop ativada — encerrando backfill"
+                    )
+                    break
+
+                self.last_time_msc = last_msc
+
+                total_loaded += len(ticks)
+
+                if total_loaded % 1_000_000 < len(ticks):
+
+                    logger.info(
+                        "Backfill progresso (%s): %s ticks",
+                        self.symbol,
+                        f"{total_loaded:,}",
+                    )
+
+                start = chunk_end
+
+        logger.info(
+            "Backfill concluído (%s) — %s ticks processados",
+            self.symbol,
+            f"{total_loaded:,}",
+        )

{mtcli-3.8.0.dev14 → mtcli-3.8.0.dev15}/mtcli/marketdata/tick_bus.py

@@ -1,45 +1,61 @@
-"""
-TickBus
-
-Event Bus simples para distribuição de ticks.
-"""
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class TickBus:
-    """
-    Implementa um Event Bus simples para ticks.
-    """
-
-    def __init__(self):
-        self.subscribers = []
-
-    # ---------------------------------------------------------
-
-    def subscribe(self, handler):
-        """
-        Registra um subscriber para receber ticks.
-        """
-
-        self.subscribers.append(handler)
-
-        name = getattr(handler, "__qualname__", handler.__class__.__name__)
-
-        logger.debug("Subscriber registrado: %s", name)
-
-    # ---------------------------------------------------------
-
-    def publish(self, tick):
-        """
-        Publica um tick para todos os subscribers.
-        """
-
-        for handler in self.subscribers:
-            try:
-                handler(tick)
-
-            except Exception:
-                logger.exception("Erro em subscriber")
+"""
+TickBus
+
+Event Bus simples para distribuição de ticks.
+"""
+
+from mtcli.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class TickBus:
+    """
+    Implementa um Event Bus simples para ticks.
+    """
+
+    def __init__(self):
+        self.subscribers = []
+
+    # ---------------------------------------------------------
+
+    def subscribe(self, handler):
+        """
+        Registra um subscriber para receber ticks.
+        """
+
+        self.subscribers.append(handler)
+
+        name = getattr(handler, "__qualname__", handler.__class__.__name__)
+
+        logger.debug("Subscriber registrado: %s", name)
+
+    # ---------------------------------------------------------
+
+    def publish(self, tick):
+        """
+        Publica um único tick para todos os subscribers.
+        """
+
+        for handler in self.subscribers:
+            try:
+                handler(tick)
+
+            except Exception:
+                logger.exception("Erro em subscriber")
+
+    # ---------------------------------------------------------
+
+    def publish_many(self, ticks):
+        """
+        Publica um lote de ticks para todos os subscribers.
+
+        Usado principalmente por mecanismos de backfill.
+        """
+
+        for handler in self.subscribers:
+            try:
+                handler(ticks)
+
+            except Exception:
+                logger.exception("Erro em subscriber")