mtcli 3.8.0.dev4__tar.gz → 3.8.0.dev6__tar.gz

{mtcli-3.8.0.dev4 → mtcli-3.8.0.dev6}/PKG-INFO

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

{mtcli-3.8.0.dev4 → mtcli-3.8.0.dev6}/mtcli/cli.py

@@ -1,56 +1,74 @@
 """
 CLI principal do mtcli.
+
+Responsável por:
+
+- inicializar o ambiente do CLI
+- carregar plugins
+- iniciar captura automática de ticks (opcional)
+
+A captura automática é ativada se a variável de ambiente
+MTCLI_SYMBOL estiver definida.
+
+Exemplo:
+
+    MTCLI_SYMBOL=WIN$N mt bars
+
+Nesse caso o mtcli inicia um TickEngine em background
+para manter o histórico de ticks atualizado.
 """
 
 import os
-import threading
 import click
 
 from mtcli.plugin_loader import load_plugins
 from mtcli.logger import setup_logger
-from mtcli.marketdata.tick_streamer import TickStreamer
+from mtcli.marketdata.tick_engine import TickEngine
 
 from .commands.bars import bars
 from .commands.doctor import doctor
 from .commands.migrate import migrate
+from .commands.ticks import ticks
 
 
 logger = setup_logger(__name__)
 
-_tick_streamer = None
+_tick_engine = None
 
 
 def start_tick_capture():
+    """
+    Inicia captura contínua de ticks em background.
 
-    global _tick_streamer
+    Se a variável de ambiente MTCLI_SYMBOL estiver definida,
+    o mtcli iniciará automaticamente um TickEngine para
+    coletar ticks continuamente.
 
-    if _tick_streamer:
+    Isso permite manter um histórico próprio de ticks
+    independente do histórico do broker.
+    """
+
+    global _tick_engine
+
+    if _tick_engine:
         return
 
     symbol = os.getenv("MTCLI_SYMBOL")
 
     if not symbol:
