mtcli-volume 2.3.0.dev1__tar.gz → 2.4.0__tar.gz

{mtcli_volume-2.3.0.dev1 → mtcli_volume-2.4.0}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: mtcli-volume
-Version: 2.3.0.dev1
+Version: 2.4.0
 Summary: Plugin mtcli para exibir o volume profile
+License-File: LICENSE
 Author: Valmir França da Silva
 Author-email: vfranca3@gmail.com
 Requires-Python: >=3.10,<3.14.0

mtcli_volume-2.4.0/mtcli_volume/cli.py

@@ -0,0 +1,142 @@
+from datetime import datetime
+
+import click
+
+from .conf import (
+    FIM,
+    INICIO,
+    LIMIT,
+    PERIOD,
+    RANGE,
+    SYMBOL,
+    TIMEZONE,
+    VOLUME,
+)
+from .controller import calcular_volume_profile
+from .view import exibir_volume_profile
+
+
+@click.command(
+    help=(
+        "Exibe o Volume Profile distribuindo o volume dos candles "
+        "uniformemente entre as faixas de preço entre LOW e HIGH."
+    )
+)
+@click.version_option(package_name="mtcli-volume")
+@click.option(
+    "--symbol",
+    "-s",
+    default=SYMBOL,
+    show_default=True,
+    help="Símbolo do ativo.",
+)
+@click.option(
+    "--period",
+    "-p",
+    default=PERIOD,
+    show_default=True,
+    help="Timeframe utilizado no cálculo.",
+)
+@click.option(
+    "--limit",
+    "-l",
+    default=LIMIT,
+    show_default=True,
+    help="Quantidade de candles usados no cálculo.",
+)
+@click.option(
+    "--range",
+    "-r",
+    type=float,
+    default=RANGE,
+    show_default=True,
+    help="Tamanho da faixa de preço do Volume Profile.",
+)
+@click.option(
+    "--volume",
+    "-v",
+    type=click.Choice(["tick", "real"], case_sensitive=False),
+    default=VOLUME,
+    show_default=True,
+    help="Tipo de volume utilizado no cálculo.",
+)
+@click.option(
+    "--inicio",
+    "-i",
+    default=INICIO,
+    show_default=True,
+    help="Data/hora inicial (YYYY-MM-DD HH:MM).",
+)
+@click.option(
+    "--fim",
+    "-f",
+    default=FIM,
+    show_default=True,
+    help="Data/hora final (YYYY-MM-DD HH:MM).",
+)
+@click.option(
+    "--timezone",
+    "-tz",
+    type=str,
+    default=TIMEZONE,
+    show_default=True,
+    help="Fuso horário para exibição das datas.",
+)
+@click.option(
+    "--hvn-criterio",
+    type=click.Choice(["media", "percentil"], case_sensitive=False),
+    default="percentil",
+    show_default=True,
+    help="Critério para identificação de HVNs e LVNs.",
+)
+@click.option(
+    "--verbose",
+    "-vv",
+    is_flag=True,
+    help="Exibe informações detalhadas da análise.",
+)
+def volume(
+    symbol,
+    period,
+    limit,
+    range,
+    volume,
+    inicio,
+    fim,
+    timezone,
+    hvn_criterio,
+    verbose,
+):
+    """
+    Exibe o Volume Profile agrupando volumes por faixa de preço.
+
+    O volume de cada candle é distribuído igualmente entre todas
+    as faixas de preço tocadas entre o LOW e o HIGH do candle,
+    resultando em uma representação mais precisa da distribuição
+    de volume.
+    """
+    inicio_dt = (
+        datetime.strptime(inicio, "%Y-%m-%d %H:%M") if inicio else None
+    )
+    fim_dt = datetime.strptime(fim, "%Y-%m-%d %H:%M") if fim else None
+
+    profile, stats, info = calcular_volume_profile(
+        symbol=symbol,
+        period=period,
+        limit=limit,
+        step=range,
+        volume=volume,
+        inicio=inicio_dt,
+        fim=fim_dt,
+        verbose=verbose,
+        timezone_str=timezone,
+        criterio_hvn=hvn_criterio.lower(),
+    )
+
+    exibir_volume_profile(
+        profile=profile,
+        stats=stats,
+        symbol=symbol,
+        info=info,
+        verbose=verbose,
+    )

