mtcli-risco 2.4.2__tar.gz → 2.5.1__tar.gz

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli-risco
-Version: 2.4.2
+Version: 2.5.1
 Summary: Plugin mtcli para controle de loss diário
 License-Expression: MIT
 License-File: LICENSE
@@ -19,7 +19,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Dist: click (>=8.3.1,<9.0.0)
 Requires-Dist: metatrader5 (>=5.0.5572,<6.0.0)
-Requires-Dist: mtcli (>=3.7.0)
+Requires-Dist: mtcli (>=3.7.2)
 Project-URL: Documentation, https://mtcli-risco.readthedocs.io
 Project-URL: Homepage, https://github.com/vfranca/mtcli-risco
 Project-URL: Repository, https://github.com/vfranca/mtcli-risco

mtcli_risco-2.5.1/mtcli_risco/cli.py

@@ -0,0 +1,33 @@
+"""
+Comando principal e registro dos subcomandos
+"""
+
+import click
+from .commands.checar import checar
+from .commands.monitorar import monitorar
+from .commands.lucro import lucro
+from .commands.panic import panic
+from .commands.start import start
+from .commands.stop import stop
+from .commands.status import status
+
+
+@click.group()
+@click.version_option(package_name="mtcli-risco")
+def cli():
+    """
+    Plugin mtcli-risco.
+
+    Conjunto de comandos para gerenciamento e controle de risco diário
+    baseado em lucro/prejuízo no MetaTrader 5.
+    """
+    pass
+
+
+cli.add_command(checar, name="checar")
+cli.add_command(monitorar, name="monitorar")
+cli.add_command(lucro, name="lucro")
+cli.add_command(panic, name="panic")
+cli.add_command(start, name="start")
+cli.add_command(stop, name="stop")
+cli.add_command(status, name="status")

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/commands/checar.py

@@ -1,75 +1,75 @@
-"""
-Comando checar.
-
-Verifica se o limite diário de prejuízo foi atingido e,
-se necessário, encerra posições e bloqueia novas ordens.
-"""
-
-import click
-from datetime import date
-from mtcli.logger import setup_logger
-from mtcli_risco.conf import LOSS_LIMIT, STATUS_FILE
-from mtcli_risco.models.trades_model import calcular_lucro_total_dia
-from mtcli_risco.models.checar_model import (
-    carregar_estado,
-    salvar_estado,
-    risco_excedido,
-    encerrar_todas_posicoes,
-    cancelar_todas_ordens,
-)
-
-log = setup_logger()
-
-
-@click.command(
-    "checar",
-    help="Verifica se o limite diário de prejuízo foi atingido.",
-)
-@click.version_option(package_name="mtcli-risco")
-@click.option(
-    "--limite",
-    "-l",
-    default=LOSS_LIMIT,
-    help="Limite de perda diária (ex: -500).",
-)
-@click.option(
-    "--lucro",
-    is_flag=True,
-    default=False,
-    help="Exibe o lucro total do dia e encerra.",
-)
-def checar_cmd(limite: float, lucro: bool):
-    """
-    Executa uma verificação pontual do risco diário.
-    """
-    if lucro:
-        total = calcular_lucro_total_dia()
-        click.echo(f"Lucro total do dia: {total:.2f}")
-        log.info(f"[RISCO] Lucro total do dia: {total:.2f}")
-        return
-
-    hoje = date.today()
-    estado = carregar_estado(STATUS_FILE)
-
-    # Reset diário
-    if estado["data"] != hoje.isoformat():
-        log.info("[ESTADO] Novo dia detectado, resetando bloqueio.")
-        estado["bloqueado"] = False
-        salvar_estado(STATUS_FILE, hoje, False)
-
-    if estado["bloqueado"]:
-        click.echo("Sistema bloqueado hoje por limite de risco.")
-        log.warning("[RISCO] Sistema já bloqueado hoje.")
-        return
-
-    if risco_excedido(limite):
-        click.echo(
-            f"Limite {limite:.2f} excedido. Encerrando posições e bloqueando ordens."
-        )
-        log.warning(f"[RISCO] Limite {limite:.2f} excedido.")
-        encerrar_todas_posicoes()
-        cancelar_todas_ordens()
-        salvar_estado(STATUS_FILE, hoje, True)
-    else:
-        click.echo("Dentro do limite de risco.")
-        log.info(f"[RISCO] Dentro do limite {limite:.2f}.")
+"""
+Comando checar.
+
+Verifica se o limite diário de prejuízo foi atingido e,
+se necessário, encerra posições e bloqueia novas ordens.
+"""
+
+import click
+from datetime import date
+from mtcli.logger import setup_logger
+from mtcli_risco.conf import LOSS_LIMIT, STATUS_FILE
+from mtcli_risco.models.trades_model import calcular_lucro_total_dia
+from mtcli_risco.models.checar_model import (
+    carregar_estado,
+    salvar_estado,
+    risco_excedido,
+    encerrar_todas_posicoes,
+    cancelar_todas_ordens,
+)
+
+log = setup_logger(__name__)
+
+
+@click.command(
+    "checar",
+    help="Verifica se o limite diário de prejuízo foi atingido.",
+)
+@click.version_option(package_name="mtcli-risco")
+@click.option(
+    "--limite",
+    "-l",
+    default=LOSS_LIMIT,
+    help="Limite de perda diária (ex: -500).",
+)
+@click.option(
+    "--lucro",
+    is_flag=True,
+    default=False,
+    help="Exibe o lucro total do dia e encerra.",
+)
+def checar(limite: float, lucro: bool):
+    """
+    Executa uma verificação pontual do risco diário.
+    """
+    if lucro:
+        total = calcular_lucro_total_dia()
+        click.echo(f"Lucro total do dia: {total:.2f}")
+        log.info(f"[RISCO] Lucro total do dia: {total:.2f}")
+        return
+
+    hoje = date.today()
+    estado = carregar_estado(STATUS_FILE)
+
+    # Reset diário
+    if estado["data"] != hoje.isoformat():
+        log.info("[ESTADO] Novo dia detectado, resetando bloqueio.")
+        estado["bloqueado"] = False
+        salvar_estado(STATUS_FILE, hoje, False)
+
+    if estado["bloqueado"]:
+        click.echo("Sistema bloqueado hoje por limite de risco.")
+        log.warning("[RISCO] Sistema já bloqueado hoje.")
+        return
+
+    if risco_excedido(limite):
+        click.echo(
+            f"Limite {limite:.2f} excedido. Encerrando posições e bloqueando ordens."
+        )
+        log.warning(f"[RISCO] Limite {limite:.2f} excedido.")
+        encerrar_todas_posicoes()
+        cancelar_todas_ordens()
+        salvar_estado(STATUS_FILE, hoje, True)
+    else:
+        click.echo("Dentro do limite de risco.")
+        log.info(f"[RISCO] Dentro do limite {limite:.2f}.")

