mtcli-risco 2.2.2__tar.gz → 2.3.0__tar.gz

{mtcli_risco-2.2.2 → mtcli_risco-2.3.0}/PKG-INFO

@@ -1,17 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: mtcli-risco
-Version: 2.2.2
+Version: 2.3.0
 Summary: Plugin mtcli para controle de loss diário
-License: GPL-3.0
+License-Expression: GPL-3.0
+License-File: LICENSE
 Author: Valmir França da Silva
 Author-email: vfranca3@gmail.com
 Requires-Python: >=3.10,<3.14
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.3.1,<9.0.0)
+Requires-Dist: metatrader5 (>=5.0.5572,<6.0.0)
 Requires-Dist: mtcli (>=1.18.1)
 Project-URL: Documentation, https://mtcli-risco.readthedocs.io
 Project-URL: Homepage, https://github.com/vfranca/mtcli-risco

mtcli_risco-2.3.0/mtcli_risco/cli.py

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

{mtcli_risco-2.2.2 → mtcli_risco-2.3.0}/mtcli_risco/commands/checar.py

@@ -1,4 +1,9 @@
-"""Comando checar - verifica se o loss limit foi atingido."""
+"""
+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
@@ -13,59 +18,58 @@ from mtcli_risco.models.checar_model import (
     cancelar_todas_ordens,
 )
 
-
 log = setup_logger()
 
 
 @click.command(
     "checar",
-    help="Verifica se o limite diário de prejuízo foi atingido, com base nas regras configuradas.",
+    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), default -180.00.",
+    help="Limite de perda diária (ex: -500).",
 )
 @click.option(
     "--lucro",
     is_flag=True,
     default=False,
-    help="Exibe o lucro total do dia atualizado e sai.",
+    help="Exibe o lucro total do dia e encerra.",
 )
-def checar(limite, lucro):
-    """Verifica se o limite de prejuizo foi atingido."""
+def checar_cmd(limite: float, lucro: bool):
+    """
+    Executa uma verificação pontual do risco diário.
+    """
     if lucro:
-        lucro = calcular_lucro_total_dia()
-        click.echo(f"Lucro total do dia: {lucro:.2f}")
-        log.info(f"Lucro total do dia: {lucro:.2f}")
+        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
 
-    estado = carregar_estado(STATUS_FILE)
     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("Bloqueado hoje por risco. Nenhuma ordem deve ser enviada.")
+        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 novas ordens."
+            f"Limite {limite:.2f} excedido. Encerrando posições e bloqueando ordens."
         )
-        log.info(f"Risco {limite:.2f} excedido, iniciando encerramento de posições.")
+        log.warning(f"[RISCO] Limite {limite:.2f} excedido.")
         encerrar_todas_posicoes()
         cancelar_todas_ordens()
-        estado["bloqueado"] = True
+        salvar_estado(STATUS_FILE, hoje, True)
     else:
         click.echo("Dentro do limite de risco.")
-        log.info(f"Risco dentro do limite {limite:.2f}")
-
-    salvar_estado(STATUS_FILE, hoje, estado["bloqueado"])
-
-
-if __name__ == "__main__":
-    checar()
+        log.info(f"[RISCO] Dentro do limite {limite:.2f}.")

mtcli_risco-2.3.0/mtcli_risco/commands/monitorar.py

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

mtcli_risco-2.3.0/mtcli_risco/commands/panic.py

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

mtcli_risco-2.3.0/mtcli_risco/commands/trades.py

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

mtcli_risco-2.3.0/mtcli_risco/models/checar_model.py

@@ -0,0 +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

mtcli_risco-2.3.0/mtcli_risco/models/panic_model.py

@@ -0,0 +1,206 @@
+"""
+Modo PANIC CLOSE.
+
+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)
+"""
+
+import time
+import MetaTrader5 as mt5
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+
+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)
+
+    if not tick:
+        log.error(f"[PANIC] Tick indisponível para {symbol}")
+        return False
+
+    order_type = (
+        mt5.ORDER_TYPE_SELL
+        if position.type == mt5.ORDER_TYPE_BUY
+        else mt5.ORDER_TYPE_BUY
+    )
+
+    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": order_type,
+        "price": price,
+        "deviation": 20,
+        "magic": 999999,
+        "comment": "PANIC CLOSE",
+        "type_time": mt5.ORDER_TIME_GTC,
+        "type_filling": mt5.ORDER_FILLING_IOC,
+    }
+
+    # Conta hedge → precisa do ticket
+    if position.ticket:
+        request["position"] = position.ticket
+
+    if dry_run:
+        log.warning(f"[PANIC][DRY] Fechamento simulado: {request}")
+        return True
+
+    result = mt5.order_send(request)
+
+    if not result:
+        log.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 posição {symbol} | "
+            f"retcode={result.retcode}"
+        )
+        return False
+
+    log.critical(
+        f"[PANIC] Posição fechada | {symbol} vol={position.volume}"
+    )
+    return True
+
+
+def panic_close_all(
+    retry_on_market_open: bool = True,
+    retry_interval: int = 60,
+    dry_run: bool = False,
+) -> dict:
+    """
+    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,
+        "positions_closed": 0,
+        "orders_cancelled": 0,
+        "market_closed": False,
+        "trade_disabled": False,
+        "dry_run": dry_run,
+    }
+
+    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
+
+            positions = mt5.positions_get()
+            orders = mt5.orders_get()
+
+            if positions:
+                stats["positions_total"] = len(positions)
+
+            # 1️⃣ Fechamento de posições
+            if positions:
+                for pos in positions:
+                    if not _market_aberto(pos.symbol):
+                        market_fechado = True
+                        log.critical(
+                            f"[PANIC] Market fechado para {pos.symbol}"
+                        )
+                        continue
+
+                    if _close_position(pos, dry_run=dry_run):
+                        stats["positions_closed"] += 1
+
+            # 2️⃣ Cancelamento de ordens pendentes
+            if orders:
+                for ordem in orders:
+                    if dry_run:
+                        log.warning(
+                            f"[PANIC][DRY] Cancelamento simulado | "
+                            f"ticket={ordem.ticket}"
+                        )
+                        stats["orders_cancelled"] += 1
+                        continue
+
+                    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"retcode={result.retcode}"
+                        )
+
+        if not market_fechado:
+            break
+
+        stats["market_closed"] = True
+
+        if not retry_on_market_open:
+            break
+
+        log.critical(
+            f"[PANIC] Market fechado. Nova tentativa em {retry_interval}s..."
+        )
+        time.sleep(retry_interval)
+
+    log.critical(f"[PANIC] Resultado final: {stats}")
+    return stats

