mtcli-risco 2.3.0.dev1__tar.gz → 2.4.0__tar.gz

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli-risco
-Version: 2.3.0.dev1
+Version: 2.4.0
 Summary: Plugin mtcli para controle de loss diário
 License-Expression: GPL-3.0
 License-File: LICENSE

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/cli.py

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

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/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()
+
+
+@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}.")

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/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 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.")

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/commands/panic.py

@@ -1,36 +1,36 @@
-"""
-Comando panic.
-
-Executa o PANIC CLOSE manualmente.
-"""
-
-import click
-from mtcli.logger import setup_logger
-from mtcli_risco.models.panic_model import panic_close_all
-
-log = setup_logger()
-
-
-@click.command()
-@click.option("--dry-run", is_flag=True, help="Simula o panic close.")
-@click.option(
-    "--no-retry",
-    is_flag=True,
-    help="Não repetir quando o market estiver fechado.",
-)
-def panic_cmd(dry_run: bool, no_retry: bool):
-    """
-    Executa manualmente o fechamento emergencial de posições.
-    """
-    click.echo("Executando PANIC CLOSE...")
-    log.critical(
-        f"[PANIC] Execução manual | dry_run={dry_run} retry={not no_retry}"
-    )
-
-    resultado = panic_close_all(
-        retry_on_market_open=not no_retry,
-        dry_run=dry_run,
-    )
-
-    click.echo("PANIC CLOSE finalizado.")
-    log.critical(f"[PANIC] Resultado: {resultado}")
+"""
+Comando panic.
+
+Executa o PANIC CLOSE manualmente.
+"""
+
+import click
+from mtcli.logger import setup_logger
+from mtcli_risco.models.panic_model import panic_close_all
+
+log = setup_logger()
+
+
+@click.command()
+@click.option("--dry-run", is_flag=True, help="Simula o panic close.")
+@click.option(
+    "--no-retry",
+    is_flag=True,
+    help="Não repetir quando o market estiver fechado.",
+)
+def panic_cmd(dry_run: bool, no_retry: bool):
+    """
+    Executa manualmente o fechamento emergencial de posições.
+    """
+    click.echo("Executando PANIC CLOSE...")
+    log.critical(
+        f"[PANIC] Execução manual | dry_run={dry_run} retry={not no_retry}"
+    )
+
+    resultado = panic_close_all(
+        retry_on_market_open=not no_retry,
+        dry_run=dry_run,
+    )
+
+    click.echo("PANIC CLOSE finalizado.")
+    log.critical(f"[PANIC] Resultado: {resultado}")

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/commands/trades.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 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}")

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/models/checar_model.py