mtcli_risco-2.4.2/mtcli_risco/commands/trades.py → mtcli_risco-2.5.1/mtcli_risco/commands/lucro.py

@@ -1,51 +1,51 @@
-"""
-Comando trades.
-
-Exibe lucros realizados, abertos e totais do dia.
-"""
-
-import click
-from mtcli.logger import setup_logger
-from mtcli_risco.models.trades_model import (
-    obter_lucro_aberto,
-    calcular_lucro_realizado,
-    calcular_lucro_total_dia,
-)
-
-log = setup_logger()
-
-
-@click.command(
-    "trades",
-    help="Exibe os lucros realizados, abertos e totais do dia.",
-)
-@click.version_option(package_name="mtcli-risco")
-@click.option("--aberto", "-a", is_flag=True, help="Exibe o lucro em aberto.")
-@click.option("--realizado", "-r", is_flag=True, help="Exibe o lucro realizado.")
-@click.option("--total", "-t", is_flag=True, help="Exibe o lucro total.")
-def trades_cmd(aberto: bool, realizado: bool, total: bool):
-    """
-    Exibe informações de lucro do dia atual.
-    """
-    if aberto:
-        valor = obter_lucro_aberto()
-        click.echo(f"{valor:.2f}")
-        return
-
-    if realizado:
-        valor = calcular_lucro_realizado()
-        click.echo(f"{valor:.2f}")
-        return
-
-    if total:
-        valor = calcular_lucro_total_dia()
-        click.echo(f"{valor:.2f}")
-        return
-
-    aberto_v = obter_lucro_aberto()
-    realizado_v = calcular_lucro_realizado()
-    total_v = aberto_v + realizado_v
-
-    click.echo(f"lucro em aberto: {aberto_v:.2f}")
-    click.echo(f"lucro realizado: {realizado_v:.2f}")
-    click.echo(f"lucro total: {total_v:.2f}")
+"""
+Comando lucro.
+
+Exibe lucros realizados, abertos e totais do dia.
+"""
+
+import click
+from mtcli.logger import setup_logger
+from mtcli_risco.models.trades_model import (
+    obter_lucro_aberto,
+    calcular_lucro_realizado,
+    calcular_lucro_total_dia,
+)
+
+log = setup_logger(__name__)
+
+
+@click.command(
+    "lucro",
+    help="Exibe os lucros realizados, abertos e totais do dia.",
+)
+@click.version_option(package_name="mtcli-risco")
+@click.option("--aberto", "-a", is_flag=True, help="Exibe o lucro em aberto.")
+@click.option("--realizado", "-r", is_flag=True, help="Exibe o lucro realizado.")
+@click.option("--total", "-t", is_flag=True, help="Exibe o lucro total.")
+def lucro(aberto: bool, realizado: bool, total: bool):
+    """
+    Exibe informações de lucro do dia atual.
+    """
+    if aberto:
+        valor = obter_lucro_aberto()
+        click.echo(f"{valor:.2f}")
+        return
+
+    if realizado:
+        valor = calcular_lucro_realizado()
+        click.echo(f"{valor:.2f}")
+        return
+
+    if total:
+        valor = calcular_lucro_total_dia()
+        click.echo(f"{valor:.2f}")
+        return
+
+    aberto_v = obter_lucro_aberto()
+    realizado_v = calcular_lucro_realizado()
+    total_v = aberto_v + realizado_v
+
+    click.echo(f"lucro em aberto: {aberto_v:.2f}")
+    click.echo(f"lucro realizado: {realizado_v:.2f}")
+    click.echo(f"lucro total: {total_v:.2f}")

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/commands/monitorar.py