mtcli_risco-2.3.0/mtcli_risco/models/trades_model.py

@@ -0,0 +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

mtcli_risco-2.3.0/mtcli_risco/plugin.py

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

{mtcli_risco-2.2.2 → mtcli_risco-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-risco"
-version = "2.2.2"
+version = "2.3.0"
 description = "Plugin mtcli para controle de loss diário"
 authors = [
     {name = "Valmir França da Silva",email = "vfranca3@gmail.com"}
@@ -9,7 +9,9 @@ readme = "README.md"
 license = "GPL-3.0"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "mtcli>=1.18.1"
+    "mtcli>=1.18.1",
+    "click (>=8.3.1,<9.0.0)",
+    "metatrader5 (>=5.0.5572,<6.0.0)"
 ]
 
 [project.urls]
@@ -19,7 +21,7 @@ repository = "https://github.com/vfranca/mtcli-risco"
 issues = "https://github.com/vfranca/mtcli-risco/issues"
 
 [project.entry-points."mtcli.plugins"]
-mtcli_risco = "mtcli_risco.plugin:register"
+risco = "mtcli_risco.plugin:register"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

mtcli_risco-2.2.2/mtcli_risco/commands/__init__.py

@@ -1,2 +0,0 @@
-from .checar import checar
-from .monitorar import monitorar

mtcli_risco-2.2.2/mtcli_risco/commands/monitorar.py

@@ -1,59 +0,0 @@
-"""Comando monitorar - monitora o prejuízo do dia."""
-
-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,
-    encerrar_todas_posicoes,
-    cancelar_todas_ordens,
-)
-
-log = setup_logger()
-
-
-@click.command(
-    "monitorar", help="Inicia o monitoramento contínuo do risco diário em tempo real."
-)
-@click.version_option(package_name="mtcli-risco")
-@click.option("--limite", "-l", default=LOSS_LIMIT, help="Limite de perda diária.")
-@click.option(
-    "--intervalo",
-    "-i",
-    default=INTERVALO,
-    help="Intervalo entre verificações (segundos), default 60.",
-)
-def monitorar(limite, intervalo):
-    """Monitora continuamente o risco em tempo real."""
-    click.echo(f"Monitorando risco a cada {intervalo}s. Limite: {limite}")
-    try:
-        while True:
-            hoje = date.today()
-            estado = carregar_estado(STATUS_FILE)
-
-            if estado.get("data") != hoje.isoformat():
-                estado["bloqueado"] = False
-                salvar_estado(STATUS_FILE, hoje, False)
-
-            if not estado.get("bloqueado") and risco_excedido(limite):
-                click.echo(f"Limite {limite} excedido. Encerrando posições.")
-                log.info(f"Risco excedido em {limite}. Encerrando posições.")
-                encerrar_todas_posicoes()
-                cancelar_todas_ordens()
-                salvar_estado(STATUS_FILE, hoje, True)
-            elif estado.get("bloqueado"):
-                click.echo(f"O limite {limite} foi excedido. Sistema bloqueado hoje.")
-            else:
-                click.echo(f"Dentro do limite {limite}")
-
-            time.sleep(intervalo)
-    except KeyboardInterrupt:
-        click.echo("Monitoramento interrompido.")
-
-
-if __name__ == "__main__":
-    monitorar()

