mtcli-range 1.0.0.dev1__tar.gz → 1.0.0.dev2__tar.gz

{mtcli_range-1.0.0.dev1 → mtcli_range-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mtcli-range
-Version: 1.0.0.dev1
+Version: 1.0.0.dev2
 Summary: Range bars  plugin para mtcli
 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.*)
 Project-URL: Documentation, https://vfranca.github.io/mtcli-range
 Project-URL: Homepage, https://github.com/vfranca/mtcli-range
 Project-URL: Issues, https://github.com/vfranca/mtcli-range/issues

{mtcli_range-1.0.0.dev1 → mtcli_range-1.0.0.dev2}/mtcli_range/conf.py

@@ -2,11 +2,7 @@
 Configuração do plugin mtcli-range.
 
 Lê parâmetros do arquivo mtcli.ini na seção [range].
-Permite definir valores padrão para:
-- símbolo
-- tamanho do range
-- timeframe base
-- quantidade de candles
+Também lê session_open da seção [renko] ou [range].
 """
 
 import configparser
@@ -22,20 +18,32 @@ SECTION = "range"
 
 
 def get_default_symbol() -> str:
-    """Retorna símbolo padrão do arquivo .ini."""
     return config.get(SECTION, "symbol", fallback="WIN$")
 
 
 def get_default_range() -> float:
-    """Retorna tamanho do range padrão."""
     return config.getfloat(SECTION, "range_size", fallback=50.0)
 
 
 def get_default_timeframe() -> str:
-    """Retorna timeframe base padrão."""
     return config.get(SECTION, "timeframe", fallback="m5")
 
 
 def get_default_bars() -> int:
-    """Retorna quantidade padrão de candles base."""
     return config.getint(SECTION, "bars", fallback=500)
+
+
+def get_session_open() -> str | None:
+    """
+    Retorna horário de abertura da sessão no formato HH:MM.
+    Busca:
+        1. [range]
+        2. [renko]
+    """
+    if config.has_option("range", "session_open"):
+        return config.get("range", "session_open")
+
+    if config.has_option("renko", "session_open"):
+        return config.get("renko", "session_open")
+
+    return None

mtcli_range-1.0.0.dev2/mtcli_range/range_controller.py

@@ -0,0 +1,115 @@
+"""
+Controller do plugin mtcli-range.
+
+Responsável por orquestrar:
+
+- Leitura de parâmetros da CLI
+- Conversão de timeframe via Enum central
+- Leitura de session_open do mtcli.ini
+- Conexão segura com MT5
+- Execução do Model
+- Renderização da View
+
+Mantém separação clara entre:
+    Model  -> cálculo dos blocos
+    View   -> exibição no terminal
+    Controller -> coordenação do fluxo
+"""
+
+from mtcli.mt5_context import mt5_conexao
+from mtcli.logger import setup_logger
+from mtcli.domain.timeframe import Timeframe
+
+from .range_model import RangeModel
+from .range_view import RangeView
+from .conf import get_session_open
+
+
+log = setup_logger("mtcli.range.controller")
+
+
+class RangeController:
+    """
+    Controlador principal do gráfico Range.
+
+    Parâmetros:
+        symbol (str): ativo
+        timeframe (str): timeframe textual (ex: m5, h1)
+        bars (int): quantidade de candles base
+        range_size (float): tamanho fixo do range
+        ancorar_abertura (bool): se True, ancora na abertura da sessão
+        numerar (bool): se True, numera as linhas exibidas
+    """
+
+    def __init__(
+        self,
+        symbol: str,
+        timeframe: str,
+        bars: int,
+        range_size: float,
+        ancorar_abertura: bool,
+        numerar: bool,
+    ):
+        self.symbol = symbol
+        self.timeframe = Timeframe.from_string(timeframe)
+        self.bars = bars
+        self.range_size = range_size
+        self.ancorar_abertura = ancorar_abertura
+        self.numerar = numerar
+
+    def executar(self):
+        """
+        Executa o fluxo completo:
+
+        1. Lê session_open do mtcli.ini
+        2. Abre conexão MT5
+        3. Instancia o Model
+        4. Gera blocos Range
+        5. Exibe resultado via View
+        """
+
+        log.info("Iniciando execução do mtcli-range.")
+
+        # 🔹 Lê horário de abertura de sessão do mtcli.ini
+        session_open = get_session_open()
+
+        if self.ancorar_abertura:
+            if session_open:
+                log.info(f"Ancoragem habilitada. session_open = {session_open}")
+            else:
+                log.warning(
+                    "Ancoragem solicitada, mas session_open não encontrado no mtcli.ini. "
+                    "Será usado o primeiro fechamento disponível."
+                )
+
+        try:
+            with mt5_conexao():
+
+                model = RangeModel(
+                    symbol=self.symbol,
+                    timeframe_const=self.timeframe.mt5_const,
+                    bars=self.bars,
+                    range_size=self.range_size,
+                    ancorar_abertura=self.ancorar_abertura,
+                    session_open=session_open,
+                )
+
+                blocos = model.gerar_range()
+
+        except Exception as e:
+            log.error(f"Erro durante execução do RangeController: {e}")
+            raise
+
+        # 🔹 Exibição fora do contexto MT5
+        RangeView.exibir_header(
+            symbol=self.symbol,
+            range_size=self.range_size,
+            ancorado=self.ancorar_abertura,
+        )
+
+        RangeView.exibir_blocos(
+            blocos=blocos,
+            numerar=self.numerar,
+        )
+
+        log.info("Execução do mtcli-range finalizada com sucesso.")

{mtcli_range-1.0.0.dev1 → mtcli_range-1.0.0.dev2}/mtcli_range/range_model.py

@@ -1,14 +1,13 @@
 """
 Model responsável pela geração dos blocos Range.
 
