csv-mean-filter 0.1.0__tar.gz

csv_mean_filter-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Ruflo local secrets and runtime data
+.env
+.env.local
+.env.*.local
+.claude-flow/data/
+.claude-flow/logs/
+.claude-flow/sessions/
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+
+# Ruflo / Claude Code (ferramentas locais)
+.claude/
+.claude-flow/
+.swarm/
+.mcp.json
+CLAUDE.md
+iniciar_ruflo.bat

csv_mean_filter-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jjuffagtotal-source
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

csv_mean_filter-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.5
+Name: csv-mean-filter
+Version: 0.1.0
+Summary: CLI em Python para calcular a média de colunas CSV com filtros dinâmicos, zero dependências e 36 testes unitários.
+Author: jjuffagtotal-source
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# analise
+
+Script de linha de comando em Python que lê um arquivo CSV e calcula a média de uma coluna numérica, com filtro opcional por valor de outra coluna.
+
+## Funcionalidades
+
+- Calcula a média de qualquer coluna numérica de um CSV com cabeçalho.
+- Filtro opcional `--filtrar-coluna COLUNA=VALOR` para considerar só as linhas que batem com o valor.
+- Ignora células vazias.
+- Lê CSVs gravados pelo Excel (UTF-8 com BOM).
+- Mensagens de erro claras e códigos de saída previsíveis.
+- Usa apenas a biblioteca padrão: nenhuma dependência externa.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+
+## Instalação
+
+Não há pacotes para instalar. Basta clonar o repositório:
+
+```bash
+git clone <url-do-repositorio>
+cd <pasta-do-repositorio>
+```
+
+## Instalação via pip
+
+O projeto também pode ser instalado como pacote, o que disponibiliza o comando `csv-mean` no terminal. Na raiz do repositório:
+
+```bash
+pip install .
+```
+
+Futuramente, quando o pacote estiver publicado no PyPI:
+
+```bash
+pip install csv-mean-filter
+```
+
+Depois de instalado, use `csv-mean` no lugar de `python src/analise.py`:
+
+```bash
+$ csv-mean dados.csv salario --filtrar-coluna idade=30
+1500.0
+```
+
+Recomenda-se instalar dentro de um ambiente virtual (`python -m venv .venv`).
+
+## Uso
+
+```bash
+python src/analise.py ARQUIVO COLUNA [--filtrar-coluna COLUNA=VALOR]
+```
+
+### Exemplos
+
+Dado o arquivo `dados.csv`:
+
+```csv
+nome,idade,salario
+Ana,30,1000
+Bia,25,3000
+Caio,30,2000
+```
+
+Média de uma coluna:
+
+```bash
+$ python src/analise.py dados.csv salario
+2000.0
+```
+
+Média só das linhas em que `idade` é `30`:
+
+```bash
+$ python src/analise.py dados.csv salario --filtrar-coluna idade=30
+1500.0
+```
+
+### Regras do filtro
+
+- O formato é `coluna=valor`. A divisão acontece no primeiro `=`, então `obs=a=b` filtra a coluna `obs` pelo valor `a=b`.
+- A comparação é exata e diferencia maiúsculas de minúsculas, após remover espaços nas pontas. `30` não bate com `30.0`.
+- `coluna=` (valor vazio) seleciona as linhas em que a coluna está vazia.
+- Valores não numéricos em linhas que não batem com o filtro são ignorados.
+
+### Códigos de saída
+
+| Código | Situação |
+|--------|----------|
+| `0` | Sucesso: a média é impressa na saída padrão. |
+| `1` | Arquivo inexistente, coluna inexistente, valor não numérico ou nenhum valor numérico (mensagem `Erro: ...` na saída de erro). |
+| `2` | Argumentos inválidos, como um filtro sem `=` (`use o formato coluna=valor`). |
+
+### Uso como módulo
+
+Com a pasta `src/` no `PYTHONPATH` (ou executando a partir dela):
+
+```python
+from analise import calcular_media, interpretar_filtro
+
+calcular_media("dados.csv", "salario")                     # 2000.0
+calcular_media("dados.csv", "salario", ("idade", "30"))    # 1500.0
+calcular_media("dados.csv", "salario", interpretar_filtro("idade=30"))
+```
+
+## Testes
+
+Os testes usam apenas o `unittest` da biblioteca padrão. Na raiz do projeto:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Estrutura
+
+```
+src/analise.py           # script e funções
+tests/test_analise.py    # testes unitários
+```
+
+## Licença
+
+Distribuído sob a licença MIT. Veja o arquivo [LICENSE](LICENSE).