mtcli_risco-2.2.2/mtcli_risco/commands/trades.py

@@ -1,56 +0,0 @@
-"""Comando lucro - exibe os diferentes tipos de lucro."""
-
-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 atual."
-)
-@click.version_option(package_name="mtcli-risco")
-@click.option(
-    "--aberto", "-a", is_flag=True, default=False, help="Exibe o lucro aberto."
-)
-@click.option(
-    "--realizado",
-    "-r",
-    is_flag=True,
-    default=False,
-    help="Exibe o lucro realizado do dia.",
-)
-@click.option(
-    "--total", "-t", is_flag=True, default=False, help="Exibe o lucro total do dia."
-)
-def trades(aberto, realizado, total):
-    """Exibe os lucros aberto, realizado e total do dia."""
-    lucro_aberto = obter_lucro_aberto()
-    lucro_realizado = calcular_lucro_realizado()
-    lucro_total = calcular_lucro_total_dia()
-
-    if aberto:
-        click.echo(f"{lucro_aberto:.2f}")
-        return
-
-    if realizado:
-        click.echo(f"{lucro_realizado:.2f}")
-        return
-
-    if total:
-        click.echo(f"{lucro_total:.2f}")
-        return
-
-    click.echo(f"lucro em aberto {lucro_aberto:.2f}")
-    click.echo(f"lucro realizado {lucro_realizado:.2f}")
-    click.echo(f"lucro total {lucro_total:.2f}")
-
-
-if __name__ == "__main__":
-    trades()

mtcli_risco-2.2.2/mtcli_risco/models/checar_model.py

@@ -1,102 +0,0 @@
-"""Verifica dados de risco."""
-
-import MetaTrader5 as mt5
-import json
-import os
-from datetime import date, datetime, time
-from mtcli.logger import setup_logger
-from .trades_model import calcular_lucro_total_dia
-from mtcli_risco.mt5_context import mt5_conexao
-
-
-log = setup_logger()
-
-
-def carregar_estado(STATUS_FILE):
-    """Carrega o estado do controle de risco."""
-    if os.path.exists(STATUS_FILE):
-        with open(STATUS_FILE, "r") as f:
-            log.info(f"Carregando dados do arquivo {STATUS_FILE}")
-            return json.load(f)
-    return {"data": None, "bloqueado": False}
-
-
-def salvar_estado(STATUS_FILE, data, bloqueado):
-    """Salva o estado do controle de risco."""
-    with open(STATUS_FILE, "w") as f:
-        json.dump({"data": data.isoformat(), "bloqueado": bloqueado}, f)
-        log.info(f"Salvando o estado: data {data} bloqueado {bloqueado}")
-
-
-def encerrar_todas_posicoes():
-    """Encerra todas as posições abertas."""
-    with mt5_conexao():
-        positions = mt5.positions_get()
-    if not positions:
-        log.info("Nenhuma posição aberta para fechar.")
-        return
-
-    with mt5_conexao():
-        for pos in positions:
-            tipo_oposto = (
-                mt5.ORDER_TYPE_SELL
-                if pos.type == mt5.ORDER_TYPE_BUY
-                else mt5.ORDER_TYPE_BUY
-            )
-            ordem_fechar = {
-                "action": mt5.TRADE_ACTION_DEAL,
-                "symbol": pos.symbol,
-                "volume": pos.volume,
-                "type": tipo_oposto,
-                "position": pos.ticket,
-                "deviation": 10,
-                "magic": 1000,
-                "comment": "Fechando posição por limite de risco",
-            }
-            log.info(
-                f"Requizição para encerramento de posições pelo risco: {ordem_fechar}"
-            )
-            resultado = mt5.order_send(ordem_fechar)
-
-            if resultado is None:
-                log.error("Erro ao enviar ordem: resultado é None.")
-                continue
-
-            if resultado.retcode != mt5.TRADE_RETCODE_DONE:
-                log.error(f"Falha ao fechar posição {pos.ticket}: {resultado.retcode}")
-            else:
-                log.info(f"Posição {pos.ticket} fechada com sucesso.")
-
-
-def cancelar_todas_ordens():
-    """Cancela todas órdens pendentes."""
-    with mt5_conexao():
-        ordens = mt5.orders_get()
-    if not ordens:
-        log.info("Nenhuma ordem pendente para cancelar.")
-        return
-
-    with mt5_conexao():
-        for ordem in ordens:
-            resultado = mt5.order_delete(ordem.ticket)
-            if resultado.retcode != mt5.TRADE_RETCODE_DONE:
-                log.error(
-                    f"Falha ao cancelar ordem {ordem.ticket}: {resultado.retcode}"
-                )
-            else:
-                log.info(f"Ordem {ordem.ticket} cancelada com sucesso.")
-
-
-def risco_excedido(limite):
-    """Verifica se o loss limit do dia foi atingido."""
-    try:
-        total_lucro = calcular_lucro_total_dia()
-        if total_lucro <= limite:
-            log.info(
-                f"Limite de prejuízo excedido! prejuízo: {total_lucro:.2f}, limite: {limite:.2f}"
-            )
-            return True
-        return False
-    except Exception as e:
-        log.error(f"Erro ao verificar risco: {e}")
-        return False