@@ -1,64 +1,64 @@
-"""
-Comando monitorar.
-
-Monitora continuamente o risco diário e executa PANIC CLOSE
-quando o limite é excedido.
-"""
-
-import time
-import click
-from datetime import date
-from mtcli.logger import setup_logger
-from mtcli_risco.conf import LOSS_LIMIT, STATUS_FILE, INTERVALO
-from mtcli_risco.models.checar_model import (
-    carregar_estado,
-    salvar_estado,
-    risco_excedido,
-)
-from mtcli_risco.models.panic_model import panic_close_all
-
-log = setup_logger()
-
-
-@click.command()
-@click.version_option(package_name="mtcli-risco")
-@click.option("--limite", "-l", default=LOSS_LIMIT, show_default=True)
-@click.option("--intervalo", "-i", default=INTERVALO, show_default=True)
-@click.option("--dry-run", is_flag=True, help="Simula o panic close.")
-def monitorar_cmd(limite: float, intervalo: int, dry_run: bool):
-    """
-    Inicia o monitoramento contínuo do risco diário.
-    """
-    click.echo(
-        f"Monitorando risco | limite={limite:.2f} intervalo={intervalo}s"
-    )
-    log.info(
-        f"[MONITOR] Iniciado | limite={limite} intervalo={intervalo}s dry_run={dry_run}"
-    )
-
-    try:
-        while True:
-            hoje = date.today()
-            estado = carregar_estado(STATUS_FILE)
-
-            if estado["data"] != hoje.isoformat():
-                salvar_estado(STATUS_FILE, hoje, False)
-                estado["bloqueado"] = False
-
-            if not estado["bloqueado"] and risco_excedido(limite):
-                click.echo("LIMITE DE RISCO EXCEDIDO — PANIC CLOSE")
-                log.critical("[MONITOR] Disparando PANIC CLOSE")
-
-                resultado = panic_close_all(
-                    retry_on_market_open=True,
-                    dry_run=dry_run,
-                )
-
-                salvar_estado(STATUS_FILE, hoje, True)
-                log.critical(f"[MONITOR] Panic finalizado: {resultado}")
-
-            time.sleep(intervalo)
-
-    except KeyboardInterrupt:
-        click.echo("Monitoramento interrompido.")
-        log.info("[MONITOR] Interrompido pelo usuário.")
+"""
+Comando monitorar.
+
+Monitora continuamente o risco diário e executa PANIC CLOSE
+quando o limite é excedido.
+"""
+
+import time
+import click
+from datetime import date
+from mtcli.logger import setup_logger
+from ..conf import LOSS_LIMIT, STATUS_FILE, INTERVALO
+from ..models.checar_model import (
+    carregar_estado,
+    salvar_estado,
+    risco_excedido,
+)
+from ..models.panic_model import panic_close_all
+
+log = setup_logger(__name__)
+
+
+@click.command()
+@click.version_option(package_name="mtcli-risco")
+@click.option("--limite", "-l", default=LOSS_LIMIT, show_default=True)
+@click.option("--intervalo", "-i", default=INTERVALO, show_default=True)
+@click.option("--dry-run", is_flag=True, help="Simula o panic close.")
+def monitorar(limite: float, intervalo: int, dry_run: bool):
+    """
+    Inicia o monitoramento contínuo do risco diário.
+    """
+    click.echo(
+        f"Monitorando risco limite={limite:.2f} intervalo={intervalo}s"
+    )
+    log.info(
+        f"[MONITOR] Iniciado | limite={limite} intervalo={intervalo}s dry_run={dry_run}"
+    )
+
+    try:
+        while True:
+            hoje = date.today()
+            estado = carregar_estado(STATUS_FILE)
+
+            if estado["data"] != hoje.isoformat():
+                salvar_estado(STATUS_FILE, hoje, False)
+                estado["bloqueado"] = False
+
+            if not estado["bloqueado"] and risco_excedido(limite):
+                click.echo("LIMITE DE RISCO EXCEDIDO — PANIC CLOSE")
+                log.critical("[MONITOR] Disparando PANIC CLOSE")
+
+                resultado = panic_close_all(
+                    retry_on_market_open=True,
+                    dry_run=dry_run,
+                )
+
+                salvar_estado(STATUS_FILE, hoje, True)
+                log.critical(f"[MONITOR] Panic finalizado: {resultado}")
+
+            time.sleep(intervalo)
+
+    except KeyboardInterrupt:
+        click.echo("Monitoramento interrompido.")
+        log.info("[MONITOR] Interrompido pelo usuário.")

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/commands/panic.py