{mtcli_volume-2.3.0.dev1 → mtcli_volume-2.4.0}/mtcli_volume/conf.py

@@ -5,13 +5,12 @@ from mtcli.conf import config
 SYMBOL = os.getenv("SYMBOL", config["DEFAULT"].get("symbol", fallback="WIN$N"))
 DIGITOS = int(os.getenv("DIGITOS", config["DEFAULT"].getint("digitos", fallback=0)))
 PERIOD = os.getenv("PERIOD", config["DEFAULT"].get("period", fallback="M1"))
-PERIODOS = int(
-    os.getenv("PERIODOS", config["DEFAULT"].getint("periodos", fallback=566))
-)
+LIMIT = int(os.getenv("LIMIT", config["DEFAULT"].getint("limit", fallback=566)))
 RANGE = float(os.getenv("RANGE", config["DEFAULT"].getfloat("range", fallback=100)))
 VOLUME = os.getenv("VOLUME", config["DEFAULT"].get("volume", fallback="tick"))
-FROM = os.getenv("FROM", config["DEFAULT"].get("from", fallback=""))
-TO = os.getenv("TO", config["DEFAULT"].get("to", fallback=""))
+INICIO = os.getenv("INICIO", config["DEFAULT"].get("inicio", fallback=""))
+FIM = os.getenv("FIM", config["DEFAULT"].get("fim", fallback=""))
 TIMEZONE = os.getenv(
     "TIMEZONE", config["DEFAULT"].get("timezone", fallback="America/Sao_Paulo")
 )
+FORMAT = os.getenv("FORMAT", config["DEFAULT"].get("format", fallback="k"))

mtcli_volume-2.4.0/mtcli_volume/controller.py

@@ -0,0 +1,90 @@
+from datetime import datetime, timedelta, timezone
+import zoneinfo
+import numpy as np
+
+from mtcli.logger import setup_logger
+from .model import (
+    calcular_profile,
+    calcular_estatisticas,
+    obter_rates,
+)
+
+log = setup_logger()
+
+
+def calcular_volume_profile(
+    symbol,
+    period,
+    limit,
+    step,
+    volume,
+    inicio=None,
+    fim=None,
+    verbose=False,
+    timezone_str="America/Sao_Paulo",
+    criterio_hvn="media",
+):
+    """
+    Controla o fluxo de cálculo do Volume Profile.
+
+    - Obtém candles via MT5
+    - Calcula Volume Profile por faixa High–Low
+    - Calcula estatísticas (POC, VA, HVN, LVN)
+    """
+
+    volume = volume.lower().strip()
+    if volume not in ("tick", "real"):
+        raise ValueError("Tipo de volume inválido. Use 'tick' ou 'real'.")
+
+    rates = obter_rates(symbol, period, limit, inicio, fim)
+
+    # ✅ Correção crítica: validação correta para numpy.ndarray
+    if rates is None or not isinstance(rates, np.ndarray) or len(rates) == 0:
+        log.error("Nenhum dado retornado para o cálculo do Volume Profile.")
+        return {}, {}, {}
+
+    profile = calcular_profile(
+        rates=rates,
+        step=step,
+        volume_tipo=volume,
+    )
+
+    stats = calcular_estatisticas(
+        profile=profile,
+        criterio=criterio_hvn,
+    )
+
+    info = {}
+    try:
+        fuso = zoneinfo.ZoneInfo(timezone_str)
+    except Exception:
+        log.warning(
+            f"Fuso horário '{timezone_str}' inválido. Usando UTC−3 (Brasília)."
+        )
+        fuso = timezone(timedelta(hours=-3))
+
+    try:
+        inicio_real = (
+            datetime.utcfromtimestamp(float(rates[0]["time"]))
+            .astimezone(fuso)
+            .strftime("%Y-%m-%d %H:%M:%S")
+        )
+        fim_real = (
+            datetime.utcfromtimestamp(float(rates[-1]["time"]))
+            .astimezone(fuso)
+            .strftime("%Y-%m-%d %H:%M:%S")
+        )
+    except Exception as e:
+        log.error(f"Erro ao converter datas: {e}")
+        inicio_real = fim_real = "?"
+
+    info = {
+        "symbol": symbol,
+        "period": period,
+        "candles": len(rates),
+        "inicio": inicio_real,
+        "fim": fim_real,
+        "timezone": timezone_str,
+    }
+
+    return profile, stats, info