csv_mean_filter-0.1.0/README.md

@@ -0,0 +1,125 @@
+# analise
+
+Script de linha de comando em Python que lê um arquivo CSV e calcula a média de uma coluna numérica, com filtro opcional por valor de outra coluna.
+
+## Funcionalidades
+
+- Calcula a média de qualquer coluna numérica de um CSV com cabeçalho.
+- Filtro opcional `--filtrar-coluna COLUNA=VALOR` para considerar só as linhas que batem com o valor.
+- Ignora células vazias.
+- Lê CSVs gravados pelo Excel (UTF-8 com BOM).
+- Mensagens de erro claras e códigos de saída previsíveis.
+- Usa apenas a biblioteca padrão: nenhuma dependência externa.
+
+## Requisitos
+
+- Python 3.10 ou superior.
+
+## Instalação
+
+Não há pacotes para instalar. Basta clonar o repositório:
+
+```bash
+git clone <url-do-repositorio>
+cd <pasta-do-repositorio>
+```
+
+## Instalação via pip
+
+O projeto também pode ser instalado como pacote, o que disponibiliza o comando `csv-mean` no terminal. Na raiz do repositório:
+
+```bash
+pip install .
+```
+
+Futuramente, quando o pacote estiver publicado no PyPI:
+
+```bash
+pip install csv-mean-filter
+```
+
+Depois de instalado, use `csv-mean` no lugar de `python src/analise.py`:
+
+```bash
+$ csv-mean dados.csv salario --filtrar-coluna idade=30
+1500.0
+```
+
+Recomenda-se instalar dentro de um ambiente virtual (`python -m venv .venv`).
+
+## Uso
+
+```bash
+python src/analise.py ARQUIVO COLUNA [--filtrar-coluna COLUNA=VALOR]
+```
+
+### Exemplos
+
+Dado o arquivo `dados.csv`:
+
+```csv
+nome,idade,salario
+Ana,30,1000
+Bia,25,3000
+Caio,30,2000
+```
+
+Média de uma coluna:
+
+```bash
+$ python src/analise.py dados.csv salario
+2000.0
+```
+
+Média só das linhas em que `idade` é `30`:
+
+```bash
+$ python src/analise.py dados.csv salario --filtrar-coluna idade=30
+1500.0
+```
+
+### Regras do filtro
+
+- O formato é `coluna=valor`. A divisão acontece no primeiro `=`, então `obs=a=b` filtra a coluna `obs` pelo valor `a=b`.
+- A comparação é exata e diferencia maiúsculas de minúsculas, após remover espaços nas pontas. `30` não bate com `30.0`.
+- `coluna=` (valor vazio) seleciona as linhas em que a coluna está vazia.
+- Valores não numéricos em linhas que não batem com o filtro são ignorados.
+
+### Códigos de saída
+
+| Código | Situação |
+|--------|----------|
+| `0` | Sucesso: a média é impressa na saída padrão. |
+| `1` | Arquivo inexistente, coluna inexistente, valor não numérico ou nenhum valor numérico (mensagem `Erro: ...` na saída de erro). |
+| `2` | Argumentos inválidos, como um filtro sem `=` (`use o formato coluna=valor`). |
+
+### Uso como módulo
+
+Com a pasta `src/` no `PYTHONPATH` (ou executando a partir dela):
+
+```python
+from analise import calcular_media, interpretar_filtro
+
+calcular_media("dados.csv", "salario")                     # 2000.0
+calcular_media("dados.csv", "salario", ("idade", "30"))    # 1500.0
+calcular_media("dados.csv", "salario", interpretar_filtro("idade=30"))
+```
+
+## Testes
+
+Os testes usam apenas o `unittest` da biblioteca padrão. Na raiz do projeto:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Estrutura
+
+```
+src/analise.py           # script e funções
+tests/test_analise.py    # testes unitários
+```
+
+## Licença
+
+Distribuído sob a licença MIT. Veja o arquivo [LICENSE](LICENSE).