@@ -4,10 +4,10 @@ Comando PANIC CLOSE.
 
 import click
 from mtcli.logger import setup_logger
-from mtcli_risco.models.panic_model import panic_close_all
+from ..models.panic_model import panic_close_all
 from mtcli_risco import conf
 
-log = setup_logger()
+log = setup_logger(__name__)
 
 
 @click.command()
@@ -26,7 +26,7 @@ log = setup_logger()
     type=click.Path(exists=True),
     help="Caminho do terminal MT5 (override temporário)",
 )
-def panic_cmd(no_retry: bool, dry_run: bool, terminal_path: str | None):
+def panic(no_retry: bool, dry_run: bool, terminal_path: str | None):
     """
     Executa o PANIC CLOSE com HARDSTOP.
     """

mtcli_risco-2.5.1/mtcli_risco/commands/start.py

@@ -0,0 +1,101 @@
+"""
+Comando start.
+
+Responsável por iniciar o monitor de risco em background.
+
+- Evita múltiplas instâncias (verificando PID ativo)
+- Limpa PID inválido (processo morto)
+- Inicia subprocesso com monitor_loop
+"""
+
+import os
+import click
+import subprocess
+import sys
+import time
+import signal
+
+from mtcli.logger import setup_logger
+from mtcli.conf import PID_FILE
+from ..conf import LOSS_LIMIT, INTERVALO
+
+log = setup_logger("risco")
+
+
+def _pid_running(pid: int) -> bool:
+    """
+    Verifica se um PID está ativo no sistema.
+    """
+    try:
+        os.kill(pid, 0)
+        return True
+    except Exception:
+        return False
+
+
+@click.command()
+@click.option("--limite", default=LOSS_LIMIT, show_default=True)
+@click.option("--intervalo", default=INTERVALO, show_default=True)
+@click.option("--dry-run", is_flag=True, help="Simula execução sem enviar ordens.")
+def start(limite: float, intervalo: int, dry_run: bool) -> None:
+    """
+    Inicia o monitor de risco em background.
+    """
+
+    # ===============================
+    # Verifica PID existente
+    # ===============================
+    if os.path.exists(PID_FILE):
+
+        try:
+            with open(PID_FILE) as f:
+                pid = int(f.read().strip())
+
+            if _pid_running(pid):
+                click.echo(f"Monitor já está rodando (PID {pid}).")
+                log.warning("[START] Monitor já ativo | pid=%s", pid)
+                return
+            else:
+                log.warning("[START] PID morto detectado, removendo | pid=%s", pid)
+                os.remove(PID_FILE)
+
+        except Exception as e:
+            log.error("[START] Erro ao ler PID_FILE | erro=%s", e)
+            os.remove(PID_FILE)
+
+    # ===============================
+    # Comando subprocesso
+    # ===============================
+    cmd = [
+        sys.executable,
+        "-m",
+        "mtcli_risco.services.run_monitor",
+        str(limite),
+        str(intervalo),
+        str(int(dry_run)),
+    ]
+
+    log.info(
+        "[START] Iniciando monitor | limite=%.2f intervalo=%ss dry_run=%s",
+        limite,
+        intervalo,
+        dry_run,
+    )
+
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
+    time.sleep(1)
+
+    if proc.poll() is not None:
+        log.error("[START] Processo morreu imediatamente")
+        click.echo("Erro ao iniciar monitor (verifique logs).")
+        return
+
+    log.info("[START] Monitor iniciado | pid=%s", proc.pid)
+
+    click.echo(f"Monitor iniciado em background (PID {proc.pid}).")