-O Range é baseado em movimentação de preço fixa (range_size).
-Um novo bloco é criado somente quando o preço se move
-range_size pontos acima ou abaixo do fechamento (ou abertura ancorada).
+Implementa ancoragem de sessão baseada em session_open.
 """
 
 from dataclasses import dataclass
 from typing import List
 import MetaTrader5 as mt5
+from datetime import datetime, time
 from mtcli.logger import setup_logger
 
 log = setup_logger("mtcli.range.model")
@@ -16,7 +15,6 @@ log = setup_logger("mtcli.range.model")
 
 @dataclass
 class RangeBlock:
-    """Representa um bloco de Range."""
     open: float
     close: float
     direction: str  # "UP" ou "DOWN"
@@ -27,6 +25,7 @@ class RangeModel:
     Responsável por:
     - Buscar dados no MT5
     - Calcular blocos de Range
+    - Aplicar ancoragem por abertura de sessão
     """
 
     def __init__(
@@ -36,15 +35,16 @@ class RangeModel:
         bars: int,
         range_size: float,
         ancorar_abertura: bool = False,
+        session_open: str | None = None,
     ):
         self.symbol = symbol
         self.timeframe_const = timeframe_const
         self.bars = bars
         self.range_size = range_size
         self.ancorar_abertura = ancorar_abertura
+        self.session_open = session_open
 
     def obter_candles(self):