mtcli_risco-2.2.2/mtcli_risco/models/trades_model.py

@@ -1,77 +0,0 @@
-"""Cálculos do lucro do dia."""
-
-import MetaTrader5 as mt5
-from datetime import date, datetime, time
-from mtcli.conecta import conectar, shutdown
-from mtcli.logger import setup_logger
-from mtcli_risco.mt5_context import mt5_conexao
-
-
-log = setup_logger()
-
-
-def contar_transacoes_realizadas() -> int:
-    """Conta a quantidade de posições encerradas no dia (transações de fechamento)."""
-    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 deals is None:
-        log.warning("Nenhum deal retornado.")
-        return 0
-
-    if not isinstance(deals, (list, tuple)):
-        deals = [deals]
-
-    # Types 1 = buy, 2 = sell → usados para fechar posições
-    transacoes = [d for d in deals if d.type in (1, 2)]
-
-    log.info(f"Transações realizadas hoje: {len(transacoes)}")
-    return len(transacoes)
-
-
-def calcular_lucro_realizado() -> float:
-    """Calcula o lucro realizado do dia."""
-    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)
-        log.info(f"Deals recebidos: {len(deals) if deals else 0}")
-
-    if deals is None or len(deals) == 0:
-        log.warning("Nenhum deal retornado.")
-        return 0.0
-
-    lucro_realizado = sum(
-        deal.profit for deal in deals if deal.entry == mt5.DEAL_ENTRY_OUT
-    )
-
-    log.info(f"Lucro realizado do dia: {lucro_realizado:.2f}")
-    return lucro_realizado
-
-
-def obter_lucro_aberto() -> float:
-    """Obtem o lucro em aberto."""
-    with mt5_conexao():
-        info = mt5.account_info()
-
-    lucro_aberto = info.profit if info else 0.0
-    log.info(f"lucro aberto: {lucro_aberto:.2f}")
-
-    return lucro_aberto
-
-
-def calcular_lucro_total_dia() -> float:
-    """Calcula o lucro total do dia."""
-    realizado = calcular_lucro_realizado()
-    aberto = obter_lucro_aberto()
-    total = realizado + aberto
-    log.info(
-        f"Lucro realizado: {realizado:.2f}, lucro aberto: {aberto:.2f}, total: {total:.2f}"
-    )
-    return total

mtcli_risco-2.2.2/mtcli_risco/mt5_context.py

@@ -1,11 +0,0 @@
-from contextlib import contextmanager
-from mtcli.conecta import conectar, shutdown
-
-
-@contextmanager
-def mt5_conexao():
-    conectar()
-    try:
-        yield
-    finally:
-        shutdown()

mtcli_risco-2.2.2/mtcli_risco/plugin.py

@@ -1,11 +0,0 @@
-"""Registra os comandos do plugin."""
-
-from .commands.checar import checar
-from .commands.monitorar import monitorar
-from .commands.trades import trades
-
-
-def register(cli):
-    cli.add_command(checar, name="checar")
-    cli.add_command(monitorar, name="monitorar")
-    cli.add_command(trades, name="trades")