mtcli_risco-2.5.1/mtcli_risco/commands/status.py

@@ -0,0 +1,57 @@
+"""
+Comando status.
+
+Exibe o estado atual do monitor de risco.
+
+O comando verifica:
+
+1. Existência do arquivo PID
+2. Presença do heartbeat
+3. Tempo desde o último heartbeat
+
+Isso permite detectar se o monitor:
+
+- está rodando
+- travou
+- ou foi encerrado.
+"""
+
+import os
+import time
+import click
+
+from mtcli.logger import setup_logger
+from mtcli.conf import PID_FILE, HEARTBEAT_FILE
+
+log = setup_logger(__name__)
+
+
+@click.command()
+def status() -> None:
+    """
+    Exibe o status atual do monitor de risco.
+    """
+
+    if not os.path.exists(PID_FILE):
+        click.echo("Monitor não está rodando.")
+        log.info("[STATUS] Monitor inativo")
+        return
+
+    with open(PID_FILE) as f:
+        pid = f.read().strip()
+
+    if os.path.exists(HEARTBEAT_FILE):
+
+        with open(HEARTBEAT_FILE) as f:
+            ts = float(f.read())
+
+        age = int(time.time() - ts)
+
+        click.echo(f"Monitor ativo (PID {pid})")
+        click.echo(f"Último heartbeat: {age}s")
+
+        log.debug("[STATUS] Monitor ativo | pid=%s heartbeat_age=%ss", pid, age)
+
+    else:
+        click.echo(f"Monitor rodando (PID {pid})")
+        log.warning("[STATUS] PID encontrado sem heartbeat | pid=%s", pid)

mtcli_risco-2.5.1/mtcli_risco/commands/stop.py

