mtcli-renko 1.1.0.dev0__tar.gz → 1.1.0.dev2__tar.gz

{mtcli_renko-1.1.0.dev0 → mtcli_renko-1.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli-renko
-Version: 1.1.0.dev0
+Version: 1.1.0.dev2
 Summary: Renko plugin institucional para mtcli (MetaTrader 5)
 License-Expression: MIT
 License-File: LICENSE

{mtcli_renko-1.1.0.dev0 → mtcli_renko-1.1.0.dev2}/mtcli_renko/commands/renko.py

@@ -8,7 +8,7 @@ from ..controllers.renko_controller import RenkoController
 from ..views.renko_view import exibir_renko
 from ..domain.timeframe import Timeframe
 from mtcli.logger import setup_logger
-from ..conf import SYMBOL, BRICK, PERIOD, BARS, DATA_MODE, MAX_TICKS
+from ..conf import SYMBOL, BRICK, PERIOD, BARS, DATA_MODE, MAX_TICKS, TICK_STYLE
 
 log = setup_logger(__name__)
 
@@ -43,7 +43,13 @@ log = setup_logger(__name__)
     default=MAX_TICKS,
     show_default=True,
     type=int,
-    help="Limite máximo de ticks processados no modo tick.",
+)
+@click.option(
+    "--tick-style",
+    type=click.Choice(["estrutural", "hibrido", "agressivo"], case_sensitive=False),
+    default=TICK_STYLE,
+    show_default=True,
+    help="Define como tratar brick em formação no modo tick.",
 )
 def renko(
     symbol,
@@ -55,6 +61,7 @@ def renko(
     ancorar_abertura,
     data_mode,
     max_ticks,
+    tick_style,
 ):
 
     try:
@@ -71,7 +78,8 @@ def renko(
         ancorar_abertura,
         data_mode,
         max_ticks,
+        tick_style,
     )
 
-    bricks = controller.executar()
-    exibir_renko(bricks, numerar=numerar)
+    resultado = controller.executar()
+    exibir_renko(resultado, numerar=numerar)

{mtcli_renko-1.1.0.dev0 → mtcli_renko-1.1.0.dev2}/mtcli_renko/conf.py

@@ -87,3 +87,8 @@ MAX_TICKS = int(os.getenv(
     _get_config_value("RENKO", "max_ticks", 10000)
 ))
 
+TICK_STYLE = os.getenv(
+    "TICK_STYLE",
+    _get_config_value("RENKO", "tick_style", "hibrido")
+)
+

mtcli_renko-1.1.0.dev2/mtcli_renko/controllers/renko_controller.py

@@ -0,0 +1,105 @@
+"""
+Renko controller.
+
+Responsável por:
+- Orquestrar obtenção de dados (candle ou tick)
+- Chamar o model
+- Aplicar estilo de saída no modo tick
+"""
+
+from ..models.renko_model import RenkoModel
+from mtcli.logger import setup_logger
+
+log = setup_logger(__name__)
+
+
+class RenkoController:
+    """
+    Controller principal do Renko.
+
+    :param symbol: ativo (ex: WINJ26)
+    :param brick_size: tamanho do brick
+    :param timeframe: timeframe MT5 (para candle)
+    :param quantidade: número de candles
+    :param modo: simples ou classico
+    :param ancorar_abertura: ancora na abertura da sessão
+    :param data_mode: candle ou tick
+    :param max_ticks: quantidade máxima de ticks
+    :param tick_style: estrutural | hibrido | agressivo
+    """
+
+    def __init__(
+        self,
+        symbol,
+        brick_size,
+        timeframe,
+        quantidade,
+        modo="simples",
+        ancorar_abertura=False,
+        data_mode="candle",
+        max_ticks=3000,
+        tick_style="hibrido",
+    ):
+        self.model = RenkoModel(symbol, brick_size)
+        self.timeframe = timeframe
+        self.quantidade = quantidade
+        self.modo = modo
+        self.ancorar_abertura = ancorar_abertura
+        self.data_mode = data_mode
+        self.max_ticks = max_ticks
+        self.tick_style = tick_style
+
+    def executar(self):
+        """
+        Executa construção do Renko conforme modo configurado.
+        """
+
+        # =========================
+        # MODO TICK
+        # =========================
+        if self.data_mode == "tick":
+
+            ticks = self.model.obter_ticks(
+                timeframe=self.timeframe,
+                max_ticks=self.max_ticks,
+            )
+
+            # 🔒 Correção definitiva do erro numpy
+            if ticks is None or len(ticks) == 0:
+                return []
+
+            resultado = self.model.construir_renko_ticks(ticks)
+
+            # =========================
+            # Aplicar estilo de tick
+            # =========================
+
+            # Estrutural → somente confirmados
+            if self.tick_style == "estrutural":
+                return resultado.confirmados
+
+            # Agressivo → confirmados + parcial como válido
+            if self.tick_style == "agressivo":
+                if resultado.em_formacao:
+                    return resultado.confirmados + [resultado.em_formacao]
+                return resultado.confirmados
+
+            # Híbrido (default) → retorna objeto completo
+            return resultado
+
+        # =========================
+        # MODO CANDLE
+        # =========================
+        rates = self.model.obter_rates(
+            self.timeframe,
+            self.quantidade,
+            ancorar_abertura=self.ancorar_abertura,
+        )
+
+        if rates is None or len(rates) == 0:
+            return []
+
+        return self.model.construir_renko(
+            rates,
+            modo=self.modo,
+        )

{mtcli_renko-1.1.0.dev0 → mtcli_renko-1.1.0.dev2}/mtcli_renko/models/renko_model.py

@@ -1,16 +1,15 @@
 """
 Renko model institucional profissional.
 
-✔ Ancoragem determinística por data
-✔ Suporte candle e tick
+✔ Candle mode determinístico
+✔ Tick mode híbrido (confirmados + em formação)
+✔ Estrutura estável
 ✔ Compatível com controller atual
-✔ Seguro para numpy arrays
-✔ Funciona fora do pregão
 """
 
 from dataclasses import dataclass
-from typing import List, Optional
-from datetime import datetime, timedelta
+from typing import List, Optional, NamedTuple
+from datetime import datetime
 
 import MetaTrader5 as mt5
 
@@ -22,7 +21,7 @@ log = setup_logger(__name__)
 
 
 # ==========================================================
-# DATA STRUCTURE
+# DATA STRUCTURES
 # ==========================================================
 
 @dataclass
@@ -32,6 +31,11 @@ class RenkoBrick:
     close: float
 
 
+class RenkoResult(NamedTuple):
+    confirmados: List[RenkoBrick]
+    em_formacao: Optional[RenkoBrick]
+
+
 # ==========================================================
 # MODEL
 # ==========================================================
@@ -43,7 +47,7 @@ class RenkoModel:
         self.brick_size = brick_size
 
     # ======================================================
-    # AUXILIAR: descobrir último pregão real
+    # AUXILIAR
     # ======================================================
 
     def _ultimo_pregao_data(self, timeframe):
@@ -72,10 +76,6 @@ class RenkoModel:
             if not mt5.symbol_select(self.symbol, True):
                 raise RuntimeError(f"Erro ao selecionar símbolo {self.symbol}")
 
-            # -------------------------------------------------
-            # SEM ANCORAGEM
-            # -------------------------------------------------
-
             if not ancorar_abertura:
 
                 if quantidade == 0:
@@ -88,14 +88,7 @@ class RenkoModel:
                     quantidade,
                 )
 