-        logger.info("Captura 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_streamer = TickStreamer(symbol)
-
-        thread = threading.Thread(
-            target=_tick_streamer.start,
-            daemon=True,
-            name="mtcli-tick-streamer",
-        )
-
-        thread.start()
+        _tick_engine = TickEngine([symbol])
+        _tick_engine.start()
 
         logger.info("Captura de ticks iniciada em background.")
 
     except Exception:
-
         logger.exception("Falha ao iniciar captura de ticks")
 
 
@@ -58,6 +76,9 @@ def start_tick_capture():
 @click.version_option(package_name="mtcli")
 @click.pass_context
 def mt(ctx):
+    """
+    CLI principal do mtcli.
+    """
 
     start_tick_capture()
 
@@ -69,6 +90,7 @@ mt.add_command(doctor, name="doctor")
 mt.add_command(bars, name="bars")
 mt.add_command(doctor, name="dr")
 mt.add_command(migrate)
+mt.add_command(ticks)
 
 loaded_plugins = load_plugins(mt)
 
@@ -77,6 +99,9 @@ logger.info("Plugins carregados: %s", loaded_plugins)
 
 @mt.command(name="plugins")
 def list_plugins():
+    """
+    Lista os plugins carregados no mtcli.
+    """
 
     if not loaded_plugins:
         click.echo("Nenhum plugin carregado.")

mtcli-3.8.0.dev6/mtcli/commands/ticks.py

@@ -0,0 +1,47 @@
+"""
+Comando CLI para captura contínua de ticks.
+
+Permite iniciar um TickEngine manualmente
+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
+
+
+@click.command()
+@click.argument("symbols", nargs=-1)
+def ticks(symbols):
+    """
+    Inicia captura contínua de ticks para os símbolos informados.
+    """
+
+    if not symbols:
+        click.echo("Informe ao menos um símbolo.")
+        return
+
+    engine = TickEngine(symbols)
+
+    click.echo("Iniciando captura de ticks...")
+
+    engine.start()
+
+    try:
+
+        while True:
+            time.sleep(1)
+
+    except KeyboardInterrupt:
+
+        click.echo("\nEncerrando captura de ticks...")
+        engine.stop()

{mtcli-3.8.0.dev4 → mtcli-3.8.0.dev6}/mtcli/database.py

@@ -44,6 +44,7 @@ def get_connection():
     conn.execute("PRAGMA mmap_size=268435456")
     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")

mtcli-3.8.0.dev6/mtcli/marketdata/tick_engine.py

@@ -0,0 +1,134 @@
+"""
+TickEngine - motor de captura contínua de ticks.
+
+Responsável por:
+
+- sincronizar histórico inicial
+- capturar ticks em tempo real
+- persistir ticks via TickRepository
+"""
+
+import time
+import threading
+import MetaTrader5 as mt5
+
+from datetime import datetime
+
+from mtcli.mt5_context import mt5_conexao
+from .tick_repository import TickRepository
+
+
+class TickEngine:
+
+    POLL_INTERVAL = 0.2
+    BATCH_SIZE = 1000
+    OVERLAP_MS = 5
+
+    def __init__(self, symbols):
+
+        self.symbols = symbols
+
+        self.repositories = {
+            symbol: TickRepository()
+            for symbol in symbols
+        }
+
+        self.running = False
+        self.thread = None
+
+    def start(self):
+
+        if self.running:
+            return
+
+        self.running = True
+
+        self.thread = threading.Thread(
+            target=self._run,
+            daemon=True,
+            name="mtcli-tick-engine",
+        )
+
+        self.thread.start()
+
+    def stop(self):
+
+        self.running = False
+
+        if self.thread:
+            self.thread.join()
+
+    def _run(self):
+
+        with mt5_conexao():
+
+            last_positions = {}
+
+            for symbol in self.symbols:
+
+                repo = self.repositories[symbol]
+
+                # sincroniza histórico
+                repo.sync(symbol)
+
+                last_msc = repo._get_last_tick_msc(symbol)
+
+                if last_msc:
+                    last_positions[symbol] = last_msc
+                else:
+                    last_positions[symbol] = int(time.time() * 1000)
+
+            while self.running:
+
+                for symbol in self.symbols:
+                    self._drain_symbol(symbol, last_positions)
+
+                time.sleep(self.POLL_INTERVAL)
+
+    def _drain_symbol(self, symbol, last_positions):
+
+        repo = self.repositories[symbol]
+
+        last_msc = last_positions[symbol]
+
+        start_dt = datetime.fromtimestamp(
+            (last_msc - self.OVERLAP_MS) / 1000
+        )
+
+        while True:
+
+            ticks = mt5.copy_ticks_from(
+                symbol,
+                start_dt,
+                self.BATCH_SIZE,
+                mt5.COPY_TICKS_ALL,
+            )
+
+            if ticks is None or len(ticks) == 0:
+                break
+
+            repo.conn.execute("BEGIN")
+
+            try:
+
+                repo._insert_ticks(symbol, ticks)
+
+                repo.cache.add_many(ticks)
+
+                repo.conn.commit()
+
+            except Exception:
+
+                repo.conn.rollback()
+                raise
+
+            last_msc = int(ticks[-1]["time_msc"])
+
+            last_positions[symbol] = last_msc + 1
+
+            start_dt = datetime.fromtimestamp(
+                (last_msc - self.OVERLAP_MS) / 1000
+            )
+
+            if len(ticks) < self.BATCH_SIZE:
+                break

{mtcli-3.8.0.dev4 → mtcli-3.8.0.dev6}/mtcli/marketdata/tick_repository.py

@@ -3,12 +3,13 @@ TickRepository.
 
 Responsável por:
 
-- Persistir ticks no SQLite
-- Sincronizar histórico inicial
-- Consultas rápidas para engines
+- persistência de ticks
+- sincronização histórica
+- consultas rápidas
 """
 
 import MetaTrader5 as mt5
+
 from datetime import datetime, timedelta
 
 from ..database import get_connection, backup_database
@@ -18,7 +19,7 @@ from mtcli.mt5_context import mt5_conexao
 
 class TickRepository:
 
-    BATCH_SIZE = 200000
+    RANGE_WINDOW_MINUTES = 10
 
     def __init__(self):
 
@@ -28,64 +29,64 @@ class TickRepository:
         self.last_backup_day = None
 
     # ==========================================================
-    # SINCRONIZAÇÃO HISTÓRICA
+    # SYNC HISTÓRICO
     # ==========================================================
 
     def sync(self, symbol: str, days_back: int = 1):
 
         total_inserted = 0
 
-        with mt5_conexao():
+        end = datetime.now()
 
-            last_msc = self._get_last_tick_msc(symbol)
+        last_msc = self._get_last_tick_msc(symbol)
 
-            if last_msc:
-                start = datetime.fromtimestamp((last_msc + 1) / 1000)
-            else:
-                start = datetime.now() - timedelta(days=days_back)
+        if last_msc:
+            start = datetime.fromtimestamp((last_msc + 1) / 1000)
+        else:
+            start = end - timedelta(days=days_back)
 
-            self.conn.execute("BEGIN")
+        window = timedelta(minutes=self.RANGE_WINDOW_MINUTES)
+
+        with mt5_conexao():
 
-            try:
+            while start < end:
 
-                while True:
+                chunk_end = min(start + window, end)
 
-                    ticks = mt5.copy_ticks_from(
-                        symbol,
-                        start,
-                        self.BATCH_SIZE,
-                        mt5.COPY_TICKS_ALL,
-                    )
+                ticks = mt5.copy_ticks_range(
+                    symbol,
+                    start,
+                    chunk_end,
+                    mt5.COPY_TICKS_ALL
+                )
 
-                    if ticks is None or len(ticks) == 0:
-                        break
+                if ticks is not None and len(ticks) > 0:
 
-                    inserted = self._insert_ticks(symbol, ticks)
+                    self.conn.execute("BEGIN")
 
-                    total_inserted += inserted
+                    try:
 
-                    self.cache.add_many(ticks)
+                        inserted = self._insert_ticks(symbol, ticks)
 
-                    last_msc = int(ticks[-1]["time_msc"])
+                        total_inserted += inserted
 
-                    start = datetime.fromtimestamp((last_msc + 1) / 1000)
+                        self.cache.add_many(ticks)
 
-                    if len(ticks) < self.BATCH_SIZE:
-                        break
+                        self.conn.commit()
 
-                self.conn.commit()
+                    except Exception:
 
-            except Exception:
+                        self.conn.rollback()
+                        raise
 
-                self.conn.rollback()
-                raise
+                start = chunk_end
 
         self._daily_backup()
 
         return total_inserted
 
     # ==========================================================
-    # INSERÇÃO
+    # INSERT
     # ==========================================================
 
     def _insert_ticks(self, symbol, ticks):
@@ -112,7 +113,7 @@ class TickRepository:
                 symbol,time,time_msc,bid,ask,last,volume,flags
             )
             VALUES (?,?,?,?,?,?,?,?)