@@ -0,0 +1,87 @@
+"""
+Comando stop.
+
+Solicita a parada do monitor de risco.
+
+Estratégia:
+1. Envia sinal gracioso via STOP_FILE
+2. Fallback: encerra processo via PID (SIGTERM ou taskkill)
+"""
+
+import os
+import subprocess
+import click
+import time
+
+from mtcli.logger import setup_logger
+from mtcli.conf import STOP_FILE, PID_FILE
+
+log = setup_logger("risco")
+
+
+def _pid_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except Exception:
+        return False
+
+
+@click.command()
+def stop() -> None:
+    """
+    Para o monitor de risco com garantia de finalização.
+    """
+
+    # ===============================
+    # 1. STOP gracioso
+    # ===============================
+    try:
+        with open(STOP_FILE, "w") as f:
+            f.write("stop")
+
+        log.info("[STOP] STOP_FILE enviado")
+        click.echo("Sinal de parada enviado.")
+
+    except Exception as e:
+        log.error("[STOP] Erro ao criar STOP_FILE | erro=%s", e)
+
+    # ===============================
+    # 2. Aguarda parada graciosa
+    # ===============================
+    time.sleep(2)
+
+    # ===============================
+    # 3. Fallback: kill forçado
+    # ===============================
+    if os.path.exists(PID_FILE):
+
+        try:
+            with open(PID_FILE) as f:
+                pid = int(f.read().strip())
+
+            if not _pid_running(pid):
+                click.echo("Processo já estava parado.")
+                return
+
+            log.warning("[STOP] Forçando encerramento | pid=%s", pid)
+
+            result = subprocess.run(
+                ["taskkill", "/PID", str(pid), "/F", "/T"],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                log.warning("[STOP] Processo finalizado via taskkill | pid=%s", pid)
+                click.echo(f"Processo {pid} finalizado com sucesso.")
+            else:
+                log.error(
+                    "[STOP] Falha no taskkill | pid=%s stderr=%s",
+                    pid,
+                    result.stderr.strip(),
+                )
+                click.echo("Erro ao finalizar processo. Verifique logs.")
+
+        except Exception as e:
+            log.error("[STOP] Erro ao matar processo | erro=%s", e)

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/conf.py

@@ -1,31 +1,31 @@
-import os
-from mtcli.conf import config
-
-
-LOSS_LIMIT = float(
-    os.getenv(
-        "LOSS_LIMIT",
-        config["DEFAULT"].getfloat("loss_limit", fallback=-180.00),
-    )
-)
-
-STATUS_FILE = os.getenv(
-    "STATUS_FILE",
-    config["DEFAULT"].get("status_file", fallback="bloqueio.json"),
-)
-
-INTERVALO = int(
-    os.getenv(
-        "INTERVALO",
-        config["DEFAULT"].getint("intervalo", fallback=60),
-    )
-)
-
-# Caminho do executável do MetaTrader 5 (usado no HARDSTOP)
-MT5_TERMINAL_PATH = os.getenv(
-    "MT5_TERMINAL_PATH",
-    config["DEFAULT"].get(
-        "mt5_terminal_path",
-        fallback=r"C:\Program Files\MetaTrader 5\terminal64.exe",
-    ),
-)
+import os
+from mtcli.conf import config
+
+
+LOSS_LIMIT = float(
+    os.getenv(
+        "LOSS_LIMIT",
+        config["DEFAULT"].getfloat("loss_limit", fallback=-180.00),
+    )
+)
+
+STATUS_FILE = os.getenv(
+    "STATUS_FILE",
+    config["DEFAULT"].get("status_file", fallback="bloqueio.json"),
+)
+
+INTERVALO = int(
+    os.getenv(
+        "INTERVALO",
+        config["DEFAULT"].getint("intervalo", fallback=1),
+    )
+)
+
+# Caminho do executável do MetaTrader 5 (usado no HARDSTOP)
+MT5_TERMINAL_PATH = os.getenv(
+    "MT5_TERMINAL_PATH",
+    config["DEFAULT"].get(
+        "mt5_terminal_path",
+        fallback=r"C:\Program Files\MetaTrader 5\terminal64.exe",
+    ),
+)

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/models/checar_model.py

@@ -16,7 +16,7 @@ from mtcli.logger import setup_logger
 from mtcli.mt5_context import mt5_conexao
 from .trades_model import calcular_lucro_total_dia
 
-log = setup_logger()
+log = setup_logger("risco")
 
 
 def carregar_estado(status_file: str) -> dict:

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/models/hardstop_model.py

@@ -1,120 +1,120 @@
-"""
-Hardstop via Sistema Operacional (Windows).
-
-Responsável por:
-- Encerrar o processo do MetaTrader 5
-- Bloquear tráfego de rede do terminal via Firewall
-- Impedir qualquer novo envio de ordens após PANIC
-"""
-
-import os
-import subprocess
-from mtcli.logger import setup_logger
-from mtcli_risco.conf import MT5_TERMINAL_PATH
-
-log = setup_logger()
-
-FIREWALL_RULE_NAME = "MT5_HARDSTOP_BLOCK"
-
-
-def _run(cmd: list[str]) -> bool:
-    """
-    Executa comando no Windows.
-    """
-    try:
-        subprocess.run(
-            cmd,
-            check=True,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            shell=False,
-        )
-        return True
-    except subprocess.CalledProcessError as exc:
-        log.error(f"[HARDSTOP] Falha ao executar comando: {cmd} | {exc}")
-        return False
-
-
-def kill_mt5_process() -> None:
-    """
-    Encerra o processo do MetaTrader 5 à força.
-    """
-    exe_name = os.path.basename(MT5_TERMINAL_PATH)
-
-    log.critical(f"[HARDSTOP] Encerrando processo {exe_name}")
-
-    _run(
-        [
-            "taskkill",
-            "/F",
-            "/IM",
-            exe_name,
-        ]
-    )
-
-
-def block_mt5_firewall() -> None:
-    """
-    Bloqueia qualquer tráfego de rede do MT5 via Firewall do Windows.
-    """
-    log.critical(
-        f"[HARDSTOP] Bloqueando tráfego de rede do MT5 | {MT5_TERMINAL_PATH}"
-    )
-
-    # Remove regra anterior (idempotente)
-    _run(
-        [
-            "netsh",
-            "advfirewall",
-            "firewall",
-            "delete",
-            "rule",
-            f"name={FIREWALL_RULE_NAME}",
-        ]
-    )
-
-    # Cria regra de bloqueio
-    _run(
-        [
-            "netsh",
-            "advfirewall",
-            "firewall",
-            "add",
-            "rule",
-            f"name={FIREWALL_RULE_NAME}",
-            "dir=out",
-            "action=block",
-            f"program={MT5_TERMINAL_PATH}",
-            "enable=yes",
-        ]
-    )
-
-
-def unblock_mt5_firewall() -> None:
-    """
-    Remove o bloqueio de firewall do MT5 (uso manual).
-    """
-    log.warning("[HARDSTOP] Removendo bloqueio de firewall do MT5")
-
-    _run(
-        [
-            "netsh",
-            "advfirewall",
-            "firewall",
-            "delete",
-            "rule",
-            f"name={FIREWALL_RULE_NAME}",
-        ]
-    )
-
-
-def hardstop() -> None:
-    """
-    Executa o HARDSTOP completo:
-    - Mata o MT5
-    - Bloqueia rede via Firewall
-    """
-    log.critical("========== HARDSTOP ACIONADO ==========")
-    kill_mt5_process()
-    block_mt5_firewall()
-    log.critical("========== MT5 TOTALMENTE BLOQUEADO ==========")
+"""
+Hardstop via Sistema Operacional (Windows).
+
+Responsável por:
+- Encerrar o processo do MetaTrader 5
+- Bloquear tráfego de rede do terminal via Firewall
+- Impedir qualquer novo envio de ordens após PANIC
+"""
+
+import os
+import subprocess
+from mtcli.logger import setup_logger
+from mtcli_risco.conf import MT5_TERMINAL_PATH
+
+log = setup_logger("risco")
+
+FIREWALL_RULE_NAME = "MT5_HARDSTOP_BLOCK"
+
+
+def _run(cmd: list[str]) -> bool:
+    """
+    Executa comando no Windows.
+    """
+    try:
+        subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            shell=False,
+        )
+        return True
+    except subprocess.CalledProcessError as exc:
+        log.error(f"[HARDSTOP] Falha ao executar comando: {cmd} | {exc}")
+        return False
+
+
+def kill_mt5_process() -> None:
+    """
+    Encerra o processo do MetaTrader 5 à força.
+    """
+    exe_name = os.path.basename(MT5_TERMINAL_PATH)
+
+    log.critical(f"[HARDSTOP] Encerrando processo {exe_name}")
+
+    _run(
+        [
+            "taskkill",
+            "/F",
+            "/IM",
+            exe_name,
+        ]
+    )
+
+
+def block_mt5_firewall() -> None:
+    """
+    Bloqueia qualquer tráfego de rede do MT5 via Firewall do Windows.
+    """
+    log.critical(
+        f"[HARDSTOP] Bloqueando tráfego de rede do MT5 | {MT5_TERMINAL_PATH}"
+    )
+
+    # Remove regra anterior (idempotente)
+    _run(
+        [
+            "netsh",
+            "advfirewall",
+            "firewall",
+            "delete",
+            "rule",
+            f"name={FIREWALL_RULE_NAME}",
+        ]
+    )
+
+    # Cria regra de bloqueio
+    _run(
+        [
+            "netsh",
+            "advfirewall",
+            "firewall",
+            "add",
+            "rule",
+            f"name={FIREWALL_RULE_NAME}",
+            "dir=out",
+            "action=block",
+            f"program={MT5_TERMINAL_PATH}",
+            "enable=yes",
+        ]
+    )
+
+
+def unblock_mt5_firewall() -> None:
+    """
+    Remove o bloqueio de firewall do MT5 (uso manual).
+    """
+    log.warning("[HARDSTOP] Removendo bloqueio de firewall do MT5")
+
+    _run(
+        [
+            "netsh",
+            "advfirewall",
+            "firewall",
+            "delete",
+            "rule",
+            f"name={FIREWALL_RULE_NAME}",
+        ]
+    )
+
+
+def hardstop() -> None:
+    """
+    Executa o HARDSTOP completo:
+    - Mata o MT5
+    - Bloqueia rede via Firewall
+    """
+    log.critical("========== HARDSTOP ACIONADO ==========")
+    kill_mt5_process()
+    block_mt5_firewall()
+    log.critical("========== MT5 TOTALMENTE BLOQUEADO ==========")

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/models/panic_model.py