-                if rates is None:
-                    return []
-
-                return rates
-
-            # -------------------------------------------------
-            # COM ANCORAGEM REAL POR DATA
-            # -------------------------------------------------
+                return rates or []
 
             data_pregao = self._ultimo_pregao_data(timeframe)
 
@@ -119,21 +112,13 @@ class RenkoModel:
                 if r_time.date() == data_pregao:
                     filtrado.append(r)
 
-            if not filtrado:
-                return []
-
-            total = len(filtrado)
-
             if quantidade == 0:
                 return filtrado
 
-            if quantidade >= total:
-                return filtrado
-
             return filtrado[-quantidade:]
 
     # ======================================================
-    # TICKS (tick mode)
+    # TICKS
     # ======================================================
 
     def obter_ticks(self, timeframe, max_ticks=5000):
@@ -153,110 +138,62 @@ class RenkoModel:
                 datetime.strptime(SESSION_OPEN, "%H:%M").time(),
             )
 
-            ticks = mt5.copy_ticks_from(
+            agora = datetime.now()
+
+            ticks = mt5.copy_ticks_range(
                 self.symbol,
                 inicio,
-                max_ticks,
+                agora,
                 mt5.COPY_TICKS_ALL,
             )
 
-            if ticks is None:
+            if ticks is None or len(ticks) == 0:
                 return []
 
+            if len(ticks) > max_ticks:
+                ticks = ticks[-max_ticks:]
+
             return ticks
 
     # ======================================================
     # CONSTRUÇÃO RENKO (CANDLE)
     # ======================================================
 
-    def construir_renko(
-        self,
-        rates,
-        modo="simples",
-    ) -> List[RenkoBrick]:
+    def construir_renko(self, rates, modo="simples") -> List[RenkoBrick]:
 
         if rates is None or len(rates) < 2:
             return []
 
         bricks: List[RenkoBrick] = []
-
         last_price = float(rates[0]["open"])
-        direction: Optional[str] = None
 
         for rate in rates[1:]:
 
             high = float(rate["high"])
             low = float(rate["low"])
 
-            # -------------------------------------------------
-            # MODO SIMPLES
-            # -------------------------------------------------
-
-            if modo == "simples":
-
-                while high - last_price >= self.brick_size:
-                    novo = last_price + self.brick_size
-                    bricks.append(RenkoBrick("up", last_price, novo))
-                    last_price = novo
-
-                while last_price - low >= self.brick_size:
-                    novo = last_price - self.brick_size
-                    bricks.append(RenkoBrick("down", last_price, novo))
-                    last_price = novo
-
-            # -------------------------------------------------
-            # MODO CLÁSSICO (reversão 2x)
-            # -------------------------------------------------
-
-            elif modo == "classico":
-
-                if direction in (None, "up"):
-
-                    while high - last_price >= self.brick_size:
-                        novo = last_price + self.brick_size
-                        bricks.append(RenkoBrick("up", last_price, novo))
-                        last_price = novo
-                        direction = "up"
-
-                    if (
-                        direction == "up"
-                        and last_price - low >= 2 * self.brick_size
-                    ):
-                        novo = last_price - self.brick_size
-                        bricks.append(RenkoBrick("down", last_price, novo))
-                        last_price = novo
-                        direction = "down"
-
-                if direction in (None, "down"):
-
-                    while last_price - low >= self.brick_size:
-                        novo = last_price - self.brick_size
-                        bricks.append(RenkoBrick("down", last_price, novo))
-                        last_price = novo
-                        direction = "down"
-
-                    if (
-                        direction == "down"
-                        and high - last_price >= 2 * self.brick_size
-                    ):
-                        novo = last_price + self.brick_size
-                        bricks.append(RenkoBrick("up", last_price, novo))
-                        last_price = novo
-                        direction = "up"
+            while high - last_price >= self.brick_size:
+                novo = last_price + self.brick_size
+                bricks.append(RenkoBrick("up", last_price, novo))
+                last_price = novo
+
+            while last_price - low >= self.brick_size:
+                novo = last_price - self.brick_size
+                bricks.append(RenkoBrick("down", last_price, novo))
+                last_price = novo
 
         return bricks
 
     # ======================================================
-    # CONSTRUÇÃO RENKO (TICK)
+    # CONSTRUÇÃO RENKO (TICK HÍBRIDO)
     # ======================================================
 
-    def construir_renko_ticks(self, ticks) -> List[RenkoBrick]:
+    def construir_renko_ticks(self, ticks) -> RenkoResult:
 
         if ticks is None or len(ticks) < 2:
-            return []
+            return RenkoResult([], None)
 
         bricks: List[RenkoBrick] = []
-
         last_price = float(ticks[0]["last"])
 
         for tick in ticks[1:]:
@@ -273,4 +210,26 @@ class RenkoModel:
                 bricks.append(RenkoBrick("down", last_price, novo))
                 last_price = novo
 
-        return bricks
+        # ----------------------------
+        # Brick em formação
+        # ----------------------------
+
+        ultimo_preco = float(ticks[-1]["last"])
+        diferenca = ultimo_preco - last_price
+
+        em_formacao = None
+
+        if abs(diferenca) > 0:
+
+            direcao = "up" if diferenca > 0 else "down"
+
+            em_formacao = RenkoBrick(
+                direction=direcao,
+                open=last_price,
+                close=ultimo_preco,
+            )
+
+        return RenkoResult(
+            confirmados=bricks,
+            em_formacao=em_formacao,
+        )

mtcli_renko-1.1.0.dev2/mtcli_renko/views/renko_view.py

@@ -0,0 +1,75 @@
+"""
+Renko view acessível.
+"""
+
+import click
+from ..conf import DIGITS
+
+
+def exibir_renko(resultado, numerar: bool = False):
+
+    if not resultado:
+        click.echo("Nenhum bloco Renko gerado.")
+        return
+
+    # Lista simples (estrutural ou agressivo)
+    if isinstance(resultado, list):
+
+        click.echo("=== GRAFICO RENKO ===")
+        click.echo(f"Total de blocos: {len(resultado)}")
+        click.echo()
+
+        for i, brick in enumerate(resultado, start=1):
+
+            if numerar:
+                linha = (
+                    f"{i} "
+                    f"{brick.direction.upper()} "
+                    f"{brick.open:.{DIGITS}f} "
+                    f"{brick.close:.{DIGITS}f}"
+                )
+            else:
+                linha = (
+                    f"{brick.direction.upper()} "
+                    f"{brick.open:.{DIGITS}f} "
+                    f"{brick.close:.{DIGITS}f}"
+                )
+
+            click.echo(linha)
+
+        return
+
+    # Híbrido
+    confirmados = resultado.confirmados
+    em_formacao = resultado.em_formacao
+
+    click.echo("=== GRAFICO RENKO ===")
+    click.echo(f"Blocos confirmados: {len(confirmados)}")
+    click.echo()
+
+    for i, brick in enumerate(confirmados, start=1):
+
+        if numerar:
+            linha = (
+                f"{i} "
+                f"{brick.direction.upper()} "
+                f"{brick.open:.{DIGITS}f} "
+                f"{brick.close:.{DIGITS}f}"
+            )
+        else:
+            linha = (
+                f"{brick.direction.upper()} "
+                f"{brick.open:.{DIGITS}f} "
+                f"{brick.close:.{DIGITS}f}"
+            )
+
+        click.echo(linha)
+
+    if em_formacao:
+        click.echo()
+        click.echo("EM FORMACAO:")
+        click.echo(
+            f"{em_formacao.direction.upper()} "
+            f"{em_formacao.open:.{DIGITS}f} "
+            f"{em_formacao.close:.{DIGITS}f}"
+        )

{mtcli_renko-1.1.0.dev0 → mtcli_renko-1.1.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-renko"
-version = "1.1.0.dev0"
+version = "1.1.0.dev2"
 description = "Renko plugin institucional para mtcli (MetaTrader 5)"
 authors = [
     { name = "Valmir França", email = "vfranca3@gmail.com" }

mtcli_renko-1.1.0.dev0/mtcli_renko/controllers/renko_controller.py

@@ -1,66 +0,0 @@
-"""
-Renko controller.
-"""
-
-from ..models.renko_model import RenkoModel
-from mtcli.logger import setup_logger
-
-log = setup_logger(__name__)
-
-
-class RenkoController:
-
-    def __init__(
-        self,
-        symbol,
-        brick_size,
-        timeframe,
-        quantidade,
-        modo="simples",
-        ancorar_abertura=False,
-        data_mode="candle",
-        max_ticks=3000,
-    ):
-        self.model = RenkoModel(symbol, brick_size)
-        self.timeframe = timeframe
-        self.quantidade = quantidade
-        self.modo = modo
-        self.ancorar_abertura = ancorar_abertura
-        self.data_mode = data_mode
-        self.max_ticks = max_ticks
-
-    def executar(self):
-
-        # -------------------------------------------------
-        # TICK MODE
-        # -------------------------------------------------
-
-        if self.data_mode == "tick":
-
-            ticks = self.model.obter_ticks(
-                timeframe=self.timeframe,
-                max_ticks=self.max_ticks,
-            )
-
-            if ticks is None or len(ticks) == 0:
-                return []
-
-            return self.model.construir_renko_ticks(ticks)
-
-        # -------------------------------------------------
-        # CANDLE MODE
-        # -------------------------------------------------
-
-        rates = self.model.obter_rates(
-            self.timeframe,
-            self.quantidade,
-            ancorar_abertura=self.ancorar_abertura,
-        )
-
-        if rates is None or len(rates) == 0:
-            return []
-
-        return self.model.construir_renko(
-            rates,
-            modo=self.modo,
-        )

mtcli_renko-1.1.0.dev0/mtcli_renko/views/renko_view.py

@@ -1,37 +0,0 @@
-"""
-Renko view.
-
-Saída textual acessível para leitores de tela.
-"""
-
-import click
-from ..conf import DIGITS
-
-
-def exibir_renko(bricks, numerar: bool = False):
-
-    if not bricks:
-        click.echo("Nenhum bloco Renko gerado.")
-        return
-
-    click.echo("=== GRAFICO RENKO ===")
-    click.echo(f"Total de blocos: {len(bricks)}")
-    click.echo()
-
-    for i, brick in enumerate(bricks, start=1):
-
-        if numerar:
-            linha = (
-                f"{i} "
-                f"{brick.direction.upper()} "
-                f"{brick.open:.{DIGITS}f} "
-                f"{brick.close:.{DIGITS}f}"
-            )
-        else:
-            linha = (
-                f"{brick.direction.upper()} "
-                f"{brick.open:.{DIGITS}f} "
-                f"{brick.close:.{DIGITS}f}"
-            )
-
-        click.echo(linha)