@@ -1,117 +1,117 @@
-"""
-Model de controle de risco.
-
-Responsável por:
-- persistência de estado diário
-- verificação de limite de prejuízo
-- encerramento de posições
-- cancelamento de ordens
-"""
-
-import json
-import os
-from datetime import date
-import MetaTrader5 as mt5
-from mtcli.logger import setup_logger
-from mtcli.mt5_context import mt5_conexao
-from .trades_model import calcular_lucro_total_dia
-
-log = setup_logger()
-
-
-def carregar_estado(status_file: str) -> dict:
-    """
-    Carrega o estado persistido do controle de risco.
-    """
-    if os.path.exists(status_file):
-        with open(status_file, "r") as f:
-            log.info(f"[ESTADO] Carregando {status_file}")
-            return json.load(f)
-    return {"data": "", "bloqueado": False}
-
-
-def salvar_estado(status_file: str, data: date, bloqueado: bool) -> None:
-    """
-    Persiste o estado diário do controle de risco.
-    """
-    with open(status_file, "w") as f:
-        json.dump(
-            {"data": data.isoformat(), "bloqueado": bloqueado},
-            f,
-            indent=2,
-        )
-    log.info(f"[ESTADO] Salvo | data={data.isoformat()} bloqueado={bloqueado}")
-
-
-def encerrar_todas_posicoes() -> None:
-    """
-    Encerra todas as posições abertas no MT5.
-    """
-    with mt5_conexao():
-        positions = mt5.positions_get()
-
-        if not positions:
-            log.info("[MT5] Nenhuma posição aberta.")
-            return
-
-        for pos in positions:
-            tipo_oposto = (
-                mt5.ORDER_TYPE_SELL
-                if pos.type == mt5.ORDER_TYPE_BUY
-                else mt5.ORDER_TYPE_BUY
-            )
-
-            ordem = {
-                "action": mt5.TRADE_ACTION_DEAL,
-                "symbol": pos.symbol,
-                "volume": pos.volume,
-                "type": tipo_oposto,
-                "position": pos.ticket,
-                "deviation": 10,
-                "magic": 1000,
-                "comment": "Fechamento por limite de risco",
-            }
-
-            log.warning(f"[MT5] Encerrando posição {pos.ticket}")
-            resultado = mt5.order_send(ordem)
-
-            if not resultado or resultado.retcode != mt5.TRADE_RETCODE_DONE:
-                log.error(f"[MT5] Falha ao fechar {pos.ticket}: {resultado}")
-            else:
-                log.info(f"[MT5] Posição {pos.ticket} encerrada.")
-
-
-def cancelar_todas_ordens() -> None:
-    """
-    Cancela todas as ordens pendentes.
-    """
-    with mt5_conexao():
-        ordens = mt5.orders_get()
-
-        if not ordens:
-            log.info("[MT5] Nenhuma ordem pendente.")
-            return
-
-        for ordem in ordens:
-            resultado = mt5.order_delete(ordem.ticket)
-            if not resultado or resultado.retcode != mt5.TRADE_RETCODE_DONE:
-                log.error(f"[MT5] Falha ao cancelar ordem {ordem.ticket}")
-            else:
-                log.info(f"[MT5] Ordem {ordem.ticket} cancelada.")
-
-
-def risco_excedido(limite: float) -> bool:
-    """
-    Verifica se o prejuízo diário ultrapassou o limite configurado.
-    """
-    try:
-        total = calcular_lucro_total_dia()
-        if total <= limite:
-            log.warning(
-                f"[RISCO] Excedido | resultado={total:.2f} limite={limite:.2f}"
-            )
-            return True
-        return False
-    except Exception as exc:
-        log.error(f"[RISCO] Erro ao verificar limite: {exc}")
-        return False
+"""
+Model de controle de risco.
+
+Responsável por:
+- persistência de estado diário
+- verificação de limite de prejuízo
+- encerramento de posições
+- cancelamento de ordens
+"""
+
+import json
+import os
+from datetime import date
+import MetaTrader5 as mt5
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+from .trades_model import calcular_lucro_total_dia
+
+log = setup_logger()
+
+
+def carregar_estado(status_file: str) -> dict:
+    """
+    Carrega o estado persistido do controle de risco.
+    """
+    if os.path.exists(status_file):
+        with open(status_file, "r") as f:
+            log.info(f"[ESTADO] Carregando {status_file}")
+            return json.load(f)
+    return {"data": "", "bloqueado": False}
+
+
+def salvar_estado(status_file: str, data: date, bloqueado: bool) -> None:
+    """
+    Persiste o estado diário do controle de risco.
+    """
+    with open(status_file, "w") as f:
+        json.dump(
+            {"data": data.isoformat(), "bloqueado": bloqueado},
+            f,
+            indent=2,
+        )
+    log.info(f"[ESTADO] Salvo | data={data.isoformat()} bloqueado={bloqueado}")
+
+
+def encerrar_todas_posicoes() -> None:
+    """
+    Encerra todas as posições abertas no MT5.
+    """
+    with mt5_conexao():
+        positions = mt5.positions_get()
+
+        if not positions:
+            log.info("[MT5] Nenhuma posição aberta.")
+            return
+
+        for pos in positions:
+            tipo_oposto = (
+                mt5.ORDER_TYPE_SELL
+                if pos.type == mt5.ORDER_TYPE_BUY
+                else mt5.ORDER_TYPE_BUY
+            )
+
+            ordem = {
+                "action": mt5.TRADE_ACTION_DEAL,
+                "symbol": pos.symbol,
+                "volume": pos.volume,
+                "type": tipo_oposto,
+                "position": pos.ticket,
+                "deviation": 10,
+                "magic": 1000,
+                "comment": "Fechamento por limite de risco",
+            }
+
+            log.warning(f"[MT5] Encerrando posição {pos.ticket}")
+            resultado = mt5.order_send(ordem)
+
+            if not resultado or resultado.retcode != mt5.TRADE_RETCODE_DONE:
+                log.error(f"[MT5] Falha ao fechar {pos.ticket}: {resultado}")
+            else:
+                log.info(f"[MT5] Posição {pos.ticket} encerrada.")
+
+
+def cancelar_todas_ordens() -> None:
+    """
+    Cancela todas as ordens pendentes.
+    """
+    with mt5_conexao():
+        ordens = mt5.orders_get()
+
+        if not ordens:
+            log.info("[MT5] Nenhuma ordem pendente.")
+            return
+
+        for ordem in ordens:
+            resultado = mt5.order_delete(ordem.ticket)
+            if not resultado or resultado.retcode != mt5.TRADE_RETCODE_DONE:
+                log.error(f"[MT5] Falha ao cancelar ordem {ordem.ticket}")
+            else:
+                log.info(f"[MT5] Ordem {ordem.ticket} cancelada.")
+
+
+def risco_excedido(limite: float) -> bool:
+    """
+    Verifica se o prejuízo diário ultrapassou o limite configurado.
+    """
+    try:
+        total = calcular_lucro_total_dia()
+        if total <= limite:
+            log.warning(
+                f"[RISCO] Excedido | resultado={total:.2f} limite={limite:.2f}"
+            )
+            return True
+        return False
+    except Exception as exc:
+        log.error(f"[RISCO] Erro ao verificar limite: {exc}")
+        return False

