mtcli 3.8.0.dev11__tar.gz → 3.8.0.dev12__tar.gz

{mtcli-3.8.0.dev11 → mtcli-3.8.0.dev12}/PKG-INFO

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

{mtcli-3.8.0.dev11 → mtcli-3.8.0.dev12}/mtcli/cli.py

@@ -23,11 +23,12 @@ import click
 
 from mtcli.plugin_loader import load_plugins
 from mtcli.logger import setup_logger
-from mtcli.marketdata.tick_engine import TickEngine
+from mtcli.services.tick_service import ensure_tick_engine
 
 from .commands.bars import bars
 from .commands.doctor import doctor
 from .commands.ticks import ticks
+from .commands.backfill import backfill
 
 
 logger = setup_logger(__name__)
@@ -55,15 +56,17 @@ def start_tick_capture():
     symbol = os.getenv("MTCLI_SYMBOL")
 
     if not symbol:
-        logger.info("Captura automática de ticks desativada (MTCLI_SYMBOL não definido).")
+        logger.info(
+            "Captura automática de ticks desativada (MTCLI_SYMBOL não definido)."
+        )
         return
 
     logger.info("Iniciando captura contínua de ticks para %s", symbol)
 
     try:
 
-        _tick_engine = TickEngine([symbol])
-        _tick_engine.start()
+        # CORREÇÃO PRINCIPAL
+        _tick_engine = ensure_tick_engine([symbol])
 
         logger.info("Captura de ticks iniciada em background.")
 
@@ -89,6 +92,7 @@ mt.add_command(doctor, name="doctor")
 mt.add_command(bars, name="bars")
 mt.add_command(doctor, name="dr")
 mt.add_command(ticks)
+mt.add_command(backfill, name="fill")
 
 loaded_plugins = load_plugins(mt)
 

mtcli-3.8.0.dev12/mtcli/commands/backfill.py

@@ -0,0 +1,68 @@
+"""
+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)

{mtcli-3.8.0.dev11 → mtcli-3.8.0.dev12}/mtcli/commands/ticks.py

@@ -1,45 +1,42 @@
 """
 Comando CLI para captura contínua de ticks.
 
-Permite iniciar um TickEngine manualmente
+Permite iniciar o serviço de captura de ticks
 para um ou mais símbolos.
 
 Exemplo:
 
     mt ticks WIN$N
     mt ticks WIN$N WDO$N PETR4
-
-A captura continua até o usuário interromper
-com Ctrl+C.
 """
 
 import time
 import click
 
-from mtcli.marketdata.tick_engine import TickEngine
+from mtcli.services.tick_service import ensure_tick_engine
 
 
 @click.command()
 @click.argument("symbols", nargs=-1)
 def ticks(symbols):
     """
-    Inicia captura contínua de ticks para os símbolos informados.
+    Inicia captura contínua de ticks.
     """
 
     if not symbols:
         click.echo("Informe ao menos um símbolo.")
         return
 
-    engine = TickEngine(symbols)
+    # atualmente o engine suporta apenas 1 símbolo
+    symbol = symbols[0]
 
-    click.echo("Iniciando captura de ticks...")
+    engine = ensure_tick_engine(symbol)
 
-    engine.start()
+    click.echo(f"Captura de ticks iniciada para {symbol}")
 
     try:
-
-        while True:
-            time.sleep(1)
+        # inicia engine
+        engine.start()
 
     except KeyboardInterrupt:
 

{mtcli-3.8.0.dev11 → mtcli-3.8.0.dev12}/mtcli/database.py

@@ -3,17 +3,18 @@ Core de acesso ao banco SQLite do mtcli.
 
 Responsável por:
 
-- Criar conexão SQLite
-- Aplicar otimizações de performance
-- Ativar WAL
-- Gerenciar migrations
-- Backup e manutenção do banco
+- criar conexão SQLite
+- aplicar otimizações
+- executar migrations automaticamente
+- backup automático
 """
 
 import sqlite3
 from pathlib import Path
 from datetime import datetime
+
 from .conf import DB_NAME
+from .migrations.runner import run_migrations
 
 
 DB_PATH = Path.home() / ".mtcli" / DB_NAME
@@ -24,8 +25,7 @@ _connection = None
 
 def get_connection():
     """
-    Retorna conexão singleton SQLite otimizada para ingestão
-    contínua de ticks.
+    Retorna conexão singleton SQLite.
     """
 
     global _connection
@@ -38,25 +38,18 @@ def get_connection():
 
     conn = sqlite3.connect(DB_PATH, check_same_thread=False)
 
+    # otimizações
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA synchronous=NORMAL")
     conn.execute("PRAGMA temp_store=MEMORY")
     conn.execute("PRAGMA mmap_size=30000000000")
     conn.execute("PRAGMA cache_size=-200000")
     conn.execute("PRAGMA journal_size_limit=67108864")
