mtcli-trade 1.6.2__tar.gz → 2.0.0.dev0__tar.gz

{mtcli_trade-1.6.2 → mtcli_trade-2.0.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mtcli-trade
-Version: 1.6.2
+Version: 2.0.0.dev0
 Summary: Plugin mtcli para gerenciamento de órdens
 License: GPL-3.0
 Author: Valmir França da Silva
@@ -12,7 +12,7 @@ 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: mtcli (>=1.18.1)
+Requires-Dist: mtcli (>=3.2.0)
 Requires-Dist: mtcli-risco (>=2.2.0,<3.0.0)
 Project-URL: Documentation, https://mtcli-trade.readthedocs.io
 Project-URL: Homepage, https://github.com/vfranca/mtcli-trade

mtcli_trade-2.0.0.dev0/mtcli_trade/commands/compra_cli.py

@@ -0,0 +1,29 @@
+import click
+
+from mtcli_trade.conf import LOT, SL, SYMBOL, TP
+from mtcli_trade.controllers.compra_controller import executar_compra
+from mtcli_trade.views.ordem_view import exibir_resultado_ordem
+
+
+@click.command(
+    "compra", help="Envia ordem de compra (market ou limit) com SL e TP opcionais."
+)
+@click.version_option(package_name="mtcli-trade")
+@click.option(
+    "--symbol", "-s", default=SYMBOL, help="Símbolo do ativo (default WINV25)."
+)
+@click.option(
+    "--lot", type=float, default=LOT, help="Quantidade de contratos (default=1.0)"
+)
+@click.option("--sl", type=float, default=SL, help="Stop loss (em pontos).")
+@click.option("--tp", type=float, default=TP, help="Take profit (em pontos).")
+@click.option("--limit", "-l", is_flag=True, help="Envia ordem pendente (buy limit).")
+@click.option("--preco", "-pr", type=float, default=None, help="Preço da ordem limit.")
+def compra_cmd(symbol, lot, sl, tp, limit, preco):
+    """Executa o fluxo completo de compra."""
+    resultado = executar_compra(symbol, lot, sl, tp, limit, preco)
+    exibir_resultado_ordem(resultado)
+
+
+if __name__ == "__main__":
+    compra_cmd()

mtcli_trade-2.0.0.dev0/mtcli_trade/commands/ordens_cli.py

@@ -0,0 +1,27 @@
+import click
+
+from mtcli_trade.controllers.ordens_controller import (
+    cancelar_ordens_pendentes,
+    obter_ordens_pendentes,
+)
+from mtcli_trade.views.ordens_view import exibir_cancelar_ordens, exibir_ordens
+
+
+@click.command("orders", help="Lista ou cancela ordens pendentes no MetaTrader 5.")
+@click.version_option(package_name="mtcli-trade")
+@click.option("--symbol", "-s", default=None, help="Símbolo do ativo para filtrar.")
+@click.option(
+    "--cancelar", "-c", is_flag=True, help="Cancela todas as ordens pendentes."
+)
+def ordens_cmd(symbol, cancelar):
+    if cancelar:
+        resultados = cancelar_ordens_pendentes(symbol)
+        exibir_cancelar_ordens(resultados, symbol)
+        return
+
+    ordens = obter_ordens_pendentes(symbol)
+    exibir_ordens(ordens)
+
+
+if __name__ == "__main__":
+    ordens_cmd()

mtcli_trade-2.0.0.dev0/mtcli_trade/commands/posicoes_cli.py

@@ -0,0 +1,39 @@
+import click
+
+from mtcli_trade.controllers.posicoes_controller import (
+    encerrar_posicoes,
+    obter_posicoes,
+)
+from mtcli_trade.views.posicoes_view import (
+    exibir_posicoes,
+    exibir_resultados_encerramento,
+)
+
+
+@click.command(
+    "positions",
+    help="Lista ou encerra as posições abertas, mostrando lucro/prejuízo atual e detalhes por ativo.",
+)
+@click.version_option(package_name="mtcli-trade")
+@click.option("--symbol", "-s", default=None, help="Símbolo do ativo (opcional)")
+@click.option(
+    "--zerar",
+    "-z",
+    is_flag=True,
+    default=False,
+    help="Encerra todas as posições ou de um ativo específico.",
+)
+def posicoes_cmd(symbol, zerar):
+    """Lista ou zera todas as posições abertas (ou de um ativo)."""
+    posicoes = obter_posicoes(symbol)
+
+    if zerar:
+        resultados = encerrar_posicoes(symbol)
+        exibir_resultados_encerramento(resultados)
+        return
+
+    exibir_posicoes(posicoes, symbol)
+
+
+if __name__ == "__main__":
+    posicoes_cmd()

mtcli_trade-2.0.0.dev0/mtcli_trade/commands/venda_cli.py

@@ -0,0 +1,29 @@
+import click
+
+from mtcli_trade.conf import LOT, SL, SYMBOL, TP
+from mtcli_trade.controllers.venda_controller import executar_venda
+from mtcli_trade.views.ordem_view import exibir_resultado_ordem
+
+
+@click.command(
+    "venda", help="Envia ordem de compra (market ou limit) com SL e TP opcionais."
+)
+@click.version_option(package_name="mtcli-trade")
+@click.option(
+    "--symbol", "-s", default=SYMBOL, help="Símbolo do ativo (default WINV25)."
+)
+@click.option(
+    "--lot", type=float, default=LOT, help="Quantidade de contratos (default=1.0)"
+)
+@click.option("--sl", type=float, default=SL, help="Stop loss (em pontos).")
+@click.option("--tp", type=float, default=TP, help="Take profit (em pontos).")
+@click.option("--limit", "-l", is_flag=True, help="Envia ordem pendente (buy limit).")
+@click.option("--preco", "-pr", type=float, default=None, help="Preço da ordem limit.")
+def venda_cmd(symbol, lot, sl, tp, limit, preco):
+    """Executa o fluxo completo de compra."""
+    resultado = executar_venda(symbol, lot, sl, tp, limit, preco)
+    exibir_resultado_ordem(resultado)
+
+
+if __name__ == "__main__":
+    venda_cmd()

mtcli_trade-2.0.0.dev0/mtcli_trade/controllers/compra_controller.py

@@ -0,0 +1,68 @@
+"""
+Camada Controller: coordena a execução de ordens de compra.
+"""
+
+from mtcli.logger import setup_logger
+from mtcli_trade.models.compra_model import (
+    enviar_ordem_compra,
+    preparar_ordem_compra,
+    verificar_risco,
+)
+
+log = setup_logger()
+
+
+def executar_compra(
+    symbol: str,
+    lot: float,
+    sl: float,
+    tp: float,
+    limit: bool,
+    preco: float | None = None,
+) -> dict:
+    """
+    Controla o fluxo completo da execução de compra:
+    - verifica risco,
+    - prepara a ordem,
+    - envia ao MetaTrader 5,
+    - retorna o resultado estruturado.
+    """
+
+    if verificar_risco():
+        log.info("Envio de ordem bloqueado por risco diário.")
+        return {"status": "bloqueado", "mensagem": "Limite de prejuízo atingido."}
+
+    try:
+        ordem, is_limit = preparar_ordem_compra(symbol, lot, sl, tp, limit, preco)
+        if ordem is None:
+            return {
+                "status": "falha",
+                "mensagem": "Falha ao preparar ordem.",
+                "resultado": {
+                    "tipo": "LIMIT" if limit else "MARKET",
+                    "preco": preco,
+                    "retcode": None,
+                    "mensagem": "Tick inválido ou símbolo não encontrado.",
+                },
+            }
+
+        resultado = enviar_ordem_compra(ordem, is_limit)
+
+        # MetaTrader 5 retorna 10009 = TRADE_RETCODE_DONE (sucesso)
+        if resultado.get("retcode") not in (10009,):
+            log.warning(f"Ordem recusada pelo MT5: {resultado}")
+            return {
+                "status": "falha",
+                "mensagem": "MetaTrader 5 recusou a ordem.",
+                "resultado": resultado,
+            }
+
+        log.info(f"✅ Ordem de compra enviada com sucesso para {symbol}.")
+        return {"status": "ok", "resultado": resultado}
+
+    except ValueError as e:
+        log.error(f"Erro de validação: {e}")
+        return {"status": "erro", "mensagem": str(e)}
+    except Exception as e:
+        log.exception(f"Erro inesperado ao executar compra: {e}")
+        return {"status": "erro", "mensagem": str(e)}

mtcli_trade-1.6.2/mtcli_trade/controllers/orders_controller.py → mtcli_trade-2.0.0.dev0/mtcli_trade/controllers/ordens_controller.py

@@ -1,10 +1,17 @@
-from mtcli_trade.models.orders_model import buscar_ordens, formatar_ordem
+from collections.abc import Sequence
+
 from mtcli.logger import setup_logger
+from mtcli_trade.models.ordens_model import (
+    buscar_ordens,
+    cancelar_ordens,
+    formatar_ordem,
+)
 
 log = setup_logger()
 
 
-def obter_ordens_pendentes(symbol=None):
+def obter_ordens_pendentes(symbol: str | None = None) -> Sequence:
+    """Retorna lista de ordens pendentes formatadas (pode ser vazia)."""
     ordens_raw = buscar_ordens(symbol)
 
     if not ordens_raw:
@@ -23,3 +30,13 @@ def obter_ordens_pendentes(symbol=None):
         )
         ordens.append(dados)
     return ordens