-            ON CONFLICT(symbol,time) DO NOTHING
+            ON CONFLICT(symbol,time_msc) DO NOTHING
             """,
             data,
         )
@@ -162,7 +163,7 @@ class TickRepository:
         return cursor.fetchall()
 
     # ==========================================================
-    # UTILITÁRIOS
+    # UTIL
     # ==========================================================
 
     def _get_last_tick_msc(self, symbol):
@@ -178,9 +179,9 @@ class TickRepository:
             (symbol,),
         )
 
-        result = cursor.fetchone()
+        row = cursor.fetchone()
 
-        return result[0] if result and result[0] else None
+        return row[0] if row and row[0] else None
 
     def _daily_backup(self):
 

mtcli-3.8.0.dev6/mtcli/migrations/004_ticks_pk_time_msc.py

@@ -0,0 +1,56 @@
+def upgrade(conn):
+
+    cursor = conn.execute("""
+        SELECT sql
+        FROM sqlite_master
+        WHERE type='table'
+        AND name='ticks'
+    """)
+
+    row = cursor.fetchone()
+
+    if not row:
+        return
+
+    if "PRIMARY KEY(symbol, time_msc)" in row[0]:
+        return
+
+    print("Rebuilding ticks table with PK(symbol,time_msc)...")
+
+    conn.execute("PRAGMA foreign_keys=OFF")
+
+    conn.execute("""
+    CREATE TABLE ticks_new(
+        symbol TEXT NOT NULL,
+        time INTEGER NOT NULL,
+        time_msc INTEGER NOT NULL,
+        bid REAL,
+        ask REAL,
+        last REAL,
+        volume REAL,
+        flags INTEGER,
+        PRIMARY KEY(symbol, time_msc)
+    ) WITHOUT ROWID
+    """)
+
+    conn.execute("""
+    INSERT INTO ticks_new
+    SELECT
+        symbol,
+        time,
+        COALESCE(time_msc,time),
+        bid,
+        ask,
+        last,
+        volume,
+        flags
+    FROM ticks
+    """)
+
+    conn.execute("DROP TABLE ticks")
+
+    conn.execute("ALTER TABLE ticks_new RENAME TO ticks")
+
+    conn.commit()
+
+    print("ticks table rebuilt with PK(symbol,time_msc)")

{mtcli-3.8.0.dev4 → mtcli-3.8.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli"
-version = "3.8.0.dev4"
+version = "3.8.0.dev6"
 description = "Aplicativo CLI para exibir gráficos do MetaTrader 5 screen reader friendly"
 authors = [
     {name = "Valmir França",email = "vfranca3@gmail.com"}

mtcli-3.8.0.dev4/mtcli/marketdata/tick_engine.py

@@ -1,93 +0,0 @@
-"""
-Motor de captura de ticks multi-ativo.
-"""
-
-import time
-import threading
-import MetaTrader5 as mt5
-from datetime import datetime
-
-from mtcli.mt5_context import mt5_conexao
-from .tick_repository import TickRepository
-
-
-class TickEngine:
-
-    POLL_INTERVAL = 0.2
-
-    def __init__(self, symbols):
-
-        self.symbols = symbols
-
-        self.repositories = {
-            symbol: TickRepository()
-            for symbol in symbols
-        }
-
-        self.running = False
-
-    def start(self):
-
-        thread = threading.Thread(
-            target=self._run,
-            daemon=True
-        )
-
-        self.running = True
-        thread.start()
-
-    def stop(self):
-
-        self.running = False
-
-    def _run(self):
-
-        with mt5_conexao():
-
-            last_positions = {}
-
-            for symbol in self.symbols:
-
-                repo = self.repositories[symbol]
-                last_msc = repo._get_last_tick_msc(symbol)
-
-                if last_msc:
-                    last_positions[symbol] = last_msc + 1
-                else:
-                    last_positions[symbol] = int(time.time() * 1000)
-
-            while self.running:
-
-                for symbol in self.symbols:
-
-                    repo = self.repositories[symbol]
-
-                    start = last_positions[symbol]
-
-                    ticks = mt5.copy_ticks_from(
-                        symbol,
-                        datetime.fromtimestamp(start / 1000),
-                        1000,
-                        mt5.COPY_TICKS_ALL
-                    )
-
-                    if ticks is None or len(ticks) == 0:
-                        continue
-
-                    repo.conn.execute("BEGIN")
-
-                    try:
-
-                        repo._insert_ticks(symbol, ticks)
-
-                        repo.cache.add_many(ticks)
-
-                        repo.conn.commit()
-
-                    except Exception:
-
-                        repo.conn.rollback()
-
-                    last_positions[symbol] = int(ticks[-1]["time_msc"]) + 1
-
-                time.sleep(self.POLL_INTERVAL)

mtcli-3.8.0.dev4/mtcli/marketdata/tick_streamer.py

@@ -1,62 +0,0 @@
-"""
-Captura contínua de ticks.
-"""
-
-import time
-import MetaTrader5 as mt5
-from datetime import datetime
-
-from mtcli.mt5_context import mt5_conexao
-from .tick_repository import TickRepository
-
-
-class TickStreamer:
-
-    def __init__(self, symbol):
-
-        self.symbol = symbol
-        self.repo = TickRepository()
-        self.running = False
-
-    def start(self):
-
-        self.running = True
-
-        with mt5_conexao():
-
-            last_msc = self.repo._get_last_tick_msc(self.symbol)
-
-            if last_msc:
-                start = last_msc + 1
-            else:
-                start = int(time.time() * 1000)
-
-            while self.running:
-
-                ticks = mt5.copy_ticks_from(
-                    self.symbol,
-                    datetime.fromtimestamp(start / 1000),
-                    1000,
-                    mt5.COPY_TICKS_ALL,
-                )
-
-                if ticks is None or len(ticks) == 0:
-
-                    time.sleep(0.1)
-                    continue
-
-                self.repo.conn.execute("BEGIN")
-
-                try:
-
-                    self.repo._insert_ticks(self.symbol, ticks)
-
-                    self.repo.cache.add_many(ticks)
-
-                    self.repo.conn.commit()
-
-                except Exception:
-
-                    self.repo.conn.rollback()
-
-                start = int(ticks[-1]["time_msc"]) + 1