-    conn.execute("PRAGMA read_uncommitted = TRUE")
-
-    # checkpoint automático
-    conn.execute("PRAGMA wal_autocheckpoint=1000")
-
-    conn.execute("""
-    CREATE TABLE IF NOT EXISTS schema_migrations(
-        version INTEGER PRIMARY KEY,
-        applied_at TEXT NOT NULL
-    )
-    """)
+    conn.execute("PRAGMA wal_autocheckpoint=5000")
+    conn.execute("PRAGMA foreign_keys=ON")
 
-    conn.commit()
+    # executa migrations automaticamente
+    run_migrations(conn)
 
     _connection = conn
 
@@ -68,9 +61,6 @@ def get_connection():
 # ==========================================================
 
 def backup_database(conn):
-    """
-    Realiza backup diário seguro do banco SQLite.
-    """
 
     now = datetime.now().strftime("%Y%m%d")
 

mtcli-3.8.0.dev12/mtcli/marketdata/backfill_engine.py

@@ -0,0 +1,201 @@
+"""
+BackfillEngine
+
+Carrega ticks históricos do MetaTrader5 de forma eficiente
+e os publica no TickBus para processamento.
+
+Características:
+
+• leitura em chunks grandes (100k ticks)
+• proteção contra duplicação
+• compatível com TickBus
+• inserção em batch no SQLite
+• sem barra de progresso (CLI acessível)
+• baixo uso de memória
+"""
+
+import datetime
+import MetaTrader5 as mt5
+
+from mtcli.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class BackfillEngine:
+    """
+    Engine responsável pelo carregamento histórico de ticks.
+
+    O BackfillEngine baixa ticks históricos diretamente do MT5
+    utilizando janelas grandes e publica os ticks no TickBus,
+    permitindo que múltiplos subscribers processem os dados.
+
+    Tipicamente os subscribers incluem:
+
+    - TickWriter (persistência em banco)
+    - plugins de análise
+    - geradores de estruturas derivadas (Renko, bars, etc)
+
+    Fluxo arquitetural:
+
+        MetaTrader5
+            ↓
+        BackfillEngine
+            ↓
+        TickBus
+            ↓
+        Subscribers
+            ↓
+        SQLite / Plugins
+    """
+
+    CHUNK_SIZE = 100_000
+
+    def __init__(self, symbol, tick_bus, repository):
+        """
+        Parameters
+        ----------
+        symbol : str
+            Símbolo a carregar (ex: WINJ26)
+
+        tick_bus : TickBus
+            Event bus responsável pela distribuição dos ticks.
+
+        repository : TickRepository
+            Repositório responsável pela persistência.
+        """
+
+        self.symbol = symbol
+        self.tick_bus = tick_bus
+        self.repository = repository
+
+        self.last_time_msc = None
+
+    # ---------------------------------------------------------
+    # util
+    # ---------------------------------------------------------
+
+    def _get_last_stored(self):
+        """
+        Consulta o último tick armazenado no banco.
+
+        Returns
+        -------
+        int or None
+            Timestamp em milissegundos do último tick armazenado.
+        """
+
+        last = self.repository._get_last_tick_msc(self.symbol)
+
+        if last:
+            logger.info(
+                "Backfill retomando do último tick armazenado: %s",
+                last,
+            )
+
+        return last
+
+    # ---------------------------------------------------------
+    # main
+    # ---------------------------------------------------------
+
+    def run(self, days=5):
+        """
+        Executa o processo de backfill.
+
+        Parameters
+        ----------
+        days : int
+            Número de dias de histórico caso não exista
+            histórico local no banco.
+
+        Notes
+        -----
+        O processo é incremental:
+
+        - se o banco possuir ticks, continua a partir do último
+        - caso contrário inicia no passado definido por `days`
+        """
+
+        logger.info(
+            "Backfill iniciado (%s) — até %s dias de histórico",
+            self.symbol,
+            days,
+        )
+
+        if not mt5.initialize():
+            logger.error("Falha ao inicializar MetaTrader5")
+            return
+
+        mt5.symbol_select(self.symbol, True)
+
+        now = datetime.datetime.utcnow()
+
+        last = self._get_last_stored()
+
+        if last:
+            start = datetime.datetime.fromtimestamp(last / 1000)
+            self.last_time_msc = last
+        else:
+            start = now - datetime.timedelta(days=days)
+
+        total_loaded = 0
+
+        while True:
+
+            ticks = mt5.copy_ticks_from(
+                self.symbol,
+                start,
+                self.CHUNK_SIZE,
+                mt5.COPY_TICKS_ALL,
+            )
+
+            if ticks is None or len(ticks) == 0:
+                break
+
+            # ---------------------------------------------
+            # filtro de duplicação (vetorizado numpy)
+            # ---------------------------------------------
+
+            if self.last_time_msc:
+
+                mask = ticks["time_msc"] > self.last_time_msc
+                ticks = ticks[mask]
+
+                if len(ticks) == 0:
+                    break
+
+            # ---------------------------------------------
+            # publica no event bus
+            # ---------------------------------------------
+
+            for i in range(len(ticks)):
+                self.tick_bus.publish(ticks[i])
+
+            # ---------------------------------------------
+            # grava no banco
+            # ---------------------------------------------
+
+            inserted = self.repository.insert_ticks(
+                self.symbol,
+                ticks
+            )
+
+            total_loaded += inserted
+
+            # último tick do chunk
+            self.last_time_msc = int(ticks["time_msc"][-1])
+
+            # próximo ponto de leitura
+            start = datetime.datetime.fromtimestamp(
+                self.last_time_msc / 1000
+            )
+
+            if len(ticks) < self.CHUNK_SIZE:
+                break
+
+        logger.info(
+            "Backfill concluído (%s) — %s ticks inseridos",
+            self.symbol,
+            f"{total_loaded:,}",
+        )