+
+
+def cancelar_ordens_pendentes(symbol: str | None = None):
+    """Cancela ordens pendentes via model e retorna resultados."""
+    try:
+        resultados = cancelar_ordens(symbol)
+    except Exception as e:
+        log.error(f"Erro ao cancelar ordens: {e}")
+        raise
+    return resultados

mtcli_trade-2.0.0.dev0/mtcli_trade/controllers/posicoes_controller.py

@@ -0,0 +1,30 @@
+from collections.abc import Sequence
+
+from mtcli.logger import setup_logger
+from mtcli_trade.models.posicoes_model import buscar_posicoes, encerra_posicoes
+
+log = setup_logger()
+
+
+def obter_posicoes(symbol: str | None = None) -> Sequence:
+    """Retorna uma sequência (possivelmente vazia) de posições abertas para o symbol ou todas."""
+    try:
+        posicoes = buscar_posicoes(symbol)
+    except Exception as e:
+        log.error(f"Erro ao buscar posições: {e}")
+        raise
+
+    # normalize: sempre devolve lista/sequence (não None)
+    if not posicoes:
+        return []
+    return posicoes
+
+
+def encerrar_posicoes(symbol: str | None = None):
+    """Encerrar posições (retorna a lista de resultados produzida pelo model)."""
+    try:
+        resultados = encerra_posicoes(symbol)
+    except Exception as e:
+        log.error(f"Erro ao encerrar posições: {e}")
+        raise
+    return resultados

