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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli-renko
-Version: 1.1.0.dev2
+Version: 1.1.0.dev3
 Summary: Renko plugin institucional para mtcli (MetaTrader 5)
 License-Expression: MIT
 License-File: LICENSE
@@ -19,7 +19,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Dist: click (>=8.3.0,<9.0.0)
 Requires-Dist: metatrader5 (>=5.0.5370,<6.0.0)
-Requires-Dist: mtcli (>=3.2.0)
+Requires-Dist: mtcli (>=3.5.0)
 Project-URL: Documentation, https://vfranca.github.io/mtcli-renko
 Project-URL: Homepage, https://github.com/vfranca/mtcli-renko
 Project-URL: Issues, https://github.com/vfranca/mtcli-renko/issues

mtcli_renko-1.1.0.dev3/mtcli_renko/commands/renko.py

@@ -0,0 +1,105 @@
+"""
+Comando CLI para geração de gráfico Renko.
+"""
+
+import click
+
+from ..controllers.renko_controller import RenkoController
+from ..views.renko_view import exibir_renko
+from mtcli.domain.timeframe import Timeframe
+from mtcli.logger import setup_logger
+from ..conf import (
+    SYMBOL,
+    BRICK,
+    PERIOD,
+    BARS,
+    DATA_MODE,
+    MAX_TICKS,
+    TICK_STYLE,
+    MODO,
+    LIMIT_BRICKS
+)
+
+log = setup_logger(__name__)
+
+
+@click.command()
+@click.version_option(package_name="mtcli-renko")
+@click.option("--symbol", "-s", default=SYMBOL, show_default=True)
+@click.option("--brick", "-b", default=BRICK, show_default=True, type=float)
+@click.option("--timeframe", "-t", default=PERIOD, show_default=True)
+@click.option("--bars", "-n", default=BARS, show_default=True, type=int)
+@click.option("--numerar/--no-numerar", default=False, show_default=True)
+@click.option(
+    "--modo",
+    type=click.Choice(["simples", "classico"], case_sensitive=False),
+    default=MODO,
+    show_default=True,
+    help="Modo de calculo dos blocos"
+)
+@click.option("--ancorar-abertura", is_flag=True, show_default=True, help="Ancora na abertura do pregão")
+@click.option(
+    "--data-mode",
+    type=click.Choice(["candle", "tick"]),
+    default=DATA_MODE,
+    show_default=True,
+    help="Dados baseados em candles ou ticks"
+)
+@click.option("--max-ticks", default=MAX_TICKS, type=int, show_default=True, help="Maximo de ticks usados no renko baseado em ticks")
+@click.option(
+    "--tick-style",
+    type=click.Choice(["estrutural", "hibrido", "agressivo"]),
+    default=TICK_STYLE,
+    show_default=True,
+    help="Estilo de calculo dos blocos baseado em ticks"
+)
+@click.option("--limit-bricks", type=int, default=LIMIT_BRICKS, show_default=True, help="Limite de blocos")
+@click.option("--price-min", type=float, default=None, show_default=True, help="Preço mínimo para filtrar blocos")
+@click.option("--price-max", type=float, default=None, show_default=True, help="Preço máximo para filtrar blocos")
+@click.option("--reverse", is_flag=True, show_default=True, help="Reverte a órdem dos blocos")
+
+
+def renko(
+    symbol,
+    brick,
+    timeframe,
+    bars,
+    numerar,
+    modo,
+    ancorar_abertura,
+    data_mode,
+    max_ticks,
+    tick_style,
+    limit_bricks,
+    price_min,
+    price_max,
+    reverse,
+):
+    """
+    Gera gráfico Renko no terminal.
+    """
+
+    try:
+        tf_enum = Timeframe.from_string(timeframe)
+    except ValueError as e:
+        raise click.BadParameter(str(e))
+
+    controller = RenkoController(
+        symbol=symbol,
+        brick_size=brick,
+        timeframe=tf_enum.mt5_const,
+        quantidade=bars,
+        modo=modo,
+        ancorar_abertura=ancorar_abertura,
+        data_mode=data_mode,
+        max_ticks=max_ticks,
+        tick_style=tick_style,
+        price_min=price_min,
+        price_max=price_max,
+        limit_bricks=limit_bricks,
+        reverse=reverse,
+    )
+
+    resultado = controller.executar()
+
+    exibir_renko(resultado, numerar=numerar)

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

