Skip to content

Hypergraph is more powerful. Transform unstructured text into structured knowledge with LLMs. Graphs, hypergraphs, and spatio-temporal extractions — with one command.

refactor(cli): remove --verbose flag, log level via HYPER_EXTRACT_LOG_LEVEL only

David Lie5e748329287
diff --git a/hyperextract/cli/cli.py b/hyperextract/cli/cli.py
index 468c540..83d4f87 100644
--- a/hyperextract/cli/cli.py
+++ b/hyperextract/cli/cli.py
@@ -52,20 +52,11 @@ def main(
help="Show version information",
is_eager=True,
),
- verbose: bool = typer.Option(
- False,
- "--verbose",
- help="Enable verbose logging of key processes and execution stages",
- is_eager=True,
- ),
):
# Configure logging after all imports complete so dependency loggers
# (e.g. ontosight) don't override our level settings.
- if verbose:
- configure_logging(level="DEBUG")
- ctx.obj = {"verbose": True}
- else:
- configure_logging()
+ # Log level is controlled solely by the HYPER_EXTRACT_LOG_LEVEL env var.
+ configure_logging()
if version:
from . import __version__
diff --git a/tests/cli/test_verbose.py b/tests/cli/test_verbose.py
index 7d15d19..09caa20 100644
--- a/tests/cli/test_verbose.py
+++ b/tests/cli/test_verbose.py
@@ -1,93 +1,126 @@
-"""Tests for the --verbose CLI flag."""
+"""Tests for log level configuration via HYPER_EXTRACT_LOG_LEVEL env var."""
import logging
-from unittest.mock import patch, MagicMock
+import os
+from unittest.mock import patch
import pytest
from typer.testing import CliRunner
from hyperextract.cli.cli import app
+from hyperextract.utils.logging import configure_logging, ENV_LOG_LEVEL
runner = CliRunner()
-class TestVerboseFlag:
- """Test that --verbose enables logging."""
-
- def test_verbose_flag_shows_in_help(self):
- """--verbose appears in top-level help output."""
+class TestLogLevelEnvVar:
+ """Test that log level is controlled by HYPER_EXTRACT_LOG_LEVEL env var."""
+
+ def test_env_var_default_warning(self):
+ """Without env var, default log level is WARNING."""
+ with patch.dict(os.environ, {}, clear=False):
+ # Remove the env var if present
+ os.environ.pop(ENV_LOG_LEVEL, None)
+ configure_logging()
+ assert logging.getLogger().level == logging.WARNING
+
+ def test_env_var_sets_debug(self):
+ """HYPER_EXTRACT_LOG_LEVEL=DEBUG sets root logger to DEBUG."""
+ with patch.dict(os.environ, {ENV_LOG_LEVEL: "DEBUG"}):
+ configure_logging()
+ assert logging.getLogger().level == logging.DEBUG
+
+ def test_env_var_sets_info(self):
+ """HYPER_EXTRACT_LOG_LEVEL=INFO sets root logger to INFO."""
+ with patch.dict(os.environ, {ENV_LOG_LEVEL: "INFO"}):
+ configure_logging()
+ assert logging.getLogger().level == logging.INFO
+
+ def test_env_var_sets_error(self):
+ """HYPER_EXTRACT_LOG_LEVEL=ERROR sets root logger to ERROR."""
+ with patch.dict(os.environ, {ENV_LOG_LEVEL: "ERROR"}):
+ configure_logging()
+ assert logging.getLogger().level == logging.ERROR
+
+ def test_env_var_case_insensitive(self):
+ """HYPER_EXTRACT_LOG_LEVEL=debug (lowercase) should work."""
+ with patch.dict(os.environ, {ENV_LOG_LEVEL: "debug"}):
+ configure_logging()
+ assert logging.getLogger().level == logging.DEBUG
+
+ def test_env_var_invalid_falls_back_to_warning(self):
+ """Invalid log level falls back to WARNING."""
+ with patch.dict(os.environ, {ENV_LOG_LEVEL: "INVALID"}):
+ configure_logging()
+ assert logging.getLogger().level == logging.WARNING
+
+
+class TestCLINoVerboseFlag:
+ """Test that --verbose flag is no longer supported."""
+
+ def test_verbose_flag_not_in_help(self):
+ """--verbose should NOT appear in help output."""
result = runner.invoke(app, ["--help"])
assert result.exit_code == 0
- assert "--verbose" in result.output
+ assert "--verbose" not in result.output
- def test_verbose_flag_default_false(self):
- """Without --verbose, logging stays at WARNING level (default)."""
- result = runner.invoke(app, ["--help"])
- assert result.exit_code == 0
- # No log output should appear in help mode
- assert result.output.count("INFO") == 0
-
- def test_verbose_flag_with_version(self):
- """--verbose combined with --version exits cleanly."""
+ def test_verbose_flag_causes_error(self):
+ """Using --verbose should cause an error (unrecognized option)."""
result = runner.invoke(app, ["--verbose", "--version"])
- assert result.exit_code == 0
- assert "Hyper-Extract CLI" in result.output
+ assert result.exit_code != 0
- def test_verbose_sets_debug_log_level(self):
- """When --verbose is passed, root logger level is set to DEBUG."""
- result = runner.invoke(app, ["--verbose", "--version"])
+ def test_version_works_without_verbose(self):
+ """--version works without --verbose."""
+ result = runner.invoke(app, ["--version"])
assert result.exit_code == 0
- root_logger = logging.getLogger()
- # After --verbose, the root logger should be at DEBUG level
- assert root_logger.level == logging.DEBUG
+ assert "Hyper-Extract CLI" in result.output
- def test_verbose_before_subcommand(self):
- """--verbose works when placed before a subcommand: he --verbose info --help."""
- result = runner.invoke(app, ["--verbose", "info", "--help"])
+ def test_subcommand_help_works(self):
+ """Subcommand help works without --verbose."""
+ result = runner.invoke(app, ["info", "--help"])
assert result.exit_code == 0
- def test_verbose_before_parse_help(self):
- """he --verbose parse --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "parse", "--help"])
+ def test_parse_help_works(self):
+ """he parse --help exits cleanly."""
+ result = runner.invoke(app, ["parse", "--help"])
assert result.exit_code == 0
- def test_verbose_before_search_help(self):
- """he --verbose search --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "search", "--help"])
+ def test_search_help_works(self):
+ """he search --help exits cleanly."""
+ result = runner.invoke(app, ["search", "--help"])
assert result.exit_code == 0
- def test_verbose_before_talk_help(self):
- """he --verbose talk --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "talk", "--help"])
+ def test_talk_help_works(self):
+ """he talk --help exits cleanly."""
+ result = runner.invoke(app, ["talk", "--help"])
assert result.exit_code == 0
- def test_verbose_before_feed_help(self):
- """he --verbose feed --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "feed", "--help"])
+ def test_feed_help_works(self):
+ """he feed --help exits cleanly."""
+ result = runner.invoke(app, ["feed", "--help"])
assert result.exit_code == 0
- def test_verbose_before_build_index_help(self):
- """he --verbose build-index --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "build-index", "--help"])
+ def test_build_index_help_works(self):
+ """he build-index --help exits cleanly."""
+ result = runner.invoke(app, ["build-index", "--help"])
assert result.exit_code == 0
- def test_verbose_before_show_help(self):
- """he --verbose show --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "show", "--help"])
+ def test_show_help_works(self):
+ """he show --help exits cleanly."""
+ result = runner.invoke(app, ["show", "--help"])
assert result.exit_code == 0
- def test_verbose_before_list_template_help(self):
- """he --verbose list template --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "list", "template", "--help"])
+ def test_list_template_help_works(self):
+ """he list template --help exits cleanly."""
+ result = runner.invoke(app, ["list", "template", "--help"])
assert result.exit_code == 0
- def test_verbose_before_config_help(self):
- """he --verbose config --help exits cleanly."""
- result = runner.invoke(app, ["--verbose", "config", "--help"])
+ def test_config_help_works(self):
+ """he config --help exits cleanly."""
+ result = runner.invoke(app, ["config", "--help"])
assert result.exit_code == 0
- def test_verbose_info_missing_ka_exits_with_error(self):
- """he --verbose info <nonexistent> exits with error (verbose logging enabled)."""
- result = runner.invoke(app, ["--verbose", "info", "/nonexistent/path"])
- # Should exit with error code (path doesn't exist)
+ def test_info_missing_ka_exits_with_error(self):
+ """he info <nonexistent> exits with error."""
+ result = runner.invoke(app, ["info", "/nonexistent/path"])
assert result.exit_code != 0