csv_mean_filter-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "csv-mean-filter"
+version = "0.1.0"
+description = "CLI em Python para calcular a média de colunas CSV com filtros dinâmicos, zero dependências e 36 testes unitários."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  {name = "jjuffagtotal-source"}
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+[project.scripts]
+csv-mean = "analise:main"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src/analise.py"]
+sources = ["src"]

csv_mean_filter-0.1.0/requirements.txt

@@ -0,0 +1,2 @@
+# Este projeto usa apenas a biblioteca padrão do Python 3.10+.
+# Não há dependências externas para instalar.

csv_mean_filter-0.1.0/src/analise.py

@@ -0,0 +1,90 @@
+"""Calcula a média de uma coluna numérica de um arquivo CSV."""
+
+import argparse
+import csv
+import os
+import sys
+
+
+def interpretar_filtro(texto: str) -> tuple[str, str]:
+    """Converte "coluna=valor" em (coluna, valor), dividindo no primeiro "="."""
+    if "=" not in texto:
+        raise ValueError(f"Filtro sem '=': {texto!r}")
+    nome, valor = (parte.strip() for parte in texto.split("=", 1))
+    if not nome:
+        raise ValueError(f"Filtro sem nome de coluna: {texto!r}")
+    return nome, valor
+
+
+def _filtro_argparse(texto: str) -> tuple[str, str]:
+    """Adapta interpretar_filtro para o type= do argparse."""
+    try:
+        return interpretar_filtro(texto)
+    except ValueError:
+        raise argparse.ArgumentTypeError("use o formato coluna=valor") from None
+
+
+def calcular_media(
+    caminho_csv: str, coluna: str, filtro: tuple[str, str] | None = None
+) -> float:
+    """Retorna a média dos valores numéricos da coluna informada.
+
+    Células vazias são ignoradas. Com filtro (coluna, valor), considera só as
+    linhas cuja coluna do filtro é igual ao valor (após strip). Levanta
+    FileNotFoundError se o arquivo não existir e ValueError para coluna
+    ausente, valor não numérico ou ausência de valores numéricos.
+    """
+    if not os.path.isfile(caminho_csv):
+        raise FileNotFoundError(f"Arquivo não encontrado: {caminho_csv}")
+
+    with open(caminho_csv, encoding="utf-8-sig", newline="") as arquivo:
+        leitor = csv.DictReader(arquivo)
+        cabecalho = leitor.fieldnames or []
+        for nome in [coluna] + ([filtro[0]] if filtro else []):
+            if nome not in cabecalho:
+                raise ValueError(f"Coluna '{nome}' não encontrada no cabeçalho")
+
+        soma = 0.0
+        quantidade = 0
+        for linha in leitor:
+            if filtro and (linha.get(filtro[0]) or "").strip() != filtro[1].strip():
+                continue
+            bruto = (linha.get(coluna) or "").strip()
+            if not bruto:
+                continue
+            try:
+                soma += float(bruto)
+            except ValueError:
+                raise ValueError(
+                    f"Valor não numérico '{bruto}' na linha {leitor.line_num}"
+                ) from None
+            quantidade += 1
+
+    if quantidade == 0:
+        sufixo = f" com o filtro {filtro[0]}={filtro[1]}" if filtro else ""
+        raise ValueError(f"Nenhum valor numérico na coluna '{coluna}'{sufixo}")
+    return soma / quantidade
+
+
+def main(argv=None) -> int:
+    """Ponto de entrada da CLI; retorna o código de saída."""
+    parser = argparse.ArgumentParser(description="Média de uma coluna de um CSV.")
+    parser.add_argument("arquivo", help="caminho do arquivo CSV")
+    parser.add_argument("coluna", help="nome da coluna")
+    parser.add_argument(
+        "--filtrar-coluna", type=_filtro_argparse, metavar="COLUNA=VALOR",
+        help="considera só as linhas em que COLUNA é igual a VALOR",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        media = calcular_media(args.arquivo, args.coluna, args.filtrar_coluna)
+    except (FileNotFoundError, ValueError) as erro:
+        print(f"Erro: {erro}", file=sys.stderr)
+        return 1
+    print(media)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

csv_mean_filter-0.1.0/tests/test_analise.py

@@ -0,0 +1,267 @@
+import contextlib
+import io
+import os
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "src"))
+
+import analise  # noqa: E402
+
+
+class BaseCSVTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+
+    def criar_csv(self, conteudo, nome="dados.csv", encoding="utf-8"):
+        caminho = os.path.join(self._tmp.name, nome)
+        with open(caminho, "w", encoding=encoding, newline="") as f:
+            f.write(conteudo)
+        return caminho
+
+
+class TestCalcularMedia(BaseCSVTest):
+    def test_media_inteiros(self):
+        caminho = self.criar_csv("nome,valor\na,10\nb,20\nc,30\n")
+        self.assertEqual(analise.calcular_media(caminho, "valor"), 20.0)
+
+    def test_media_floats(self):
+        caminho = self.criar_csv("valor\n1.5\n2.5\n3.5\n")
+        self.assertAlmostEqual(analise.calcular_media(caminho, "valor"), 2.5)
+
+    def test_celulas_em_branco_ignoradas(self):
+        caminho = self.criar_csv("nome,valor\na,10\nb,\nc,  \nd,20\n")
+        self.assertEqual(analise.calcular_media(caminho, "valor"), 15.0)
+
+    def test_linha_curta_ignorada(self):
+        caminho = self.criar_csv("nome,valor\na,10\nb\nc,20\n")
+        self.assertEqual(analise.calcular_media(caminho, "valor"), 15.0)
+
+    def test_arquivo_inexistente(self):
+        caminho = os.path.join(self._tmp.name, "nao_existe.csv")
+        with self.assertRaises(FileNotFoundError):
+            analise.calcular_media(caminho, "valor")
+
+    def test_coluna_desconhecida(self):
+        caminho = self.criar_csv("nome,valor\na,10\n")
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(caminho, "preco")
+        self.assertIn("preco", str(ctx.exception))
+
+    def test_arquivo_vazio(self):
+        caminho = self.criar_csv("")
+        with self.assertRaises(ValueError):
+            analise.calcular_media(caminho, "valor")
+
+    def test_valor_nao_numerico(self):
+        caminho = self.criar_csv("nome,valor\na,10\nb,abc\n")
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(caminho, "valor")
+        self.assertIn("abc", str(ctx.exception))
+        self.assertIn("3", str(ctx.exception))
+
+    def test_coluna_sem_valores_numericos(self):
+        caminho = self.criar_csv("nome,valor\na,\nb, \n")
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(caminho, "valor")
+        self.assertIn("valor", str(ctx.exception))
+
+
+class TestMain(BaseCSVTest):
+    def executar(self, argv):
+        out, err = io.StringIO(), io.StringIO()
+        with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
+            codigo = analise.main(argv)
+        return codigo, out.getvalue(), err.getvalue()
+
+    def test_sucesso_imprime_media(self):
+        caminho = self.criar_csv("valor\n10\n\n20\n")
+        codigo, out, err = self.executar([caminho, "valor"])
+        self.assertEqual(codigo, 0)
+        self.assertEqual(out.strip(), "15.0")
+        self.assertEqual(err, "")
+
+    def test_erro_arquivo_inexistente(self):
+        caminho = os.path.join(self._tmp.name, "nao_existe.csv")
+        codigo, out, err = self.executar([caminho, "valor"])
+        self.assertEqual(codigo, 1)
+        self.assertEqual(out, "")
+        self.assertTrue(err.startswith("Erro:"))
+
+    def test_erro_coluna_desconhecida(self):
+        caminho = self.criar_csv("valor\n1\n")
+        codigo, out, err = self.executar([caminho, "outra"])
+        self.assertEqual(codigo, 1)
+        self.assertIn("Erro:", err)
+
+    def test_erro_valor_nao_numerico(self):
+        caminho = self.criar_csv("valor\nx\n")
+        codigo, _, err = self.executar([caminho, "valor"])
+        self.assertEqual(codigo, 1)
+        self.assertIn("Erro:", err)
+
+
+CSV_FILTRO = (
+    "nome,idade,salario,cidade\n"
+    "a,30,1000,SP\n"
+    "b, 30 ,2000,\n"
+    "c,40,xx,RJ\n"
+    "d,30.0,9999,RJ\n"
+    "e,50,,X\n"
+)
+
+
+class TestInterpretarFiltro(unittest.TestCase):
+    def test_simples(self):
+        self.assertEqual(analise.interpretar_filtro("idade=30"), ("idade", "30"))
+
+    def test_divide_no_primeiro_igual(self):
+        self.assertEqual(analise.interpretar_filtro("obs=a=b"), ("obs", "a=b"))
+
+    def test_remove_espacos(self):
+        self.assertEqual(analise.interpretar_filtro(" x = y "), ("x", "y"))
+
+    def test_valor_vazio(self):
+        self.assertEqual(analise.interpretar_filtro("cidade="), ("cidade", ""))
+
+    def test_sem_igual(self):
+        with self.assertRaises(ValueError):
+            analise.interpretar_filtro("idade30")
+
+    def test_nome_coluna_vazio(self):
+        with self.assertRaises(ValueError):
+            analise.interpretar_filtro("=1")
+        with self.assertRaises(ValueError):
+            analise.interpretar_filtro("  =1")
+
+
+class TestCalcularMediaComFiltro(BaseCSVTest):
+    def setUp(self):
+        super().setUp()
+        self.caminho = self.criar_csv(CSV_FILTRO)
+
+    def test_media_apenas_linhas_correspondentes(self):
+        # " 30 " casa com "30"; "30.0" nao casa; "xx" da linha c e ignorado
+        self.assertEqual(
+            analise.calcular_media(self.caminho, "salario", ("idade", "30")), 1500.0
+        )
+
+    def test_comparacao_exata_e_sensivel_a_maiusculas(self):
+        caminho = self.criar_csv("cidade,valor\nSP,10\nsp,100\nSP ,20\n")
+        self.assertEqual(analise.calcular_media(caminho, "valor", ("cidade", "SP")), 15.0)
+        self.assertEqual(analise.calcular_media(caminho, "valor", ("cidade", "sp")), 100.0)
+
+    def test_30_nao_casa_com_30_ponto_0(self):
+        self.assertEqual(
+            analise.calcular_media(self.caminho, "salario", ("idade", "30.0")), 9999.0
+        )
+
+    def test_valor_vazio_casa_celulas_vazias(self):
+        self.assertEqual(
+            analise.calcular_media(self.caminho, "salario", ("cidade", "")), 2000.0
+        )
+
+    def test_filtro_none_igual_ao_anterior(self):
+        caminho = self.criar_csv("nome,valor\na,10\nb,\nc,20\n")
+        self.assertEqual(
+            analise.calcular_media(caminho, "valor", None),
+            analise.calcular_media(caminho, "valor"),
+        )
+        self.assertEqual(analise.calcular_media(caminho, "valor", None), 15.0)
+
+    def test_filtro_none_valor_invalido_ainda_falha(self):
+        with self.assertRaises(ValueError):
+            analise.calcular_media(self.caminho, "salario", None)
+
+    def test_coluna_filtro_inexistente(self):
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(self.caminho, "salario", ("nada", "1"))
+        self.assertIn("nada", str(ctx.exception))
+
+    def test_nenhuma_linha_corresponde(self):
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(self.caminho, "salario", ("idade", "99"))
+        self.assertIn("idade=99", str(ctx.exception))
+
+    def test_correspondentes_somente_vazios(self):
+        with self.assertRaises(ValueError):
+            analise.calcular_media(self.caminho, "salario", ("idade", "50"))
+
+    def test_nao_numerico_em_linha_correspondente_falha(self):
+        with self.assertRaises(ValueError) as ctx:
+            analise.calcular_media(self.caminho, "salario", ("idade", "40"))
+        self.assertIn("xx", str(ctx.exception))
+        self.assertIn("4", str(ctx.exception))
+
+
+class TestMainComFiltro(BaseCSVTest):
+    executar = TestMain.executar
+
+    def test_filtro_sucesso(self):
+        caminho = self.criar_csv(CSV_FILTRO)
+        codigo, out, err = self.executar(
+            [caminho, "salario", "--filtrar-coluna", "idade=30"]
+        )
+        self.assertEqual(codigo, 0)
+        self.assertEqual(out.strip(), "1500.0")
+        self.assertEqual(err, "")
+
+    def test_filtro_coluna_inexistente(self):
+        caminho = self.criar_csv(CSV_FILTRO)
+        codigo, out, err = self.executar(
+            [caminho, "salario", "--filtrar-coluna", "nada=1"]
+        )
+        self.assertEqual(codigo, 1)
+        self.assertEqual(out, "")
+        self.assertIn("Erro:", err)
+
+    def test_filtro_mal_formatado_sai_com_2(self):
+        caminho = self.criar_csv(CSV_FILTRO)
+        for texto in ("idade30", "=1"):
+            with self.subTest(texto=texto):
+                err = io.StringIO()
+                with contextlib.redirect_stderr(err), self.assertRaises(SystemExit) as ctx:
+                    analise.main([caminho, "salario", "--filtrar-coluna", texto])
+                self.assertEqual(ctx.exception.code, 2)
+                self.assertIn("--filtrar-coluna", err.getvalue())
+
+
+class TestMensagemFiltroInvalido(BaseCSVTest):
+    def test_mensagem_formato_coluna_valor(self):
+        caminho = self.criar_csv(CSV_FILTRO)
+        err = io.StringIO()
+        with contextlib.redirect_stderr(err), self.assertRaises(SystemExit) as ctx:
+            analise.main([caminho, "salario", "--filtrar-coluna", "idade30"])
+        self.assertEqual(ctx.exception.code, 2)
+        self.assertIn(
+            "argument --filtrar-coluna: use o formato coluna=valor", err.getvalue()
+        )
+
+
+class TestArquivoComBOM(BaseCSVTest):
+    def setUp(self):
+        super().setUp()
+        self.caminho = self.criar_csv(
+            "idade,salario\n30,1000\n40,2000\n30,3000\n", encoding="utf-8-sig"
+        )
+        with open(self.caminho, "rb") as f:
+            self.assertEqual(f.read(3), b"\xef\xbb\xbf")
+
+    def test_media_primeira_coluna_sem_filtro(self):
+        self.assertAlmostEqual(analise.calcular_media(self.caminho, "idade"), 100 / 3)
+
+    def test_media_primeira_coluna_com_filtro_na_primeira_coluna(self):
+        self.assertEqual(
+            analise.calcular_media(self.caminho, "idade", ("idade", "30")), 30.0
+        )
+
+    def test_filtro_na_primeira_coluna_media_de_outra(self):
+        self.assertEqual(
+            analise.calcular_media(self.caminho, "salario", ("idade", "30")), 2000.0
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()