mtcli-renko 1.2.0.dev0__tar.gz → 1.2.0.dev1__tar.gz

{mtcli_renko-1.2.0.dev0 → mtcli_renko-1.2.0.dev1}/PKG-INFO

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

{mtcli_renko-1.2.0.dev0 → mtcli_renko-1.2.0.dev1}/mtcli_renko/models/renko_model.py

@@ -1,354 +1,354 @@
-"""
-RenkoModel profissional.
-
-Candle mode determinístico
-Tick mode híbrido (confirmados + em formação)
-Ancoragem correta na abertura da B3
-Ajuste UTC da corretora
-Margem de segurança na abertura
-Reconstrução de caminho do candle (path reconstruction)
-Compatível com controller atual
-Funciona mesmo com mercado fechado
-"""
-
-from dataclasses import dataclass
-from typing import List, Optional, NamedTuple
-from datetime import datetime, time as dtime, timedelta
-
-import MetaTrader5 as mt5
-
-from mtcli.mt5_context import mt5_conexao
-from mtcli.logger import setup_logger
-from ..marketdata.tick_repository import TickRepository
-from ..conf import SESSION_OPEN, SESSION_OPEN_OFFSET_SECONDS, BROKER_UTC_OFFSET
-
-log = setup_logger(__name__)
-
-
-# ==========================================================
-# DATA STRUCTURES
-# ==========================================================
-
-@dataclass
-class Brick:
-    direction: str
-    open: float
-    close: float
-    volume: float = 0
-    ticks: int = 0
-
-
-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()
-
-    # ======================================================
-    # UTIL
-    # ======================================================
-
-    def _session_start_timestamp(self, data):
-
-        abertura_b3 = datetime.combine(
-            data,
-            dtime.fromisoformat(SESSION_OPEN),
-        )
-
-        abertura_utc = abertura_b3 + timedelta(hours=BROKER_UTC_OFFSET)
-
-        abertura_utc += timedelta(seconds=SESSION_OPEN_OFFSET_SECONDS)
-
-        return int(abertura_utc.timestamp())
-
-    # ======================================================
-    # 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
-
-        ultimo_ts = int(rates[-1]["time"])
-
-        ultimo_dia = datetime.utcfromtimestamp(ultimo_ts).date()
-
-        abertura_ts = self._session_start_timestamp(ultimo_dia)
-
-        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):
-
-        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.utcnow().timestamp())
-
-        if ancorar_abertura:
-
-            data = datetime.utcfromtimestamp(last_time).date()
-
-            start_ts = self._session_start_timestamp(data)
-
-        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:]
-
-    # ======================================================
-    # PATH RECONSTRUCTION
-    # ======================================================
-
-    def _reconstruir_path(self, rate):
-
-        o = float(rate["open"])
-        h = float(rate["high"])
-        l = float(rate["low"])
-        c = float(rate["close"])
-
-        if c >= o:
-            return [o, l, h, c]
-
-        return [o, h, l, c]
-
-    # ======================================================
-    # RENKO CANDLE
-    # ======================================================
-
-    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"])
-        last_direction: Optional[str] = None
-
-        for rate in rates[1:]:
-
-            path = self._reconstruir_path(rate)
-
-            for price in path:
-
-                # =============================
-                # movimento de alta
-                # =============================
-
-                while price - last_price >= self.brick_size:
-
-                    # regra reversão clássica
-                    if modo == "classico" and last_direction == "down":
-
-                        if price - last_price < self.brick_size * 2:
-                            break
-
-                        last_price += self.brick_size
-
-                    novo = last_price + self.brick_size
-
-                    bricks.append(
-                        Brick("up", last_price, novo)
-                    )
-
-                    last_price = novo
-                    last_direction = "up"
-
-                # =============================
-                # movimento de baixa
-                # =============================
-
-                while last_price - price >= self.brick_size:
-
-                    if modo == "classico" and last_direction == "up":
-
-                        if last_price - price < self.brick_size * 2:
-                            break
-
-                        last_price -= self.brick_size
-
-                    novo = last_price - self.brick_size
-
-                    bricks.append(
-                        Brick("down", last_price, novo)
-                    )
-
-                    last_price = novo
-                    last_direction = "down"
-
-        return bricks
-
-    # ======================================================
-    # RENKO TICK MODE
-    # ======================================================
-
-    def construir_renko_ticks(self, ticks, modo="simples") -> RenkoTickResult:
-
-        if ticks is None or len(ticks) < 2:
-            return RenkoTickResult([], None)
-
-        bricks: List[Brick] = []
-
-        last_price = float(ticks[0][3])
-        last_direction: Optional[str] = None
-        volume_acumulado = 0
-        ticks_acumulados = 0
-
-        for tick in ticks[1:]:
-
-            price = float(tick[3])
-            volume = float(tick[4])
-
-            volume_acumulado += volume
-            ticks_acumulados += 1
-
-            # =============================
-            # movimento de alta
-            # =============================
-
-            while price - last_price >= self.brick_size:
-
-                if modo == "classico" and last_direction == "down":
-
-                    if price - last_price < self.brick_size * 2:
-                        break
-
-                    last_price += self.brick_size
-
-                novo = last_price + self.brick_size
-
-                bricks.append(
-                    Brick(
-                        direction="up",
-                        open=last_price,
-                        close=novo,
-                        volume=volume_acumulado,
-                        ticks=ticks_acumulados,
-                    )
-                )
-
-                volume_acumulado = 0
-                ticks_acumulados = 0
-                last_price = novo
-                last_direction = "up"
-
-            # =============================
-            # movimento de baixa
-            # =============================
-
-            while last_price - price >= self.brick_size:
-
-                if modo == "classico" and last_direction == "up":
-
-                    if last_price - price < self.brick_size * 2:
-                        break
-
-                    last_price -= self.brick_size
-
-                novo = last_price - self.brick_size
-
-                bricks.append(
-                    Brick(
-                        direction="down",
-                        open=last_price,
-                        close=novo,
-                        volume=volume_acumulado,
-                        ticks=ticks_acumulados,
-                    )
-                )
-
-                volume_acumulado = 0
-                ticks_acumulados = 0
-                last_price = novo
-                last_direction = "down"
-
-        # =================================
-        # 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,
-                volume=volume_acumulado,
-                ticks=ticks_acumulados,
-            )
-
-        return RenkoTickResult(
-            confirmados=bricks,
-            em_formacao=em_formacao,
-        )
+"""
+RenkoModel profissional.
+
+Candle mode determinístico
+Tick mode híbrido (confirmados + em formação)
+Ancoragem correta na abertura da B3
+Ajuste UTC da corretora
+Margem de segurança na abertura
+Reconstrução de caminho do candle (path reconstruction)
+Compatível com controller atual
+Funciona mesmo com mercado fechado
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, NamedTuple
+from datetime import datetime, time as dtime, timedelta
+
+import MetaTrader5 as mt5
+
+from mtcli.mt5_context import mt5_conexao
+from mtcli.logger import setup_logger
+from ..marketdata.tick_repository import TickRepository
+from ..conf import SESSION_OPEN, SESSION_OPEN_OFFSET_SECONDS, BROKER_UTC_OFFSET
+
+log = setup_logger(__name__)
+
+
+# ==========================================================
+# DATA STRUCTURES
+# ==========================================================
+
+@dataclass
+class Brick:
+    direction: str
+    open: float
+    close: float
+    volume: float = 0
+    ticks: int = 0
+
+
+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()
+
+    # ======================================================
+    # UTIL
+    # ======================================================
+
+    def _session_start_timestamp(self, data):
+
+        abertura_b3 = datetime.combine(
+            data,
+            dtime.fromisoformat(SESSION_OPEN),
+        )
+
+        abertura_utc = abertura_b3 + timedelta(hours=BROKER_UTC_OFFSET)
+
+        abertura_utc += timedelta(seconds=SESSION_OPEN_OFFSET_SECONDS)
+
+        return int(abertura_utc.timestamp())
+
+    # ======================================================
+    # 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
+
+        ultimo_ts = int(rates[-1]["time"])
+
+        ultimo_dia = datetime.utcfromtimestamp(ultimo_ts).date()
+
+        abertura_ts = self._session_start_timestamp(ultimo_dia)
+
+        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):
+
+        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.utcnow().timestamp())
+
+        if ancorar_abertura:
+
+            data = datetime.utcfromtimestamp(last_time).date()
+
+            start_ts = self._session_start_timestamp(data)
+
+        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:]
+
+    # ======================================================
+    # PATH RECONSTRUCTION
+    # ======================================================
+
+    def _reconstruir_path(self, rate):
+
+        o = float(rate["open"])
+        h = float(rate["high"])
+        l = float(rate["low"])
+        c = float(rate["close"])
+
+        if c >= o:
+            return [o, l, h, c]
+
+        return [o, h, l, c]
+
+    # ======================================================
+    # RENKO CANDLE
+    # ======================================================
+
+    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"])
+        last_direction: Optional[str] = None
+
+        for rate in rates[1:]:
+
+            path = self._reconstruir_path(rate)
+
+            for price in path:
+
+                # =============================
+                # movimento de alta
+                # =============================
+
+                while price - last_price >= self.brick_size:
+
+                    # regra reversão clássica
+                    if modo == "classico" and last_direction == "down":
+
+                        if price - last_price < self.brick_size * 2:
+                            break
+
+                        last_price += self.brick_size
+
+                    novo = last_price + self.brick_size
+
+                    bricks.append(
+                        Brick("up", last_price, novo)
+                    )
+
+                    last_price = novo
+                    last_direction = "up"
+
+                # =============================
+                # movimento de baixa
+                # =============================
+
+                while last_price - price >= self.brick_size:
+
+                    if modo == "classico" and last_direction == "up":
+
+                        if last_price - price < self.brick_size * 2:
+                            break
+
+                        last_price -= self.brick_size
+
+                    novo = last_price - self.brick_size
+
+                    bricks.append(
+                        Brick("down", last_price, novo)
+                    )
+
+                    last_price = novo
+                    last_direction = "down"
+
+        return bricks
+
+    # ======================================================
+    # RENKO TICK MODE
+    # ======================================================
+
+    def construir_renko_ticks(self, ticks, modo="simples") -> RenkoTickResult:
+
+        if ticks is None or len(ticks) < 2:
+            return RenkoTickResult([], None)
+
+        bricks: List[Brick] = []
+
+        last_price = float(ticks[0][3])
+        last_direction: Optional[str] = None
+        volume_acumulado = 0
+        ticks_acumulados = 0
+
+        for tick in ticks[1:]:
+
+            price = float(tick[3])
+            volume = float(tick[4])
+
+            volume_acumulado += volume
+            ticks_acumulados += 1
+
+            # =============================
+            # movimento de alta
+            # =============================
+
+            while price - last_price >= self.brick_size:
+
+                if modo == "classico" and last_direction == "down":
+
+                    if price - last_price < self.brick_size * 2:
+                        break
+
+                    last_price += self.brick_size
+
+                novo = last_price + self.brick_size
+
+                bricks.append(
+                    Brick(
+                        direction="up",
+                        open=last_price,
+                        close=novo,
+                        volume=volume_acumulado,
+                        ticks=ticks_acumulados,
+                    )
+                )
+
+                volume_acumulado = 0
+                ticks_acumulados = 0
+                last_price = novo
+                last_direction = "up"
+
+            # =============================
+            # movimento de baixa
+            # =============================
+
+            while last_price - price >= self.brick_size:
+
+                if modo == "classico" and last_direction == "up":
+
+                    if last_price - price < self.brick_size * 2:
+                        break
+
+                    last_price -= self.brick_size
+
+                novo = last_price - self.brick_size
+
+                bricks.append(
+                    Brick(
+                        direction="down",
+                        open=last_price,
+                        close=novo,
+                        volume=volume_acumulado,
+                        ticks=ticks_acumulados,
+                    )
+                )
+
+                volume_acumulado = 0
+                ticks_acumulados = 0
+                last_price = novo
+                last_direction = "down"
+
+        # =================================
+        # 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,
+                volume=volume_acumulado,
+                ticks=ticks_acumulados,
+            )
+
+        return RenkoTickResult(
+            confirmados=bricks,
+            em_formacao=em_formacao,
+        )

{mtcli_renko-1.2.0.dev0 → mtcli_renko-1.2.0.dev1}/mtcli_renko/views/renko_view.py

@@ -156,7 +156,7 @@ def exibir_renko(resultado, numerar=False):
     # BLOCOS CONFIRMADOS
     # ------------------------------------------------------
 
-    click.echo("Direcao Volume Abertura Fechamento")
+    click.echo("Direcao Abertura Fechamento Volume")
 
     for i, brick in enumerate(bricks, start=1):
 
@@ -168,16 +168,16 @@ def exibir_renko(resultado, numerar=False):
         if numerar:
             linha = (
                 f"{i} {simbolo} "
-                f"{brick.volume:.0f} "
                 f"{brick.open:.{DIGITS}f} "
-                f"{brick.close:.{DIGITS}f}"
+                f"{brick.close:.{DIGITS}f} "
+                f"{brick.volume:.0f}"
             )
         else:
             linha = (
                 f"{simbolo} "
-                f"{brick.volume:.0f} "
                 f"{brick.open:.{DIGITS}f} "
-                f"{brick.close:.{DIGITS}f}"
+                f"{brick.close:.{DIGITS}f} "
+                f"{brick.volume:.0f}"
             )
 
         click.echo(linha)
@@ -197,9 +197,9 @@ def exibir_renko(resultado, numerar=False):
 
         linha = (
             f"FORMANDO {simbolo} "
-            f"{em_formacao.volume:.0f} "
             f"{em_formacao.open:.{DIGITS}f} "
-            f"{em_formacao.close:.{DIGITS}f}"
+            f"{em_formacao.close:.{DIGITS}f} "
+            f"{em_formacao.volume:.0f}"
         )
 
         click.echo(linha)

{mtcli_renko-1.2.0.dev0 → mtcli_renko-1.2.0.dev1}/pyproject.toml

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