@@ -16,7 +16,7 @@ from mtcli.logger import setup_logger
 from mtcli.mt5_context import mt5_conexao
 from mtcli_risco.models.hardstop_model import hardstop
 
-log = setup_logger()
+log = setup_logger("risco")
 
 
 def _trade_permitido() -> bool:

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/mtcli_risco/models/trades_model.py

@@ -7,7 +7,7 @@ from datetime import datetime, time
 from mtcli.logger import setup_logger
 from mtcli.mt5_context import mt5_conexao
 
-log = setup_logger()
+log = setup_logger("risco")
 
 
 def calcular_lucro_realizado() -> float:

mtcli_risco-2.5.1/mtcli_risco/services/monitor_service.py

@@ -0,0 +1,79 @@
+"""
+Serviço de monitoramento de risco.
+
+- Monitora P/L continuamente
+- Dispara PANIC CLOSE
+- Atualiza heartbeat
+- Responde a STOP_FILE
+"""
+
+import time
+import os
+from datetime import date
+
+from mtcli.logger import setup_logger
+from mtcli.conf import STOP_FILE, HEARTBEAT_FILE
+from ..conf import STATUS_FILE
+from ..models.checar_model import (
+    carregar_estado,
+    salvar_estado,
+    risco_excedido,
+)
+from ..models.panic_model import panic_close_all
+
+log = setup_logger("risco")
+
+
+def write_heartbeat() -> None:
+    """
+    Atualiza o heartbeat do processo.
+    """
+    with open(HEARTBEAT_FILE, "w") as f:
+        f.write(str(time.time()))
+
+
+def monitor_loop(limite: float, intervalo: int, dry_run: bool) -> None:
+    """
+    Loop principal do monitor de risco.
+    """
+
+    log.info(
+        "[MONITOR] Iniciado | limite=%.2f intervalo=%ss dry_run=%s",
+        limite,
+        intervalo,
+        dry_run,
+    )
+
+    while True:
+
+        if os.path.exists(STOP_FILE):
+            log.info("[MONITOR] STOP_FILE detectado, encerrando")
+            os.remove(STOP_FILE)
+            break
+
+        write_heartbeat()
+
+        hoje = date.today()
+        estado = carregar_estado(STATUS_FILE)
+
+        if estado["data"] != hoje.isoformat():
+            log.info("[MONITOR] Novo dia detectado")
+            salvar_estado(STATUS_FILE, hoje, False)
+            estado["bloqueado"] = False
+
+        if not estado["bloqueado"] and risco_excedido(limite):
+
+            log.critical("[MONITOR] Limite de risco excedido")
+
+            resultado = panic_close_all(
+                retry_on_market_open=True,
+                dry_run=dry_run,
+            )
+
+            salvar_estado(STATUS_FILE, hoje, True)
+
+            log.critical("[MONITOR] PANIC CLOSE executado | resultado=%s", resultado)
+
+        time.sleep(intervalo)
+
+    log.info("[MONITOR] Finalizado")