mtcli_trade-2.0.0.dev0/mtcli_trade/controllers/venda_controller.py

@@ -0,0 +1,68 @@
+"""
+Camada Controller: coordena a execução de ordens de venda.
+"""
+
+from mtcli.logger import setup_logger
+from mtcli_trade.models.venda_model import (
+    enviar_ordem_venda,
+    preparar_ordem_venda,
+    verificar_risco,
+)
+
+log = setup_logger()
+
+
+def executar_venda(
+    symbol: str,
+    lot: float,
+    sl: float,
+    tp: float,
+    limit: bool,
+    preco: float | None = None,
+) -> dict:
+    """
+    Controla o fluxo completo da execução de venda:
+    - verifica risco,
+    - prepara a ordem,
+    - envia ao MetaTrader 5,
+    - retorna o resultado estruturado.
+    """
+
+    if verificar_risco():
+        log.info("Envio de ordem bloqueado por risco diário.")
+        return {"status": "bloqueado", "mensagem": "Limite de prejuízo atingido."}
+
+    try:
+        ordem, is_limit = preparar_ordem_venda(symbol, lot, sl, tp, limit, preco)
+        if ordem is None:
+            return {
+                "status": "falha",
+                "mensagem": "Falha ao preparar ordem.",
+                "resultado": {
+                    "tipo": "LIMIT" if limit else "MARKET",
+                    "preco": preco,
+                    "retcode": None,
+                    "mensagem": "Tick inválido ou símbolo não encontrado.",
+                },
+            }
+
+        resultado = enviar_ordem_venda(ordem, is_limit)
+
+        # MetaTrader 5 retorna 10009 = TRADE_RETCODE_DONE (sucesso)
+        if resultado.get("retcode") not in (10009,):
+            log.warning(f"Ordem recusada pelo MT5: {resultado}")
+            return {
+                "status": "falha",
+                "mensagem": "MetaTrader 5 recusou a ordem.",
+                "resultado": resultado,
+            }
+
+        log.info(f"✅ Ordem de compra enviada com sucesso para {symbol}.")
+        return {"status": "ok", "resultado": resultado}
+
+    except ValueError as e:
+        log.error(f"Erro de validação: {e}")
+        return {"status": "erro", "mensagem": str(e)}
+    except Exception as e:
+        log.exception(f"Erro inesperado ao executar venda: {e}")
+        return {"status": "erro", "mensagem": str(e)}