mtcli_risco-2.4.0/mtcli_risco/models/hardstop_model.py

@@ -0,0 +1,117 @@
+"""
+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
+import signal
+from mtcli.logger import setup_logger
+
+log = setup_logger()
+
+MT5_PROCESS_NAME = "terminal64.exe"
+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.
+    """
+    log.critical("[HARDSTOP] Encerrando processo do MT5")
+
+    _run(
+        [
+            "taskkill",
+            "/F",   # força
+            "/IM",
+            MT5_PROCESS_NAME,
+        ]
+    )
+
+
+def block_mt5_firewall() -> None:
+    """
+    Bloqueia qualquer tráfego de rede do MT5 via Firewall do Windows.
+    """
+    log.critical("[HARDSTOP] Bloqueando tráfego de rede do MT5 (Firewall)")
+
+    # Remove regra anterior se existir (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=%ProgramFiles%\\MetaTrader 5\\terminal64.exe",
+            "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.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/models/panic_model.py

@@ -1,31 +1,44 @@
 """
 Modo PANIC CLOSE.
 
-- Funciona em conta hedge e netting
-- Detecta market fechado
-- Reexecuta automaticamente quando o market abrir
-- Suporta modo DRY-RUN (simulação)
+Responsável por:
+- Encerrar TODAS as posições abertas (hedge ou netting)
+- Cancelar TODAS as ordens pendentes
+- Funcionar com market aberto ou fechado (retry automático)
+- Suportar modo DRY-RUN (simulação)
+- Acionar HARDSTOP via Sistema Operacional (Windows)
 """
 
 import time
 import MetaTrader5 as mt5
+
 from mtcli.logger import setup_logger
 from mtcli.mt5_context import mt5_conexao
+from mtcli_risco.models.hardstop_model import hardstop
 
 log = setup_logger()
 
 
 def _trade_permitido() -> bool:
+    """
+    Verifica se a conta permite trading.
+    """
     info = mt5.account_info()
     return bool(info and info.trade_allowed)
 
 
 def _market_aberto(symbol: str) -> bool:
+    """
+    Verifica se o mercado do símbolo está aberto para trading.
+    """
     info = mt5.symbol_info(symbol)
     return bool(info and info.trade_mode == mt5.SYMBOL_TRADE_MODE_FULL)
 
 
 def _close_position(position, dry_run: bool = False) -> bool:
+    """
+    Fecha uma posição individual (compatível com hedge e netting).
+    """
     symbol = position.symbol
     tick = mt5.symbol_info_tick(symbol)
 
@@ -33,19 +46,19 @@ def _close_position(position, dry_run: bool = False) -> bool:
         log.error(f"[PANIC] Tick indisponível para {symbol}")
         return False
 