@@ -92,3 +92,12 @@ TICK_STYLE = os.getenv(
     _get_config_value("RENKO", "tick_style", "hibrido")
 )
 
+MODO = os.getenv(
+    "MODO",
+    _get_config_value("RENKO", "modo", "simples")
+)
+
+LIMIT_BRICKS = int(os.getenv(
+    "LIMIT_BRICKS",
+    _get_config_value("RENKO", "limit_bricks", 0)
+))

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

@@ -0,0 +1,154 @@
+"""
+Renko controller.
+
+Responsável por:
+
+- Orquestrar obtenção de dados (candle ou tick)
+- Chamar o model
+- Aplicar filtros e estilos
+"""
+
+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
+    :param brick_size: tamanho do brick
+    :param timeframe: timeframe MT5
+    :param quantidade: número de candles
+    :param modo: simples | classico
+    :param ancorar_abertura: ancora sessão
+    :param data_mode: candle | tick
+    :param max_ticks: limite ticks
+    :param tick_style: estrutural | hibrido | agressivo
+    :param price_min: filtro preço mínimo
+    :param price_max: filtro preço máximo
+    :param limit_bricks: limite de blocos
+    :param reverse: inverter ordem
+    """
+
+    def __init__(
+        self,
+        symbol,
+        brick_size,
+        timeframe,
+        quantidade,
+        modo="simples",
+        ancorar_abertura=False,
+        data_mode="candle",
+        max_ticks=3000,
+        tick_style="hibrido",
+        price_min=None,
+        price_max=None,
+        limit_bricks=None,
+        reverse=False,
+    ):
+
+        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
+
+        self.price_min = price_min
+        self.price_max = price_max
+        self.limit_bricks = limit_bricks
+        self.reverse = reverse
+
+    # ==========================================================
+    # EXECUÇÃO
+    # ==========================================================
+
+    def executar(self):
+
+        # ======================================================
+        # TICK MODE
+        # ======================================================
+
+        if self.data_mode == "tick":
+
+            ticks = self.model.obter_ticks(
+                max_ticks=self.max_ticks,
+                ancorar_abertura=self.ancorar_abertura,
+            )
+
+            if ticks is None or len(ticks) == 0:
+                log.warning("Nenhum tick retornado.")
+                return []
+
+            resultado = self.model.construir_renko_ticks(ticks)
+
+            bricks = resultado.confirmados
+
+        # ======================================================
+        # CANDLE MODE
+        # ======================================================
+
+        else:
+
+            rates = self.model.obter_rates(
+                self.timeframe,
+                self.quantidade,
+                ancorar_abertura=self.ancorar_abertura,
+            )
+
+            if rates is None or len(rates) == 0:
+                log.warning("Nenhum candle retornado.")
+                return []
+
+            bricks = self.model.construir_renko(
+                rates,
+                modo=self.modo,
+            )
+
+            resultado = bricks
+
+        # ======================================================
+        # FILTROS
+        # ======================================================
+
+        if self.price_min is not None:
+            bricks = [b for b in bricks if b.close >= self.price_min]
+
+        if self.price_max is not None:
+            bricks = [b for b in bricks if b.close <= self.price_max]
+
+        if self.reverse:
+            bricks = list(reversed(bricks))
+
+        if self.limit_bricks:
+            bricks = bricks[-self.limit_bricks:]
+
+        # ======================================================
+        # TICK STYLE
+        # ======================================================
+
+        if self.data_mode == "tick":
+
+            if self.tick_style == "estrutural":
+                return bricks
+
+            if self.tick_style == "agressivo":
+
+                if resultado.em_formacao:
+                    bricks.append(resultado.em_formacao)
+
+                return bricks
+
+            # híbrido
+            resultado = resultado._replace(confirmados=bricks)
+
+            return resultado
+
+        return bricks

mtcli_renko-1.1.0.dev3/mtcli_renko/models/renko_model.py

@@ -0,0 +1,315 @@
+"""
+RenkoModel profissional.
+
+✔ Candle mode determinístico
+✔ Tick mode híbrido (confirmados + em formação)
+✔ Compatível com controller atual
+✔ Funciona mesmo com mercado fechado
+✔ Correção numpy truth value
+✔ Correção timezone sessão
+✔ Path reconstruction institucional
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, NamedTuple
+from zoneinfo import ZoneInfo
+from datetime import datetime, time as dtime
+
+import MetaTrader5 as mt5
+
+from mtcli.mt5_context import mt5_conexao
+from mtcli.logger import setup_logger
+from mtcli.marketdata.tick_repository import TickRepository
+from ..conf import SESSION_OPEN
+
+log = setup_logger(__name__)
+
+
+# ==========================================================
+# DATA STRUCTURES
+# ==========================================================
+
+@dataclass
+class Brick:
+    direction: str
+    open: float
+    close: float
+
+
+class RenkoTickResult(NamedTuple):
+    confirmados: List[Brick]
+    em_formacao: Optional[Brick]
+
+
+# ==========================================================
+# MODEL
+# ==========================================================
+
+class RenkoModel:
+
+    def __init__(self, symbol: str, brick_size: float):
+
+        self.symbol = symbol
+        self.brick_size = brick_size
+        self.repo = TickRepository()
+
+    # ======================================================
+    # AUXILIAR
+    # ======================================================
+
+    def _ultimo_pregao_data(self, timeframe):
+
+        with mt5_conexao():
+
+            ultimo = mt5.copy_rates_from_pos(
+                self.symbol,
+                timeframe,
+                0,
+                1,
+            )
+
+        if ultimo is None or len(ultimo) == 0:
+            return None
+
+        ultimo_time = datetime.utcfromtimestamp(int(ultimo[0]["time"]))
+        return ultimo_time.date()
+
+    # ======================================================
+    # RATES (CANDLE MODE)
+    # ======================================================
+
+    def obter_rates(self, timeframe, quantidade, ancorar_abertura=False):
+
+        with mt5_conexao():
+
+            if not mt5.symbol_select(self.symbol, True):
+                raise RuntimeError(f"Erro ao selecionar símbolo {self.symbol}")
+
+            if quantidade == 0:
+                quantidade = 1000
+
+            rates = mt5.copy_rates_from_pos(
+                self.symbol,
+                timeframe,
+                0,
+                quantidade,
+            )
+
+        if rates is None or len(rates) == 0:
+            return []
+
+        if not ancorar_abertura:
+            return rates
+
+        # ----------------------------------------------------
+        # ANCORAGEM NA ÚLTIMA SESSÃO DISPONÍVEL
+        # ----------------------------------------------------
+
+        from datetime import timedelta
+
+        ultimo_ts = int(rates[-1]["time"])
+
+        ultimo_dt = datetime.fromtimestamp(ultimo_ts)
+
+        ultimo_dia = ultimo_dt.date()
+
+        abertura = datetime.combine(
+            ultimo_dia,
+            dtime.fromisoformat(SESSION_OPEN),
+        )
+
+        # ajuste B3 -> UTC
+        abertura = abertura - timedelta(hours=3)
+
+        abertura_ts = int(abertura.timestamp())
+
+        filtrados = []
+
+        for r in rates:
+
+            ts = int(r["time"])
+
+            if ts >= abertura_ts:
+                filtrados.append(r)
+
+        return filtrados
+
+    # ======================================================
+    # TICKS (BANCO + MT5)
+    # ======================================================
+
+    def obter_ticks(self, max_ticks=5000, ancorar_abertura=False):
+
+        from datetime import timedelta
+
+        last_time = self.repo._get_last_tick_time(self.symbol)
+
+        if last_time is None:
+
+            self.repo.sync(self.symbol, days_back=3)
+            last_time = self.repo._get_last_tick_time(self.symbol)
+
+        else:
+
+            self.repo.sync(self.symbol)
+
+        if last_time is None:
+            return []
+
+        end_ts = int(datetime.now().timestamp())
+
+        if ancorar_abertura:
+
+            data = datetime.fromtimestamp(last_time)
+
+            # 09:00 horário B3
+            abertura_b3 = datetime.combine(
+                data.date(),
+                datetime.strptime(SESSION_OPEN, "%H:%M").time(),
+            )
+
+            # converter B3 (UTC-3) → UTC
+            abertura_utc = abertura_b3 - timedelta(hours=3)
+
+            # margem de segurança
+            abertura_utc = abertura_utc + timedelta(seconds=50)
+
+            start_ts = int(abertura_utc.timestamp())
+
+        else:
+
+            start_ts = 0
+
+        rows = self.repo.get_ticks_between(
+            self.symbol,
+            start_ts,
+            end_ts,
+        )
+
+        if rows is None or len(rows) == 0:
+            return []
+
+        return rows[-max_ticks:]
+
+    # ======================================================
+    # RENKO CANDLE (PATH RECONSTRUCTION)
+    # ======================================================
+
+    def construir_renko(self, rates, modo="simples") -> List[Brick]:
+
+        if rates is None or len(rates) < 2:
+            return []
+
+        bricks: List[Brick] = []
+
+        last_price = float(rates[0]["open"])
+
+        for rate in rates[1:]:
+
+            open_p = float(rate["open"])
+            high = float(rate["high"])
+            low = float(rate["low"])
+            close = float(rate["close"])
+
+            # -------------------------------------------------
+            # PATH RECONSTRUCTION
+            # -------------------------------------------------
+
+            if close >= open_p:
+                path = [low, high, close]
+            else:
+                path = [high, low, close]
+
+            for price in path:
+
+                while price - last_price >= self.brick_size:
+
+                    novo = last_price + self.brick_size
+
+                    bricks.append(
+                        Brick(
+                            direction="up",
+                            open=last_price,
+                            close=novo,
+                        )
+                    )
+
+                    last_price = novo
+
+                while last_price - price >= self.brick_size:
+
+                    novo = last_price - self.brick_size
+
+                    bricks.append(
+                        Brick(
+                            direction="down",
+                            open=last_price,
+                            close=novo,
+                        )
+                    )
+
+                    last_price = novo
+
+        return bricks
+
+    # ======================================================
+    # RENKO TICK MODE
+    # ======================================================
+
+    def construir_renko_ticks(self, ticks) -> RenkoTickResult:
+
+        if ticks is None or len(ticks) < 2:
+            return RenkoTickResult([], None)
+
+        bricks: List[Brick] = []
+
+        last_price = float(ticks[0][3])
+
+        for tick in ticks[1:]:
+
+            price = float(tick[3])
+
+            while price - last_price >= self.brick_size:
+
+                novo = last_price + self.brick_size
+
+                bricks.append(
+                    Brick("up", last_price, novo)
+                )
+
+                last_price = novo
+
+            while last_price - price >= self.brick_size:
+
+                novo = last_price - self.brick_size
+
+                bricks.append(
+                    Brick("down", last_price, novo)
+                )
+
+                last_price = novo
+
+        # ------------------------------------------
+        # brick em formação
+        # ------------------------------------------
+
+        ultimo_preco = float(ticks[-1][3])
+
+        diferenca = ultimo_preco - last_price
+
+        em_formacao = None
+
+        if abs(diferenca) > 0:
+
+            direcao = "up" if diferenca > 0 else "down"
+
+            em_formacao = Brick(
+                direction=direcao,
+                open=last_price,
+                close=ultimo_preco,
+            )
+
+        return RenkoTickResult(
+            confirmados=bricks,
+            em_formacao=em_formacao,
+        )

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