mtcli_trade-2.0.0.dev0/mtcli_trade/models/compra_model.py

@@ -0,0 +1,78 @@
+"""
+Camada Model responsável pela lógica de ordens de compra no MetaTrader 5.
+"""
+
+import MetaTrader5 as mt5
+
+from mtcli.logger import setup_logger
+from mtcli_trade.conf import LOSS_LIMIT, STATUS_FILE
+from mtcli_trade.models.ordem_model import criar_ordem, enviar_ordem, inicializar
+from mtcli_trade.models.risco_model import controlar_risco
+
+log = setup_logger()
+
+
+def verificar_risco() -> bool:
+    """Retorna True se o controle de risco bloquear a operação."""
+    try:
+        return controlar_risco(STATUS_FILE, LOSS_LIMIT)
+    except Exception as e:
+        log.exception(f"Erro ao verificar risco: {e}")
+        return True
+
+
+def preparar_ordem_compra(
+    symbol: str,
+    lot: float,
+    sl: float,
+    tp: float,
+    limit: bool,
+    preco: float | None = None,
+):
+    """
+    Prepara uma ordem de compra (market ou limit) para envio.
+
+    Retorna:
+        tuple: (ordem, limit) se sucesso, ou (None, None) se falha.
+    """
+    tick = inicializar(symbol)
+    if not tick:
+        log.error(f"Falha ao inicializar tick para símbolo {symbol}")
+        return None, None
+
+    if limit:
+        if preco is None:
+            raise ValueError("Preço obrigatório para ordens pendentes (--limit).")
+        price = preco
+        order_type = mt5.ORDER_TYPE_BUY_LIMIT
+    else:
+        price = tick.ask
+        order_type = mt5.ORDER_TYPE_BUY
+
+    ordem = criar_ordem(symbol, lot, sl, tp, price, order_type, limit)
+    log.debug(f"Ordem preparada: {ordem}")
+    return ordem, limit
+
+
+def enviar_ordem_compra(ordem: dict, limit: bool):
+    """
+    Envia uma ordem de compra válida para o MetaTrader 5.
+
+    Args:
+        ordem (dict): Estrutura de ordem gerada pelo Model.
+        limit (bool): Define se é ordem limitada (True) ou a mercado (False).
+
+    Returns:
+        dict: Resultado retornado pela função `enviar_ordem()`.
+    """
+    if not ordem:
+        log.error("Ordem inválida, cancelando envio.")
+        return {"retcode": None, "comment": "Ordem inválida."}
+
+    try:
+        resultado = enviar_ordem(ordem, limit)
+        log.debug(f"Resultado do envio da ordem: {resultado}")
+        return resultado
+    except Exception as e:
+        log.exception(f"Erro ao enviar ordem: {e}")
+        return {"retcode": None, "comment": str(e)}

mtcli_trade-2.0.0.dev0/mtcli_trade/models/ordem_model.py