-        """Obtém candles do MT5."""
         log.info(f"Buscando {self.bars} candles de {self.symbol}")
         rates = mt5.copy_rates_from_pos(
             self.symbol,
@@ -58,11 +58,32 @@ class RangeModel:
 
         return rates
 
-    def gerar_range(self) -> List[RangeBlock]:
+    def _obter_preco_ancora(self, rates):
         """
-        Constrói blocos de Range a partir dos candles base.
+        Retorna preço âncora baseado na abertura da sessão.
         """
 
+        if not self.session_open:
+            log.warning("session_open não configurado. Usando primeiro close.")
+            return rates[0]["close"]
+
+        hora_sessao = datetime.strptime(self.session_open, "%H:%M").time()
+
+        for candle in rates:
+            dt = datetime.fromtimestamp(candle["time"])
+            if dt.time() >= hora_sessao:
+                log.info(
+                    f"Âncora encontrada na sessão: "
+                    f"{dt.strftime('%Y-%m-%d %H:%M')} "
+                    f"preço abertura {candle['open']}"
+                )
+                return candle["open"]
+
+        log.warning("Sessão não encontrada nos candles carregados.")
+        return rates[0]["close"]
+
+    def gerar_range(self) -> List[RangeBlock]:
+
         rates = self.obter_candles()
 
         if len(rates) == 0:
@@ -70,15 +91,14 @@ class RangeModel:
 
         blocos: List[RangeBlock] = []
 
-        # 🔹 Âncora inicial
+        # 🔹 Âncora
         if self.ancorar_abertura:
-            ultimo_preco_base = rates[0]["open"]
-            log.info("Range ancorado na abertura do primeiro candle.")
+            ultimo_preco_base = self._obter_preco_ancora(rates)
         else:
             ultimo_preco_base = rates[0]["close"]
-            log.info("Range iniciado a partir do fechamento do primeiro candle.")
+            log.info("Range iniciado pelo primeiro fechamento.")
 
-        for candle in rates[1:]:
+        for candle in rates:
             preco = candle["close"]
 
             while abs(preco - ultimo_preco_base) >= self.range_size:
@@ -90,13 +110,14 @@ class RangeModel:
                     novo_close = ultimo_preco_base - self.range_size
                     direcao = "DOWN"
 
-                bloco = RangeBlock(
-                    open=ultimo_preco_base,
-                    close=novo_close,
-                    direction=direcao
+                blocos.append(
+                    RangeBlock(
+                        open=ultimo_preco_base,
+                        close=novo_close,
+                        direction=direcao
+                    )
                 )
 
-                blocos.append(bloco)
                 ultimo_preco_base = novo_close
 
         log.info(f"{len(blocos)} blocos de range gerados.")

{mtcli_range-1.0.0.dev1 → mtcli_range-1.0.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-range"
-version = "1.0.0.dev1"
+version = "1.0.0.dev2"
 description = "Range bars  plugin para mtcli"
 authors = [
     { name = "Valmir França", email = "vfranca3@gmail.com" }
@@ -33,7 +33,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "mtcli>=3.2.0",
+    "mtcli>=3.5.0.dev0,<3.6.0.dev0",
     "click>=8.3.0,<9.0.0",
     "metatrader5>=5.0.5370,<6.0.0"
 ]

mtcli_range-1.0.0.dev1/mtcli_range/range_controller.py

@@ -1,65 +0,0 @@
-"""
-Controller do plugin mtcli-range.
-
-Orquestra:
-- Conexão MT5
-- Model
-- View
-"""
-
-from mtcli.mt5_context import mt5_conexao
-from mtcli.logger import setup_logger
-from mtcli.domain.timeframe import Timeframe
-from .range_model import RangeModel
-from .range_view import RangeView
-
-log = setup_logger("mtcli.range.controller")
-
-
-class RangeController:
-    """
-    Controlador principal do fluxo.
-    """
-
-    def __init__(
-        self,
-        symbol: str,
-        timeframe: str,
-        bars: int,
-        range_size: float,
-        ancorar_abertura: bool,
-        numerar: bool,
-    ):
-        self.symbol = symbol
-        self.timeframe = Timeframe.from_string(timeframe)
-        self.bars = bars
-        self.range_size = range_size
-        self.ancorar_abertura = ancorar_abertura
-        self.numerar = numerar
-
-    def executar(self):
-        """
-        Executa o fluxo completo do gráfico Range.
-        """
-
-        with mt5_conexao():
-            model = RangeModel(
-                self.symbol,
-                self.timeframe.mt5_const,
-                self.bars,
-                self.range_size,
-                ancorar_abertura=self.ancorar_abertura,
-            )
-
-            blocos = model.gerar_range()
-
-        RangeView.exibir_header(
-            self.symbol,
-            self.range_size,
-            self.ancorar_abertura,
-        )
-
-        RangeView.exibir_blocos(
-            blocos,
-            numerar=self.numerar,
-        )