@@ -0,0 +1,81 @@
+"""
+Renko view acessível.
+"""
+
+import click
+from ..conf import DIGITS
+
+
+def _detectar_padroes(bricks):
+
+    if len(bricks) < 3:
+        return []
+
+    patterns = []
+
+    last = bricks[-1].direction
+    prev = bricks[-2].direction
+    prev2 = bricks[-3].direction
+
+    if last == "up" and prev == "down":
+        patterns.append("H1")
+
+    if last == "up" and prev == "down" and prev2 == "up":
+        patterns.append("H2")
+
+    if last == "down" and prev == "up" and prev2 == "down":
+        patterns.append("L2")
+
+    return patterns
+
+
+def _metricas(bricks):
+
+    up = sum(1 for b in bricks if b.direction == "up")
+    down = sum(1 for b in bricks if b.direction == "down")
+
+    return up, down
+
+
+def exibir_renko(resultado, numerar=False):
+
+    if not resultado:
+        click.echo("Nenhum bloco Renko gerado.")
+        return
+
+    if isinstance(resultado, list):
+
+        bricks = resultado
+
+    else:
+
+        bricks = resultado.confirmados
+
+    click.echo("=== GRAFICO RENKO ===")
+    click.echo(f"Total de blocos: {len(bricks)}")
+    click.echo()
+
+    up, down = _metricas(bricks)
+
+    click.echo("METRICAS:")
+    click.echo(f"Up: {up}")
+    click.echo(f"Down: {down}")
+    click.echo(f"Delta: {up-down}")
+    click.echo()
+
+    patterns = _detectar_padroes(bricks)
+
+    if patterns:
+        click.echo("PADROES:")
+        for p in patterns:
+            click.echo(p)
+        click.echo()
+
+    for i, brick in enumerate(bricks, start=1):
+
+        if numerar:
+            linha = f"{i} {brick.direction.upper()} {brick.open:.{DIGITS}f} {brick.close:.{DIGITS}f}"
+        else:
+            linha = f"{brick.direction.upper()} {brick.open:.{DIGITS}f} {brick.close:.{DIGITS}f}"
+
+        click.echo(linha)

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

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-renko"
-version = "1.1.0.dev2"
+version = "1.1.0.dev3"
 description = "Renko plugin institucional para mtcli (MetaTrader 5)"
 authors = [
     { name = "Valmir França", email = "vfranca3@gmail.com" }
@@ -32,9 +32,9 @@ classifiers = [
 ]
 
 dependencies = [
-    "mtcli>=3.2.0",
+    "mtcli>=3.5.0",
     "click>=8.3.0,<9.0.0",
-    "metatrader5>=5.0.5370,<6.0.0"
+    "metatrader5>=5.0.5370,<6.0.0",
 ]
 
 [project.urls]

mtcli_renko-1.1.0.dev2/mtcli_renko/commands/renko.py

@@ -1,85 +0,0 @@
-"""
-Comando CLI para geração de gráfico Renko.
-"""
-
-import click
-
-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, TICK_STYLE
-
-log = setup_logger(__name__)
-
-
-@click.command()
-@click.version_option(package_name="mtcli-renko")
-@click.option("--symbol", "-s", default=SYMBOL, show_default=True)
-@click.option("--brick", "-b", default=BRICK, show_default=True, type=float)
-@click.option("--timeframe", "-t", default=PERIOD, show_default=True)
-@click.option("--bars", "-n", default=BARS, show_default=True, type=int)
-@click.option("--numerar/--no-numerar", default=False, show_default=True)
-@click.option(
-    "--modo",
-    type=click.Choice(["simples", "classico"], case_sensitive=False),
-    default="simples",
-    show_default=True,
-)
-@click.option(
-    "--ancorar-abertura",
-    is_flag=True,
-    default=False,
-    show_default=True,
-)
-@click.option(
-    "--data-mode",
-    type=click.Choice(["candle", "tick"], case_sensitive=False),
-    default=DATA_MODE,
-    show_default=True,
-)
-@click.option(
-    "--max-ticks",
-    default=MAX_TICKS,
-    show_default=True,
-    type=int,
-)
-@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,
-    brick,
-    timeframe,
-    bars,
-    numerar,
-    modo,
-    ancorar_abertura,
-    data_mode,
-    max_ticks,
-    tick_style,
-):
-
-    try:
-        tf_enum = Timeframe.from_string(timeframe)
-    except ValueError as e:
-        raise click.BadParameter(str(e))
-
-    controller = RenkoController(
-        symbol,
-        brick,
-        tf_enum.mt5_const,
-        bars,
-        modo,
-        ancorar_abertura,
-        data_mode,
-        max_ticks,
-        tick_style,
-    )
-
-    resultado = controller.executar()
-    exibir_renko(resultado, numerar=numerar)

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