mtcli_risco-2.5.1/mtcli_risco/services/run_monitor.py

@@ -0,0 +1,52 @@
+"""
+Runner do monitor de risco.
+
+- Cria PID_FILE
+- Executa monitor_loop
+- Garante limpeza do PID
+"""
+
+import sys
+import os
+
+from mtcli.logger import setup_logger
+from mtcli.conf import PID_FILE
+from .monitor_service import monitor_loop
+
+log = setup_logger("risco")
+
+
+def main() -> None:
+    """
+    Inicializa o processo do monitor.
+    """
+
+    limite = float(sys.argv[1])
+    intervalo = int(sys.argv[2])
+    dry_run = bool(int(sys.argv[3]))
+
+    pid = os.getpid()
+
+    with open(PID_FILE, "w") as f:
+        f.write(str(pid))
+
+    log.info(
+        "[RUNNER] Processo iniciado | pid=%s limite=%.2f intervalo=%ss dry_run=%s",
+        pid,
+        limite,
+        intervalo,
+        dry_run,
+    )
+
+    try:
+        monitor_loop(limite, intervalo, dry_run)
+
+    finally:
+        if os.path.exists(PID_FILE):
+            os.remove(PID_FILE)
+
+        log.info("[RUNNER] Processo finalizado | pid=%s", pid)
+
+
+if __name__ == "__main__":
+    main()

{mtcli_risco-2.4.2 → mtcli_risco-2.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-risco"
-version = "2.4.2"
+version = "2.5.1"
 description = "Plugin mtcli para controle de loss diário"
 authors = [
     {name = "Valmir França",email = "vfranca3@gmail.com"}
@@ -34,7 +34,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "mtcli>=3.7.0",
+    "mtcli>=3.7.2",
     "click (>=8.3.1,<9.0.0)",
     "metatrader5 (>=5.0.5572,<6.0.0)"
 ]

mtcli_risco-2.4.2/mtcli_risco/cli.py

@@ -1,27 +0,0 @@
-"""
-Comando principal e registro dos subcomandos
-"""
-
-import click
-from .commands.checar import checar_cmd
-from .commands.monitorar import monitorar_cmd
-from .commands.trades import trades_cmd
-from .commands.panic import panic_cmd
-
-
-@click.group()
-@click.version_option(package_name="mtcli-risco")
-def cli():
-    """
-    Plugin mtcli-risco.
-
-    Conjunto de comandos para gerenciamento e controle de risco diário
-    baseado em lucro/prejuízo no MetaTrader 5.
-    """
-    pass
-
-
-cli.add_command(checar_cmd, name="checar")
-cli.add_command(monitorar_cmd, name="monitorar")
-cli.add_command(trades_cmd, name="trades")
-cli.add_command(panic_cmd, name="panic")