mtcli-3.8.0.dev12/mtcli/marketdata/tick_bus.py

@@ -0,0 +1,45 @@
+"""
+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")

mtcli-3.8.0.dev12/mtcli/marketdata/tick_cache.py

@@ -0,0 +1,160 @@
+"""
+Cache de ticks em memória.
+
+Mantém uma janela recente de ticks para acesso rápido
+sem necessidade de consultar o banco SQLite.
+
+Este cache é usado principalmente por:
+
+- plugins em tempo real
+- cálculos de indicadores
+- geração de renko
+- tape reading
+- consultas recentes
+
+A estrutura utiliza `collections.deque`, que oferece:
+
+- inserção O(1)
+- remoção automática quando atinge max_size
+- excelente performance para streams de dados
+"""
+
+from collections import deque
+from typing import Iterable, Iterator, Any, List
+
+
+class TickCache:
+    """
+    Mantém uma janela deslizante de ticks em memória.
+
+    Parameters
+    ----------
+    max_size : int
+        Número máximo de ticks armazenados no cache.
+    """
+
+    def __init__(self, max_size: int = 10000):
+
+        self.buffer: deque = deque(maxlen=max_size)
+
+    # ==========================================================
+    # INSERÇÃO
+    # ==========================================================
+
+    def add(self, tick: Any) -> None:
+        """
+        Adiciona um único tick ao cache.
+
+        Parameters
+        ----------
+        tick : Any
+            Tick a ser armazenado.
+        """
+
+        self.buffer.append(tick)
+
+    # ----------------------------------------------------------
+
+    def add_many(self, ticks: Iterable[Any]) -> None:
+        """
+        Adiciona múltiplos ticks ao cache.
+
+        Parameters
+        ----------
+        ticks : iterable
+            Coleção de ticks.
+        """
+
+        for t in ticks:
+            self.buffer.append(t)
+
+    # ==========================================================
+    # CONSULTA
+    # ==========================================================
+
+    def get_last(self) -> Any:
+        """
+        Retorna o último tick armazenado.
+
+        Returns
+        -------
+        tick ou None
+        """
+
+        if self.buffer:
+            return self.buffer[-1]
+
+        return None
+
+    # ----------------------------------------------------------
+
+    def get_last_n(self, n: int) -> List[Any]:
+        """
+        Retorna os últimos N ticks do cache.
+
+        Parameters
+        ----------
+        n : int
+            Número de ticks desejados.
+
+        Returns
+        -------
+        list
+            Lista contendo os últimos ticks.
+        """
+
+        if n <= 0:
+            return []
+
+        return list(self.buffer)[-n:]
+
+    # ----------------------------------------------------------
+
+    def get_all(self) -> List[Any]:
+        """
+        Retorna todos os ticks armazenados no cache.
+
+        Returns
+        -------
+        list
+        """
+
+        return list(self.buffer)
+
+    # ==========================================================
+    # UTILIDADES
+    # ==========================================================
+
+    def clear(self) -> None:
+        """
+        Limpa completamente o cache.
+        """
+
+        self.buffer.clear()
+
+    # ----------------------------------------------------------
+
+    def __len__(self) -> int:
+        """
+        Retorna o número atual de ticks armazenados.
+
+        Permite uso de:
+
+        len(cache)
+        """
+
+        return len(self.buffer)
+
+    # ----------------------------------------------------------
+
+    def __iter__(self) -> Iterator[Any]:
+        """
+        Permite iterar diretamente sobre o cache.
+
+        Exemplo:
+
+        for tick in cache:
+            ...
+        """
+
+        return iter(self.buffer)