@@ -1,105 +0,0 @@
-"""
-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.dev2/mtcli_renko/domain/timeframe.py

@@ -1,87 +0,0 @@
-"""
-Enum de Timeframes suportados pelo MTCLI Renko.
-
-Fornece:
-- Conversão amigável (m5, 5m, h1, 1h)
-- Mapeamento para constante MT5
-- Lista de valores válidos para CLI
-"""
-
-from enum import Enum
-import MetaTrader5 as mt5
-
-
-class Timeframe(Enum):
-    """
-    Representa timeframes suportados pelo MT5.
-    """
-
-    M1 = ("m1", mt5.TIMEFRAME_M1)
-    M2 = ("m2", mt5.TIMEFRAME_M2)
-    M3 = ("m3", mt5.TIMEFRAME_M3)
-    M4 = ("m4", mt5.TIMEFRAME_M4)
-    M5 = ("m5", mt5.TIMEFRAME_M5)
-    M10 = ("m10", mt5.TIMEFRAME_M10)
-    M15 = ("m15", mt5.TIMEFRAME_M15)
-    M30 = ("m30", mt5.TIMEFRAME_M30)
-
-    H1 = ("h1", mt5.TIMEFRAME_H1)
-    H2 = ("h2", mt5.TIMEFRAME_H2)
-    H3 = ("h3", mt5.TIMEFRAME_H3)
-    H4 = ("h4", mt5.TIMEFRAME_H4)
-    H6 = ("h6", mt5.TIMEFRAME_H6)
-    H8 = ("h8", mt5.TIMEFRAME_H8)
-    H12 = ("h12", mt5.TIMEFRAME_H12)
-
-    D1 = ("d1", mt5.TIMEFRAME_D1)
-    W1 = ("w1", mt5.TIMEFRAME_W1)
-    MN1 = ("mn1", mt5.TIMEFRAME_MN1)
-
-    def __init__(self, label: str, mt5_const: int):
-        self.label = label
-        self.mt5_const = mt5_const
-
-    @classmethod
-    def from_string(cls, value: str) -> "Timeframe":
-        """
-        Converte string amigável para Enum Timeframe.
-
-        Aceita:
-            m5, 5m
-            h1, 1h
-            d1, 1d
-        """
-
-        value = value.strip().lower()
-
-        # Aliases humanos
-        aliases = {
-            "1m": "m1",
-            "5m": "m5",
-            "15m": "m15",
-            "30m": "m30",
-            "1h": "h1",
-            "4h": "h4",
-            "1d": "d1",
-            "1w": "w1",
-            "1mo": "mn1",
-        }
-
-        if value in aliases:
-            value = aliases[value]
-
-        for tf in cls:
-            if tf.label == value:
-                return tf
-
-        raise ValueError(
-            f"Timeframe inválido: {value}. "
-            f"Use: {', '.join(cls.valid_labels())}"
-        )
-
-    @classmethod
-    def valid_labels(cls):
-        """
-        Retorna lista de labels válidos.
-        """
-        return [tf.label for tf in cls]

mtcli_renko-1.1.0.dev2/mtcli_renko/models/renko_model.py

@@ -1,235 +0,0 @@
-"""
-Renko model institucional profissional.
-
-✔ Candle mode determinístico
-✔ Tick mode híbrido (confirmados + em formação)
-✔ Estrutura estável
-✔ Compatível com controller atual
-"""
-
-from dataclasses import dataclass
-from typing import List, Optional, NamedTuple
-from datetime import datetime
-
-import MetaTrader5 as mt5
-
-from mtcli.mt5_context import mt5_conexao
-from mtcli.logger import setup_logger
-from ..conf import SESSION_OPEN
-
-log = setup_logger(__name__)
-
-
-# ==========================================================
-# DATA STRUCTURES
-# ==========================================================
-
-@dataclass
-class RenkoBrick:
-    direction: str
-    open: float
-    close: float
-
-
-class RenkoResult(NamedTuple):
-    confirmados: List[RenkoBrick]
-    em_formacao: Optional[RenkoBrick]
-
-
-# ==========================================================
-# MODEL
-# ==========================================================
-
-class RenkoModel:
-
-    def __init__(self, symbol: str, brick_size: float):
-        self.symbol = symbol
-        self.brick_size = brick_size
-
-    # ======================================================
-    # AUXILIAR
-    # ======================================================
-
-    def _ultimo_pregao_data(self, timeframe):
-
-        ultimo = mt5.copy_rates_from_pos(
-            self.symbol,
-            timeframe,
-            0,
-            1,
-        )
-
-        if ultimo is None or len(ultimo) == 0:
-            return None
-
-        ultimo_time = datetime.fromtimestamp(ultimo[0]["time"])
-        return ultimo_time.date()
-
-    # ======================================================
-    # RATES (candle mode)
-    # ======================================================
-
-    def obter_rates(self, timeframe, quantidade: int, ancorar_abertura=False):
-
-        with mt5_conexao():
-
-            if not mt5.symbol_select(self.symbol, True):
-                raise RuntimeError(f"Erro ao selecionar símbolo {self.symbol}")
-
-            if not ancorar_abertura:
-
-                if quantidade == 0:
-                    quantidade = 1000
-
-                rates = mt5.copy_rates_from_pos(
-                    self.symbol,
-                    timeframe,
-                    0,
-                    quantidade,
-                )
-
-                return rates or []
-
-            data_pregao = self._ultimo_pregao_data(timeframe)
-
-            if data_pregao is None:
-                return []
-
-            bruto = mt5.copy_rates_from_pos(
-                self.symbol,
-                timeframe,
-                0,
-                5000,
-            )
-
-            if bruto is None or len(bruto) == 0:
-                return []
-
-            filtrado = []
-
-            for r in bruto:
-                r_time = datetime.fromtimestamp(r["time"])
-                if r_time.date() == data_pregao:
-                    filtrado.append(r)
-
-            if quantidade == 0:
-                return filtrado
-
-            return filtrado[-quantidade:]
-
-    # ======================================================
-    # TICKS
-    # ======================================================
-
-    def obter_ticks(self, timeframe, max_ticks=5000):
-
-        with mt5_conexao():
-
-            if not mt5.symbol_select(self.symbol, True):
-                raise RuntimeError(f"Erro ao selecionar símbolo {self.symbol}")
-
-            data_pregao = self._ultimo_pregao_data(timeframe)
-
-            if data_pregao is None:
-                return []
-
-            inicio = datetime.combine(
-                data_pregao,
-                datetime.strptime(SESSION_OPEN, "%H:%M").time(),
-            )
-
-            agora = datetime.now()
-
-            ticks = mt5.copy_ticks_range(
-                self.symbol,
-                inicio,
-                agora,
-                mt5.COPY_TICKS_ALL,
-            )
-
-            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]:
-
-        if rates is None or len(rates) < 2:
-            return []
-
-        bricks: List[RenkoBrick] = []
-        last_price = float(rates[0]["open"])
-
-        for rate in rates[1:]:
-
-            high = float(rate["high"])
-            low = float(rate["low"])
-
-            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 HÍBRIDO)
-    # ======================================================
-
-    def construir_renko_ticks(self, ticks) -> RenkoResult:
-
-        if ticks is None or len(ticks) < 2:
-            return RenkoResult([], None)
-
-        bricks: List[RenkoBrick] = []
-        last_price = float(ticks[0]["last"])
-
-        for tick in ticks[1:]:
-
-            price = float(tick["last"])
-
-            while price - last_price >= self.brick_size:
-                novo = last_price + self.brick_size
-                bricks.append(RenkoBrick("up", last_price, novo))
-                last_price = novo
-
-            while last_price - price >= self.brick_size:
-                novo = last_price - self.brick_size
-                bricks.append(RenkoBrick("down", last_price, novo))
-                last_price = novo
-
-        # ----------------------------
-        # 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

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