@@ -0,0 +1,103 @@
+"""
+Modelo de execução de ordens no MetaTrader 5 (camada Model do MVC).
+Responsável por criar, enviar e inicializar ordens de compra/venda.
+"""
+
+import MetaTrader5 as mt5
+
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+
+log = setup_logger()
+
+
+def inicializar(symbol: str):
+    """
+    Inicializa o símbolo no MetaTrader 5 e retorna seu tick atual.
+    Retorna None se houver falha na seleção ou na obtenção do tick.
+    """
+    with mt5_conexao():
+        if not mt5.symbol_select(symbol, True):
+            log.error(f"Erro ao selecionar símbolo {symbol}")
+            return None
+
+        tick = mt5.symbol_info_tick(symbol)
+        if not tick:
+            log.error(f"Erro ao obter cotação de {symbol}")
+            return None
+
+        log.debug(f"Símbolo {symbol} inicializado com sucesso.")
+        return tick
+
+
+def criar_ordem(
+    symbol: str,
+    lot: float,
+    sl: float,
+    tp: float,
+    price: float,
+    order_type: int,
+    limit: bool,
+) -> dict:
+    """
+    Cria e retorna um dicionário com os parâmetros de uma ordem MT5.
+    Suporta ordens a mercado e ordens pendentes (limit).
+    """
+    try:
+        info = mt5.symbol_info(symbol)
+        point = getattr(info, "point", 0.01)
+    except Exception:
+        point = 0.01
+        log.warning(
+            f"Símbolo {symbol} sem informações completas; usando point padrão 0.01."
+        )
+
+    sl_price = (
+        price - sl * point
+        if order_type in (mt5.ORDER_TYPE_BUY, mt5.ORDER_TYPE_BUY_LIMIT)
+        else price + sl * point
+    )
+    tp_price = (
+        price + tp * point
+        if order_type in (mt5.ORDER_TYPE_BUY, mt5.ORDER_TYPE_BUY_LIMIT)
+        else price - tp * point
+    )
+
+    ordem = {
+        "action": mt5.TRADE_ACTION_PENDING if limit else mt5.TRADE_ACTION_DEAL,
+        "symbol": symbol,
+        "volume": lot,
+        "type": order_type,
+        "price": price,
+        "sl": sl_price,
+        "tp": tp_price,
+        "deviation": 10,
+        "magic": 1000,
+        "comment": "Ordem mtcli",
+        "type_time": mt5.ORDER_TIME_DAY,
+        "type_filling": mt5.ORDER_FILLING_IOC,
+    }
+
+    log.debug(f"Ordem criada: {ordem}")
+    return ordem
+
+
+def enviar_ordem(ordem, limit: bool):
+    """Envia a ordem e retorna resultado formatado, mesmo em falha."""
+    resultado = mt5.order_send(ordem)
+
+    if resultado is None:
+        return {
+            "retcode": None,
+            "comment": "Erro: ordem não enviada. Possível mercado fechado.",
+        }
+
+    return {
+        "retcode": resultado.retcode,
+        "comment": getattr(resultado, "comment", ""),
+        "order": getattr(resultado, "order", None),
+        "symbol": ordem["symbol"],
+        "type": "LIMIT" if limit else "MARKET",
+        "volume": ordem["volume"],
+        "price": ordem["price"],
+    }

mtcli_trade-2.0.0.dev0/mtcli_trade/models/ordens_model.py

@@ -0,0 +1,70 @@
+from typing import Any
+
+import MetaTrader5 as mt5
+
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+from mtcli_trade.conf import DIGITOS
+
+log = setup_logger()
+
+
+def buscar_ordens(symbol: str | None = None):
+    """Recupera ordens pendentes do MetaTrader 5."""
+    with mt5_conexao():
+        return mt5.orders_get(symbol=symbol) if symbol else mt5.orders_get()
+
+
+def formatar_ordem(ordem):
+    tipo = (
+        "COMPRA"
+        if ordem.type == mt5.ORDER_TYPE_BUY_LIMIT
+        else "VENDA"
+        if ordem.type == mt5.ORDER_TYPE_SELL_LIMIT
+        else str(ordem.type)
+    )
+    return {
+        "tipo": tipo,
+        "symbol": ordem.symbol,
+        "volume": ordem.volume_current,
+        "preco": round(ordem.price_open, DIGITOS),
+        "ticket": ordem.ticket,
+    }
+
+
+def cancelar_ordens(symbol: str | None = None) -> list[Any]:
+    """Cancela todas as ordens (ou as de um símbolo específico)."""
+    resultados = []
+    with mt5_conexao():
+        ordens = mt5.orders_get(symbol=symbol) if symbol else mt5.orders_get()
+
+        if not ordens:
+            log.info(
+                f"Nenhuma ordem pendente para {symbol}"
+                if symbol
+                else "Nenhuma ordem pendente encontrada."
+            )
+            return resultados
+
+        for ordem in ordens:
+            req = {
+                "action": mt5.TRADE_ACTION_REMOVE,
+                "order": ordem.ticket,
+                "symbol": ordem.symbol,
+                "magic": 1000,
+                "comment": "Cancelamento via CLI",
+            }
+
+            resultado = mt5.order_send(req)
+            if (
+                resultado
+                and getattr(resultado, "retcode", None) == mt5.TRADE_RETCODE_DONE
+            ):
+                log.info(f"Ordem cancelada: ticket {ordem.ticket} ({ordem.symbol})")
+            else:
+                log.error(
+                    f"Falha ao cancelar {ordem.ticket} código {getattr(resultado, 'retcode', 'N/A')}"
+                )
+            resultados.append(resultado)
+
+    return resultados