mtcli_volume-2.4.0/mtcli_volume/model.py

@@ -0,0 +1,161 @@
+from collections import defaultdict
+from collections.abc import Mapping
+from datetime import datetime
+
+import MetaTrader5 as mt5
+import numpy as np
+
+from mtcli.logger import setup_logger
+from mtcli.mt5_context import mt5_conexao
+from mtcli_volume.conf import DIGITOS
+
+log = setup_logger()
+
+
+def obter_rates(
+    symbol: str,
+    period: str,
+    bars: int,
+    data_inicio: datetime = None,
+    data_fim: datetime = None,
+):
+    """Obtém candles históricos do MetaTrader 5."""
+    with mt5_conexao():
+        tf = getattr(mt5, f"TIMEFRAME_{period.upper()}", None)
+        if tf is None:
+            log.error(f"Timeframe inválido: {period}")
+            return None
+
+        if not mt5.symbol_select(symbol, True):
+            log.error(f"Erro ao selecionar símbolo {symbol}")
+            return None
+
+        try:
+            if data_inicio and data_fim:
+                rates = mt5.copy_rates_range(symbol, tf, data_inicio, data_fim)
+            else:
+                rates = mt5.copy_rates_from_pos(symbol, tf, 0, bars)
+        except Exception as e:
+            log.error(f"Erro ao obter dados históricos: {e}")
+            return None
+
+        if rates is None or len(rates) == 0:
+            log.error("Nenhum dado retornado.")
+            return None
+
+    return rates
+
+
+def calcular_profile(
+    rates,
+    step: float,
+    volume_tipo: str = "tick",
+):
+    """
+    Calcula o Volume Profile distribuindo o volume do candle
+    uniformemente entre as faixas de preço entre LOW e HIGH.
+    """
+    profile = defaultdict(float)
+
+    for r in rates:
+        if isinstance(r, Mapping):
+            low = r["low"]
+            high = r["high"]
+            tick_volume = r["tick_volume"]
+            real_volume = r.get("real_volume", tick_volume)
+
+        elif isinstance(r, np.void):
+            low = float(r["low"])
+            high = float(r["high"])
+            tick_volume = int(r["tick_volume"])
+            real_volume = (
+                int(r["real_volume"]) if "real_volume" in r.dtype.names else tick_volume
+            )
+
+        else:
+            raise TypeError(f"Formato de rate desconhecido: {type(r)}")
+
+        volume = tick_volume if volume_tipo == "tick" else real_volume
+
+        if high < low:
+            low, high = high, low
+
+        faixa_inicio = round(low // step * step, DIGITOS)
+        faixa_fim = round(high // step * step, DIGITOS)
+
+        faixas = []
+        p = faixa_inicio
+        while p <= faixa_fim:
+            faixas.append(round(p, DIGITOS))
+            p += step
+
+        if not faixas:
+            continue
+
+        vol_por_faixa = volume / len(faixas)
+
+        for f in faixas:
+            profile[f] += vol_por_faixa
+
+    return dict(profile)
+
+
+def calcular_estatisticas(
+    profile: dict,
+    hvn_multiplicador: float = 1.5,
+    lvn_multiplicador: float = 0.5,
+    percentil_hvn: int = 80,
+    percentil_lvn: int = 20,
+    criterio: str = "media",
+):
+    """
+    Calcula POC, Área de Valor (70%) e HVNs/LVNs com critérios profissionais.
+    """
+    if not profile:
+        return {"poc": None, "area_valor": (None, None), "hvns": [], "lvns": []}
+
+    volumes = np.array(list(profile.values()))
+    faixas = np.array(list(profile.keys()))
+
+    idx_sorted = np.argsort(volumes)[::-1]
+    volumes_ord = volumes[idx_sorted]
+    faixas_ord = faixas[idx_sorted]
+
+    poc = faixas_ord[0]
+
+    total = volumes.sum()
+    acumulado = 0
+    area = []
+    for f, v in zip(faixas_ord, volumes_ord):
+        acumulado += v
+        area.append(f)
+        if acumulado >= total * 0.7:
+            break
+
+    area_valor = (min(area), max(area))
+
+    media = volumes.mean()
+
+    if criterio == "media":
+        hvns = sorted(
+            f for f, v in profile.items() if v >= media * hvn_multiplicador
+        )
+        lvns = sorted(
+            f for f, v in profile.items() if v <= media * lvn_multiplicador
+        )
+
+    elif criterio == "percentil":
+        p_hvn = np.percentile(volumes, percentil_hvn)
+        p_lvn = np.percentile(volumes, percentil_lvn)
+        hvns = sorted(f for f, v in profile.items() if v >= p_hvn)
+        lvns = sorted(f for f, v in profile.items() if v <= p_lvn)
+
+    else:
+        hvns, lvns = [], []
+
+    return {
+        "poc": poc,
+        "area_valor": area_valor,
+        "hvns": hvns,
+        "lvns": lvns,
+    }

{mtcli_volume-2.3.0.dev1 → mtcli_volume-2.4.0}/mtcli_volume/plugin.py

@@ -1,4 +1,4 @@
-from mtcli_volume.volume import volume
+from .cli import volume
 
 
 def register(cli):

mtcli_volume-2.4.0/mtcli_volume/view.py

@@ -0,0 +1,42 @@
+import click
+from .conf import DIGITOS as D
+
+
+def formatar_numero(valor: float) -> str:
+    return f"{valor:,.{D}f}".replace(",", ".")
+
+
+def exibir_volume_profile(profile, stats, symbol, info=None, verbose=False):
+    if not profile:
+        click.echo("Nenhum dado disponível.")
+        return
+
+    max_vol = max(profile.values())
+
+    if verbose and info:
+        click.echo("\nInformações da Análise")
+        for k, v in info.items():
+            click.echo(f"{k.capitalize():15}: {v}")
+
+    click.echo(f"\nVolume Profile — {symbol}\n")
+    click.echo("Preço           | Volume        | Distribuição")
+    click.echo("-" * 55)
+
+    for preco in sorted(profile.keys(), reverse=True):
+        vol = profile[preco]
+        perc = vol / max_vol * 100
+        click.echo(
+            f"{preco:>15.{D}f} | {formatar_numero(vol):>12} | {perc:5.0f}%"
+        )
+
+    # click.echo("\nEstatísticas")
+    click.echo(f"POC             {stats['poc']:.{D}f}")
+    click.echo(
+        f"VA    {stats['area_valor'][0]:.{D}f} → {stats['area_valor'][1]:.{D}f}"
+    )
+    click.echo(
+        f"HVNs            {', '.join(f'{x:.{D}f}' for x in stats['hvns']) or 'Nenhum'}"
+    )
+    click.echo(
+        f"LVNs            {', '.join(f'{x:.{D}f}' for x in stats['lvns']) or 'Nenhum'}"
+    )

{mtcli_volume-2.3.0.dev1 → mtcli_volume-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mtcli-volume"
-version = "2.3.0.dev1"
+version = "2.4.0"
 description = "Plugin mtcli para exibir o volume profile"
 authors = [
     {name = "Valmir França da Silva",email = "vfranca3@gmail.com"}

mtcli_volume-2.3.0.dev1/mtcli_volume/controllers/volume_controller.py

@@ -1,83 +0,0 @@
-from datetime import datetime, timedelta, timezone
-import zoneinfo  # Python 3.9+
-
-import numpy as np
-
-from mtcli.logger import setup_logger
-from mtcli_volume.models.volume_model import (
-    calcular_estatisticas,
-    calcular_profile,
-    obter_rates,
-)
-
-log = setup_logger()
-
-
-def calcular_volume_profile(
-    symbol,
-    period,
-    bars,
-    step,
-    volume,
-    data_inicio=None,
-    data_fim=None,
-    verbose=False,
-    timezone_str="America/Sao_Paulo",
-):
-    """Controla o fluxo de cálculo do volume profile, com suporte a timezone configurável."""
-    volume = volume.lower().strip()
-    if volume not in ["tick", "real"]:
-        log.error(f"Tipo de volume inválido: {volume}. Use 'tick' ou 'real'.")
-        raise ValueError(f"Tipo de volume inválido: {volume}. Use 'tick' ou 'real'.")
-
-    rates = obter_rates(symbol, period, bars, data_inicio, data_fim)
-
-    if rates is None or len(rates) == 0:
-        log.error("Falha ao obter dados de preços para cálculo do volume profile.")
-        return {}, {}, {}
-
-    profile = calcular_profile(rates, step, volume)
-    stats = calcular_estatisticas(profile)
-
-    # Captura de informações de contexto
-    info = {}
-    if isinstance(rates, np.ndarray) and len(rates) > 0:
-        primeiro = rates[0]
-        ultimo = rates[-1]
-        if "time" in rates.dtype.names:
-            try:
-                # Define fuso horário desejado
-                try:
-                    fuso = zoneinfo.ZoneInfo(timezone_str)
-                except Exception:
-                    log.warning(
-                        f"Fuso horário '{timezone_str}' inválido. Usando UTC−3 (Brasília)."
-                    )
-                    fuso = timezone(timedelta(hours=-3))
-
-                inicio_real = (
-                    datetime.utcfromtimestamp(float(primeiro["time"]))
-                    .astimezone(fuso)
-                    .strftime("%Y-%m-%d %H:%M:%S")
-                )
-                fim_real = (
-                    datetime.utcfromtimestamp(float(ultimo["time"]))
-                    .astimezone(fuso)
-                    .strftime("%Y-%m-%d %H:%M:%S")
-                )
-            except Exception as e:
-                log.error(f"Erro ao converter timezone: {e}")
-                inicio_real = fim_real = "?"
-        else:
-            inicio_real = fim_real = "?"
-
-        info = {
-            "symbol": symbol,
-            "period": period,
-            "candles": len(rates),
-            "inicio": inicio_real,
-            "fim": fim_real,
-            "timezone": timezone_str,
-        }
-
-    return profile, stats, info

mtcli_volume-2.3.0.dev1/mtcli_volume/models/volume_model.py

@@ -1,129 +0,0 @@
-from collections import defaultdict
-from collections.abc import Mapping
-from datetime import datetime
-
-import MetaTrader5 as mt5
-import numpy as np
-
-from mtcli.logger import setup_logger
-from mtcli.mt5_context import mt5_conexao
-from mtcli_volume.conf import DIGITOS
-
-log = setup_logger()
-
-
-def obter_rates(
-    symbol: str,
-    period: str,
-    bars: int,
-    data_inicio: datetime = None,
-    data_fim: datetime = None,
-):
-    """Obtém dados históricos via MetaTrader 5, podendo filtrar por intervalo de tempo."""
-    with mt5_conexao():
-        tf = getattr(mt5, f"TIMEFRAME_{period.upper()}", None)
-        if tf is None:
-            log.error(f"Timeframe inválido: {period}")
-            return None
-
-        if not mt5.symbol_select(symbol, True):
-            log.error(f"Erro ao selecionar símbolo {symbol}")
-            return None
-
-        try:
-            if data_inicio and data_fim:
-                log.debug(
-                    f"Obtendo candles de {symbol} entre {data_inicio} e {data_fim}"
-                )
-                rates = mt5.copy_rates_range(symbol, tf, data_inicio, data_fim)
-            else:
-                log.debug(f"Obtendo {bars} candles de {symbol} a partir da posição 0")
-                rates = mt5.copy_rates_from_pos(symbol, tf, 0, bars)
-        except Exception as e:
-            log.error(f"Erro ao obter dados históricos: {e}")
-            return None
-
-        # ✅ Correção para arrays NumPy
-        if rates is None or len(rates) == 0:
-            log.error("Nenhum dado retornado.")
-            return None
-
-    return rates
-
-
-def calcular_profile(
-    rates: list[dict | tuple | object],
-    step: float,
-    volume: str = "tick",
-) -> dict[float, float]:
-    """Calcula o volume total por faixa de preço, suportando dicionários, numpy.void, objetos ou tuplas."""
-    profile = defaultdict(int)
-
-    for r in rates:
-        # --- 1️⃣ Dict comum ---
-        if isinstance(r, Mapping):
-            preco = r["close"]
-            tick_volume = r["tick_volume"]
-            real_volume = r.get("real_volume", tick_volume)
-
-        # --- 2️⃣ numpy.void (estrutura MT5) ---
-        elif isinstance(r, np.void):
-            preco = float(r["close"])
-            tick_volume = int(r["tick_volume"])
-            # real_volume pode não existir dependendo da corretora
-            real_volume = (
-                int(r["real_volume"]) if "real_volume" in r.dtype.names else tick_volume
-            )
-
-        # --- 3️⃣ Objeto com atributos (ex: namedtuple) ---
-        elif hasattr(r, "close"):
-            preco = r.close
-            tick_volume = r.tick_volume
-            real_volume = getattr(r, "real_volume", tick_volume)
-
-        # --- 4️⃣ Tupla/lista ---
-        elif isinstance(r, (tuple, list)) and len(r) >= 6:
-            preco = r[4]
-            tick_volume = r[5]
-            real_volume = r[6] if len(r) > 6 else tick_volume
-
-        else:
-            raise TypeError(f"Formato de rate desconhecido: {type(r)}")
-
-        faixa = round(round(preco / step) * step, DIGITOS)
-        profile[faixa] += tick_volume if volume == "tick" else real_volume
-
-    return dict(profile)
-
-
-def calcular_estatisticas(profile):
-    """Calcula POC, área de valor (70%), HVNs e LVNs."""
-    if not profile:
-        return {"poc": None, "area_valor": (None, None), "hvns": [], "lvns": []}
-
-    # Ordena as faixas de preço por volume (desc)
-    volumes_ordenados = sorted(profile.items(), key=lambda x: x[1], reverse=True)
-    poc = volumes_ordenados[0][0]
-
-    # Cálculo da área de valor (70%)
-    total_volume = sum(profile.values())
-    acumulado = 0
-    faixas_area_valor = []
-    for faixa, vol in volumes_ordenados:
-        acumulado += vol
-        faixas_area_valor.append(faixa)
-        if acumulado >= total_volume * 0.7:
-            break
-    area_valor = (min(faixas_area_valor), max(faixas_area_valor))
-
-    # HVNs e LVNs
-    media = total_volume / len(profile)
-    hvns = sorted([faixa for faixa, vol in profile.items() if vol >= media * 1.5])
-    lvns = sorted([faixa for faixa, vol in profile.items() if vol <= media * 0.5])
-
-    return {
-        "poc": poc,
-        "area_valor": area_valor,
-        "hvns": hvns,
-        "lvns": lvns,
-    }

mtcli_volume-2.3.0.dev1/mtcli_volume/views/volume_view.py

@@ -1,69 +0,0 @@
-import click
-
-from mtcli_volume.conf import DIGITOS
-
-BARRA_CHAR = "#"
-
-
-def exibir_volume_profile(profile, stats, symbol, info=None, verbose=False):
-    """Exibe o volume profile no terminal de forma acessível e organizada."""
-    if not profile:
-        click.echo(f"Nenhum dado disponível para {symbol}")
-        return
-
-    # ──────────────────────────────────────────────
-    # BLOCO VERBOSO: exibe detalhes da análise
-    # ──────────────────────────────────────────────
-    if verbose and info:
-        click.echo("\n=== Informações da Análise ===")
-        linhas = [
-            ("Símbolo", info.get("symbol", "?")),
-            ("Timeframe", info.get("period", "?").upper()),
-            ("Candles analisados", str(info.get("candles", "?"))),
-            (
-                "Período analisado",
-                f"{info.get('inicio', '?')} → {info.get('fim', '?')}",
-            ),
-            ("Fuso horário", info.get("timezone", "Desconhecido")),
-        ]
-        largura_esq = max(len(t[0]) for t in linhas) + 2
-        for chave, valor in linhas:
-            click.echo(f"{chave:<{largura_esq}}: {valor}")
-        click.echo("=" * (largura_esq + 30))
-
-    # ──────────────────────────────────────────────
-    # BLOCO PRINCIPAL: Volume Profile
-    # ──────────────────────────────────────────────
-    dados_ordenados = sorted(profile.items(), reverse=True)
-    click.echo(f"\nVolume Profile — {symbol}\n")
-
-    max_vol = max(profile.values())
-    largura_preco = max(len(f"{p:.{DIGITOS}f}") for p in profile.keys())
-
-    # Cabeçalho
-    click.echo(f"{'Preço':>{largura_preco}} | Volume | Distribuição")
-    click.echo("-" * (largura_preco + 32))
-
-    # Corpo da tabela
-    for preco, vol in dados_ordenados:
-        barra_len = int(vol / max_vol * 50)
-        barra = BARRA_CHAR * barra_len
-        click.echo(f"{preco:>{largura_preco}.{DIGITOS}f} | {vol:>6} | {barra}")
-
-    # ──────────────────────────────────────────────
-    # BLOCO FINAL: Estatísticas
-    # ──────────────────────────────────────────────
-    click.echo("\n=== Estatísticas ===")
-    if stats.get("poc") is not None:
-        click.echo(f"POC              {stats['poc']:.{DIGITOS}f}")
-        click.echo(
-            f"VA {stats['area_valor'][0]:.{DIGITOS}f} a {stats['area_valor'][1]:.{DIGITOS}f}"
-        )
-        click.echo(
-            f"HVNs {', '.join(map(lambda x: f'{x:.{DIGITOS}f}', stats['hvns'])) or 'Nenhum'}"
-        )
-        click.echo(
-            f"LVNs {', '.join(map(lambda x: f'{x:.{DIGITOS}f}', stats['lvns'])) or 'Nenhum'}"
-        )
-    else:
-        click.echo("Estatísticas indisponíveis (dados insuficientes).")

mtcli_volume-2.3.0.dev1/mtcli_volume/volume.py

@@ -1,97 +0,0 @@
-from datetime import datetime
-
-import click
-
-from mtcli_volume.conf import (
-    FROM,
-    PERIOD,
-    PERIODOS,
-    RANGE,
-    SYMBOL,
-    TIMEZONE,
-    TO,
-    VOLUME,
-)
-from mtcli_volume.controllers.volume_controller import calcular_volume_profile
-from mtcli_volume.views.volume_view import exibir_volume_profile
-
-
-@click.command(
-    help="Exibe o Volume Profile, agrupando volumes por faixa de preço no histórico recente."
-)
-@click.version_option(package_name="mtcli-volume")
-@click.option(
-    "--symbol", "-s", default=SYMBOL, show_default=True, help="Símbolo do ativo."
-)
-@click.option(
-    "--period",
-    "-p",
-    default=PERIOD,
-    show_default=True,
-    help="Período do volume.",
-)
-@click.option(
-    "--periodos",
-    "-po",
-    "bars",
-    default=PERIODOS,
-    show_default=True,
-    help="Quantidade de períodos.",
-)
-@click.option(
-    "--range",
-    "-r",
-    "step",
-    type=float,
-    default=RANGE,
-    show_default=True,
-    help="Tamanho do agrupamento de preços.",
-)
-@click.option(
-    "--volume",
-    "-v",
-    default=VOLUME,
-    show_default=True,
-    help="Tipo de volume (tick ou real).",
-)
-@click.option(
-    "--from",
-    "data_inicio",
-    type=str,
-    default=FROM,
-    show_default=True,
-    help="Data/hora inicial (YYYY-MM-DD HH:MM).",
-)
-@click.option(
-    "--to",
-    "data_fim",
-    type=str,
-    default=TO,
-    show_default=True,
-    help="Data/hora final (YYYY-MM-DD HH:MM).",
-)
-@click.option(
-    "--verbose",
-    "-vv",
-    is_flag=True,
-    help="Mostra informações detalhadas sobre a análise.",
-)
-@click.option(
-    "--timezone",
-    "-tz",
-    type=str,
-    default=TIMEZONE,
-    show_default=True,
-    help="Fuso horário para exibição das datas (ex: 'UTC', 'America/Sao_Paulo').",
-)
-def volume(
-    symbol, period, bars, step, volume, data_inicio, data_fim, verbose, timezone
-):
-    """Exibe o Volume Profile agrupando volumes por faixa de preço."""
-    inicio = datetime.strptime(data_inicio, "%Y-%m-%d %H:%M") if data_inicio else None
-    fim = datetime.strptime(data_fim, "%Y-%m-%d %H:%M") if data_fim else None
-
-    profile, stats, info = calcular_volume_profile(
-        symbol, period, bars, step, volume, inicio, fim, verbose, timezone
-    )
-    exibir_volume_profile(profile, stats, symbol, info, verbose)