-    tipo = (
+    order_type = (
         mt5.ORDER_TYPE_SELL
         if position.type == mt5.ORDER_TYPE_BUY
         else mt5.ORDER_TYPE_BUY
     )
 
-    price = tick.bid if tipo == mt5.ORDER_TYPE_SELL else tick.ask
+    price = tick.bid if order_type == mt5.ORDER_TYPE_SELL else tick.ask
 
     request = {
         "action": mt5.TRADE_ACTION_DEAL,
         "symbol": symbol,
         "volume": position.volume,
-        "type": tipo,
+        "type": order_type,
         "price": price,
         "deviation": 20,
         "magic": 999999,
@@ -54,6 +67,7 @@ def _close_position(position, dry_run: bool = False) -> bool:
         "type_filling": mt5.ORDER_FILLING_IOC,
     }
 
+    # Conta hedge → fechamento por ticket
     if position.ticket:
         request["position"] = position.ticket
 
@@ -65,13 +79,15 @@ def _close_position(position, dry_run: bool = False) -> bool:
 
     if not result:
         log.error(
-            f"[PANIC] order_send None | {symbol} | last_error={mt5.last_error()}"
+            f"[PANIC] order_send retornou None | "
+            f"{symbol} | last_error={mt5.last_error()}"
         )
         return False
 
     if result.retcode != mt5.TRADE_RETCODE_DONE:
         log.error(
-            f"[PANIC] Falha ao fechar {symbol} | retcode={result.retcode}"
+            f"[PANIC] Falha ao fechar posição {symbol} | "
+            f"retcode={result.retcode}"
         )
         return False
 
@@ -87,13 +103,21 @@ def panic_close_all(
     dry_run: bool = False,
 ) -> dict:
     """
-    Executa o fechamento emergencial de posições e ordens.
-
-    retry_on_market_open:
-        Reexecuta automaticamente quando o market abrir.
-
-    dry_run:
-        Simula ações sem enviar ordens.
+    Executa o fechamento emergencial de TODAS as posições e ordens.
+
+    Parâmetros
+    ----------
+    retry_on_market_open : bool
+        Reexecuta automaticamente quando o market estiver fechado.
+    retry_interval : int
+        Intervalo (segundos) entre tentativas quando market fechado.
+    dry_run : bool
+        Simula as ações sem enviar ordens reais.
+
+    Retorna
+    -------
+    dict
+        Estatísticas da execução do panic close.
     """
     stats = {
         "positions_total": 0,
@@ -102,14 +126,17 @@ def panic_close_all(
         "market_closed": False,
         "trade_disabled": False,
         "dry_run": dry_run,
+        "hardstop_executed": False,
     }
 
     while True:
+        market_fechado = False
+
         with mt5_conexao():
             if not _trade_permitido():
                 log.critical("[PANIC] Trading desabilitado na conta!")
                 stats["trade_disabled"] = True
-                return stats
+                break
 
             positions = mt5.positions_get()
             orders = mt5.orders_get()
@@ -117,9 +144,7 @@ def panic_close_all(
             if positions:
                 stats["positions_total"] = len(positions)
 
-            market_fechado = False
-
-            # 1️⃣ Fechar posições
+            # 1️⃣ Fechamento de posições
             if positions:
                 for pos in positions:
                     if not _market_aberto(pos.symbol):
@@ -132,25 +157,40 @@ def panic_close_all(
                     if _close_position(pos, dry_run=dry_run):
                         stats["positions_closed"] += 1
 
-            # 2️⃣ Cancelar ordens pendentes
+            # 2️⃣ Cancelamento de ordens pendentes
             if orders:
                 for ordem in orders:
                     if dry_run:
                         log.warning(
-                            f"[PANIC][DRY] Cancelamento simulado | ticket={ordem.ticket}"
+                            f"[PANIC][DRY] Cancelamento simulado | "
+                            f"ticket={ordem.ticket}"
                         )
                         stats["orders_cancelled"] += 1
                         continue
 
-                    result = mt5.order_delete(ordem.ticket)
-                    if result and result.retcode == mt5.TRADE_RETCODE_DONE:
+                    request = {
+                        "action": mt5.TRADE_ACTION_REMOVE,
+                        "order": ordem.ticket,
+                    }
+
+                    result = mt5.order_send(request)
+
+                    if not result:
+                        log.error(
+                            f"[PANIC] Falha ao cancelar ordem {ordem.ticket} | "
+                            f"last_error={mt5.last_error()}"
+                        )
+                        continue
+
+                    if result.retcode == mt5.TRADE_RETCODE_DONE:
                         stats["orders_cancelled"] += 1
                         log.warning(
                             f"[PANIC] Ordem cancelada | ticket={ordem.ticket}"
                         )
                     else:
                         log.error(
-                            f"[PANIC] Falha ao cancelar ordem {ordem.ticket}"
+                            f"[PANIC] Falha ao cancelar ordem {ordem.ticket} | "
+                            f"retcode={result.retcode}"
                         )
 
         if not market_fechado:
@@ -162,9 +202,16 @@ def panic_close_all(
             break
 
         log.critical(
-            f"[PANIC] Market fechado. Repetindo em {retry_interval}s..."
+            f"[PANIC] Market fechado. Nova tentativa em {retry_interval}s..."
         )
         time.sleep(retry_interval)
 
+    # 3️⃣ HARDSTOP via Sistema Operacional
+    if not dry_run:
+        hardstop()
+        stats["hardstop_executed"] = True
+    else:
+        log.warning("[PANIC][DRY] HARDSTOP não executado (modo simulação)")
+
     log.critical(f"[PANIC] Resultado final: {stats}")
     return stats

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/models/trades_model.py

@@ -1,62 +1,62 @@
-"""
-Model de cálculos de lucro diário.
-"""
-
-import MetaTrader5 as mt5
-from datetime import datetime, time
-from mtcli.logger import setup_logger
-from mtcli.mt5_context import mt5_conexao
-
-log = setup_logger()
-
-
-def calcular_lucro_realizado() -> float:
-    """
-    Calcula o lucro/prejuízo realizado no dia atual.
-    """
-    hoje = datetime.now().date()
-    inicio = datetime.combine(hoje, time(0, 0))
-    fim = datetime.combine(hoje, time(23, 59))
-
-    with mt5_conexao():
-        deals = mt5.history_deals_get(inicio, fim)
-
-    if not deals:
-        log.info("[TRADES] Nenhum deal realizado hoje.")
-        return 0.0
-
-    lucro = sum(
-        deal.profit for deal in deals if deal.entry == mt5.DEAL_ENTRY_OUT
-    )
-
-    log.info(f"[TRADES] Lucro realizado: {lucro:.2f}")
-    return lucro
-
-
-def obter_lucro_aberto() -> float:
-    """
-    Obtém o lucro/prejuízo das posições atualmente abertas.
-    """
-    with mt5_conexao():
-        info = mt5.account_info()
-
-    if not info:
-        log.warning("[TRADES] account_info indisponível.")
-        return 0.0
-
-    log.info(f"[TRADES] Lucro em aberto: {info.profit:.2f}")
-    return info.profit
-
-
-def calcular_lucro_total_dia() -> float:
-    """
-    Calcula o lucro total do dia (realizado + aberto).
-    """
-    realizado = calcular_lucro_realizado()
-    aberto = obter_lucro_aberto()
-    total = realizado + aberto
-
-    log.info(
-        f"[TRADES] Total do dia | realizado={realizado:.2f} aberto={aberto:.2f}"
-    )
-    return total
+"""
+Model de cálculos de lucro diário.
+"""
+
+import MetaTrader5 as mt5
+from datetime import datetime, time
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+
+log = setup_logger()
+
+
+def calcular_lucro_realizado() -> float:
+    """
+    Calcula o lucro/prejuízo realizado no dia atual.
+    """
+    hoje = datetime.now().date()
+    inicio = datetime.combine(hoje, time(0, 0))
+    fim = datetime.combine(hoje, time(23, 59))
+
+    with mt5_conexao():
+        deals = mt5.history_deals_get(inicio, fim)
+
+    if not deals:
+        log.info("[TRADES] Nenhum deal realizado hoje.")
+        return 0.0
+
+    lucro = sum(
+        deal.profit for deal in deals if deal.entry == mt5.DEAL_ENTRY_OUT
+    )
+
+    log.info(f"[TRADES] Lucro realizado: {lucro:.2f}")
+    return lucro
+
+
+def obter_lucro_aberto() -> float:
+    """
+    Obtém o lucro/prejuízo das posições atualmente abertas.
+    """
+    with mt5_conexao():
+        info = mt5.account_info()
+
+    if not info:
+        log.warning("[TRADES] account_info indisponível.")
+        return 0.0
+
+    log.info(f"[TRADES] Lucro em aberto: {info.profit:.2f}")
+    return info.profit
+
+
+def calcular_lucro_total_dia() -> float:
+    """
+    Calcula o lucro total do dia (realizado + aberto).
+    """
+    realizado = calcular_lucro_realizado()
+    aberto = obter_lucro_aberto()
+    total = realizado + aberto
+
+    log.info(
+        f"[TRADES] Total do dia | realizado={realizado:.2f} aberto={aberto:.2f}"
+    )
+    return total

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/mtcli_risco/plugin.py

@@ -1,12 +1,12 @@
-"""
-Registro do plugin mtcli-risco no mtcli principal.
-"""
-
-from .cli import cli as risco
-
-
-def register(main_cli):
-    """
-    Registra o grupo de comandos 'risco' no mtcli principal.
-    """
-    main_cli.add_command(risco, name="risco")
+"""
+Registro do plugin mtcli-risco no mtcli principal.
+"""
+
+from .cli import cli as risco
+
+
+def register(main_cli):
+    """
+    Registra o grupo de comandos 'risco' no mtcli principal.
+    """
+    main_cli.add_command(risco, name="risco")

{mtcli_risco-2.3.0.dev1 → mtcli_risco-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-risco"
-version = "2.3.0.dev1"
+version = "2.4.0"
 description = "Plugin mtcli para controle de loss diário"
 authors = [
     {name = "Valmir França da Silva",email = "vfranca3@gmail.com"}