python-code-validator 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

code_validator/__init__.py

@@ -54,4 +54,4 @@ __all__ = [
     "RuleParsingError",
 ]
 
-__version__ = "0.1.3"
+__version__ = "0.2.1"

code_validator/cli.py

@@ -35,19 +35,22 @@ def setup_arg_parser() -> argparse.ArgumentParser:
         prog="validate-code",
         description="Validates a Python source file against a set of JSON rules.",
     )
+
     parser.add_argument("solution_path", type=Path, help="Path to the Python solution file to validate.")
     parser.add_argument("rules_path", type=Path, help="Path to the JSON file with validation rules.")
+
     parser.add_argument(
-        "-l",
-        "--log-level",
+        "--log",
         type=LogLevel,
-        choices=list(LogLevel),
-        default=LogLevel.WARNING,
-        help="Set the logging level (default: WARNING).",
+        default=LogLevel.ERROR,
+        help=("Set the logging level for stderr (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL). Default: ERROR."),
     )
-    parser.add_argument("--silent", action="store_true", help="Suppress stdout output, show only logs.")
+    parser.add_argument(
+        "--quiet", action="store_true", help="Suppress all stdout output (validation errors and final verdict)."
+    )
+    parser.add_argument("--no-verdict", action="store_true", help="Suppress stdout output verdict, show failed rules.")
     parser.add_argument("--stop-on-first-fail", action="store_true", help="Stop after the first failed rule.")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--version", "-v", action="version", version=f"%(prog)s {__version__}")
     return parser
 
 
@@ -68,35 +71,42 @@ def run_from_cli() -> None:
     parser = setup_arg_parser()
     args = parser.parse_args()
 
-    logger = setup_logging(args.log_level)
-    console = Console(logger, is_silent=args.silent)
+    logger = setup_logging(args.log)
+    console = Console(logger, is_quiet=args.quiet, show_verdict=not args.no_verdict)
+    console.print(f"Level of logging: {args.log}", level=LogLevel.DEBUG)
     config = AppConfig(
         solution_path=args.solution_path,
         rules_path=args.rules_path,
-        log_level=args.log_level,
-        is_silent=args.silent,
+        log_level=args.log,
+        is_quiet=args.quiet,
         stop_on_first_fail=args.stop_on_first_fail,
     )
+    console.print(f"Config is: {config}", level=LogLevel.TRACE)
 
     try:
         console.print(f"Starting validation for: {config.solution_path}", level=LogLevel.INFO)
         validator = StaticValidator(config, console)
+
+        console.print("Start of validation..", level=LogLevel.TRACE)
         is_valid = validator.run()
+        console.print(f"End of validation with result: {is_valid = }", level=LogLevel.TRACE)
 
         if is_valid:
-            console.print("Validation successful.", level=LogLevel.INFO)
+            console.print("Validation successful.", level=LogLevel.INFO, is_verdict=True)
             sys.exit(ExitCode.SUCCESS)
         else:
-            console.print("Validation failed.", level=LogLevel.ERROR)
+            console.print("Validation failed.", level=LogLevel.INFO, is_verdict=True)
             sys.exit(ExitCode.VALIDATION_FAILED)
 
     except CodeValidatorError as e:
-        console.print(str(e), level=LogLevel.CRITICAL)
+        console.print("Error: Internal Error of validator!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for CodeValidatorError: {e}")
         sys.exit(ExitCode.VALIDATION_FAILED)
     except FileNotFoundError as e:
-        console.print(f"Error: File not found - {e.strerror}: {e.filename}", level=LogLevel.CRITICAL)
+        console.print(f"Error: File not found - {e.filename}!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for FileNotFoundError: {e}")
         sys.exit(ExitCode.FILE_NOT_FOUND)
     except Exception as e:
-        console.print(f"An unexpected error occurred: {e}", level=LogLevel.CRITICAL)
-        logger.exception("Traceback for unexpected error:")
+        console.print(f"An unexpected error occurred: {e.__class__.__name__}!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for unexpected error: {e}")
         sys.exit(ExitCode.UNEXPECTED_ERROR)

code_validator/components/factories.py

@@ -10,9 +10,9 @@ rules file and instantiating the appropriate handler classes from the
 import dataclasses
 from typing import Any, Type, TypeVar
 
-from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, SelectorConfig, ShortRuleConfig
+from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, LogLevel, SelectorConfig, ShortRuleConfig
 from ..exceptions import RuleParsingError
-from ..output import Console
+from ..output import Console, log_initialization
 from ..rules_library.basic_rules import CheckLinterRule, CheckSyntaxRule, FullRuleHandler
 from ..rules_library.constraint_logic import (
     IsForbiddenConstraint,
@@ -71,6 +71,7 @@ class RuleFactory:
         _constraint_factory (ConstraintFactory): A factory for creating constraint objects.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, console: Console):
         """Initializes the RuleFactory.
 
@@ -101,8 +102,10 @@ class RuleFactory:
                 required keys, or specifies an unknown type.
         """
         rule_id = rule_config.get("rule_id")
+        self._console.print(f"Start parsing rule ({rule_id}):\n{rule_config}", level=LogLevel.TRACE)
         try:
             if "type" in rule_config:
+                self._console.print(f"Rule {rule_id} is shorted rule - {rule_config['type']}", level=LogLevel.DEBUG)
                 config = _create_dataclass_from_dict(ShortRuleConfig, rule_config)
                 return self._create_short_rule(config)
 
@@ -110,20 +113,31 @@ class RuleFactory:
                 raw_selector_cfg = rule_config["check"]["selector"]
                 raw_constraint_cfg = rule_config["check"]["constraint"]
 
-                selector = self._selector_factory.create(raw_selector_cfg)
-                constraint = self._constraint_factory.create(raw_constraint_cfg)
-
                 selector_cfg = _create_dataclass_from_dict(SelectorConfig, raw_selector_cfg)
                 constraint_cfg = _create_dataclass_from_dict(ConstraintConfig, raw_constraint_cfg)
+
+                selector = self._selector_factory.create(selector_cfg)
+                constraint = self._constraint_factory.create(constraint_cfg)
+
+                self._console.print(
+                    f"Rule {rule_id} is general rule with: selector - "
+                    f"{selector_cfg.type}, constraint - {raw_constraint_cfg['type']}",
+                    level=LogLevel.DEBUG,
+                )
+
                 check_cfg = FullRuleCheck(selector=selector_cfg, constraint=constraint_cfg)
+                self._console.print(f"Create FullRuleCheck: {check_cfg}", level=LogLevel.TRACE)
+
                 config = FullRuleConfig(
                     rule_id=rule_config["rule_id"],
                     message=rule_config["message"],
                     check=check_cfg,
                     is_critical=rule_config.get("is_critical", False),
                 )
+                self._console.print(f"Create FullRuleConfig: {config}", level=LogLevel.TRACE)
                 return FullRuleHandler(config, selector, constraint, self._console)
             else:
+                self._console.print(f"Invalid syntax of rule: {rule_id}", level=LogLevel.WARNING)
                 raise RuleParsingError("Rule must contain 'type' or 'check' key.", rule_id)
         except (TypeError, KeyError, RuleParsingError) as e:
             raise RuleParsingError(f"Invalid config for rule '{rule_id}': {e}", rule_id) from e
@@ -165,21 +179,23 @@ class SelectorFactory:
     any state.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(selector_config: dict[str, Any]) -> Selector:
+    def create(config: SelectorConfig) -> Selector:
         """Creates a specific selector instance based on its type.
 
         This method uses the 'type' field from the selector configuration
         to determine which concrete Selector class to instantiate.
 
         Args:
-            selector_config: The 'selector' block from a JSON rule.
+            config: The 'selector' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Selector protocol.
         """
-        config = _create_dataclass_from_dict(SelectorConfig, selector_config)
-
         match config.type:
             case "function_def":
                 return FunctionDefSelector(name=config.name, in_scope_config=config.in_scope)
@@ -210,21 +226,23 @@ class ConstraintFactory:
     to a list of AST nodes. This class uses a static `create` method.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(constraint_config: dict[str, Any]) -> Constraint:
+    def create(config: ConstraintConfig) -> Constraint:
         """Creates a specific constraint instance based on its type.
 
         This method uses the 'type' field from the constraint configuration
         to determine which concrete Constraint class to instantiate.
 
         Args:
-            constraint_config: The 'constraint' block from a JSON rule.
+            config: The 'constraint' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Constraint protocol.
         """
-        config = _create_dataclass_from_dict(ConstraintConfig, constraint_config)
-
         match config.type:
             case "is_required":
                 return IsRequiredConstraint(count=config.count)

code_validator/config.py

@@ -25,6 +25,7 @@ class ExitCode(IntEnum):
 class LogLevel(StrEnum):
     """Defines the supported logging levels for the application."""
 
+    TRACE = "TRACE"
     DEBUG = "DEBUG"
     INFO = "INFO"
     WARNING = "WARNING"
@@ -40,14 +41,14 @@ class AppConfig:
         solution_path: The file path to the Python solution to be validated.
         rules_path: The file path to the JSON rules file.
         log_level: The minimum logging level for console output.
-        is_silent: If True, suppresses all non-log output to stdout.
+        is_quiet: If True, suppresses all non-log output to stdout.
         stop_on_first_fail: If True, halts validation after the first failed rule.
     """
 
     solution_path: Path
     rules_path: Path
     log_level: LogLevel
-    is_silent: bool
+    is_quiet: bool
     stop_on_first_fail: bool
 
 

code_validator/core.py

@@ -45,9 +45,9 @@ import json
 from .components.ast_utils import enrich_ast_with_parents
 from .components.definitions import Rule
 from .components.factories import RuleFactory
-from .config import AppConfig, LogLevel
+from .config import AppConfig, LogLevel, ShortRuleConfig
 from .exceptions import RuleParsingError
-from .output import Console
+from .output import Console, log_initialization
 
 
 class StaticValidator:
@@ -67,6 +67,7 @@ class StaticValidator:
         _failed_rules (list[int]): A list of rule IDs that failed during the run.
     """
 
+    @log_initialization(level=LogLevel.DEBUG)
     def __init__(self, config: AppConfig, console: Console):
         """Initializes the StaticValidator.
 
@@ -77,6 +78,7 @@ class StaticValidator:
         """
         self._config = config
         self._console = console
+
         self._rule_factory = RuleFactory(self._console)
         self._source_code: str = ""
         self._ast_tree: ast.Module | None = None
@@ -95,39 +97,17 @@ class StaticValidator:
             FileNotFoundError: If the source file specified in the config does not exist.
             RuleParsingError: If the source file cannot be read for any other reason.
         """
-        self._console.print(f"Reading source file: {self._config.solution_path}")
+        self._console.print(f"Reading source file: {self._config.solution_path}", level=LogLevel.DEBUG)
         try:
             self._source_code = self._config.solution_path.read_text(encoding="utf-8")
+            self._console.print(f"Source code:\n{self._source_code}\n", level=LogLevel.TRACE)
         except FileNotFoundError:
+            self._console.print("During reading source file raised FileNotFound", level=LogLevel.TRACE)
             raise
         except Exception as e:
+            self._console.print("During reading source file raised some exception..", level=LogLevel.TRACE)
             raise RuleParsingError(f"Cannot read source file: {e}") from e
 
-    def _parse_ast_tree(self) -> bool:
-        """Parses the loaded source code into an AST and enriches it.
-
-        This method attempts to parse the source code. If successful, it calls
-        a helper to add parent references to each node in the tree, which is
-        crucial for many advanced checks. If a `SyntaxError` occurs, it
-        checks if a `check_syntax` rule was defined to provide a custom message.
-
-        Returns:
-            bool: True if parsing was successful, False otherwise.
-        """
-        self._console.print("Parsing Abstract Syntax Tree (AST)...")
-        try:
-            self._ast_tree = ast.parse(self._source_code)
-            enrich_ast_with_parents(self._ast_tree)
-            return True
-        except SyntaxError as e:
-            for rule in self._rules:
-                if getattr(rule.config, "type", None) == "check_syntax":
-                    self._console.print(rule.config.message, level=LogLevel.ERROR)
-                    self._failed_rules.append(rule.config.rule_id)
-                    return False
-            self._console.print(f"Syntax Error found: {e}", level=LogLevel.ERROR)
-            return False
-
     def _load_and_parse_rules(self) -> None:
         """Loads and parses the JSON file into executable Rule objects.
 
@@ -140,20 +120,52 @@ class StaticValidator:
             RuleParsingError: If the JSON is malformed or a rule configuration
                 is invalid.
         """
-        self._console.print(f"Loading rules from: {self._config.rules_path}")
+        self._console.print(f"Loading rules from: {self._config.rules_path}", level=LogLevel.DEBUG)
         try:
             rules_data = json.loads(self._config.rules_path.read_text(encoding="utf-8"))
+            self._console.print(f"Load rules:\n{rules_data}", level=LogLevel.TRACE)
             raw_rules = rules_data.get("validation_rules")
             if not isinstance(raw_rules, list):
                 raise RuleParsingError("`validation_rules` key not found or is not a list.")
 
+            self._console.print(f"Found {len(raw_rules)}.", level=LogLevel.DEBUG)
             self._rules = [self._rule_factory.create(rule) for rule in raw_rules]
-            self._console.print(f"Successfully parsed {len(self._rules)} rules.")
+            self._console.print(f"Successfully parsed {len(self._rules)} rules.", level=LogLevel.DEBUG)
         except json.JSONDecodeError as e:
+            self._console.print("During reading file of rules raised JsonDecodeError..", level=LogLevel.TRACE)
             raise RuleParsingError(f"Invalid JSON in rules file: {e}") from e
         except FileNotFoundError:
+            self._console.print("During reading file of rules raised FileNotFound", level=LogLevel.TRACE)
             raise
 
+    def _parse_ast_tree(self) -> bool:
+        """Parses the loaded source code into an AST and enriches it.
+
+        This method attempts to parse the source code. If successful, it calls
+        a helper to add parent references to each node in the tree, which is
+        crucial for many advanced checks. If a `SyntaxError` occurs, it
+        checks if a `check_syntax` rule was defined to provide a custom message.
+
+        Returns:
+            bool: True if parsing was successful, False otherwise.
+        """
+        self._console.print("Parsing Abstract Syntax Tree (AST)...", level=LogLevel.DEBUG)
+        try:
+            self._console.print("Start parse source code.", level=LogLevel.TRACE)
+            self._ast_tree = ast.parse(self._source_code)
+            enrich_ast_with_parents(self._ast_tree)
+            return True
+        except SyntaxError as e:
+            self._console.print("In source code SyntaxError..", level=LogLevel.TRACE)
+            for rule in self._rules:
+                if getattr(rule.config, "type", None) == "check_syntax":
+                    self._console.print(rule.config.message, level=LogLevel.ERROR, show_user=True)
+                    self._console.print(f"Failed rule id: {rule.config.rule_id}", level=LogLevel.DEBUG)
+                    self._failed_rules.append(rule.config.rule_id)
+                    return False
+            self._console.print(f"Syntax Error found: {e}", level=LogLevel.ERROR)
+            return False
+
     def run(self) -> bool:
         """Runs the entire validation process from start to finish.
 
@@ -174,20 +186,38 @@ class StaticValidator:
             if not self._parse_ast_tree():
                 return False
 
-        except (FileNotFoundError, RuleParsingError):
+            self._console.print("Lead source code, load and parse rules and parsing code - PASS", level=LogLevel.DEBUG)
+
+        except (FileNotFoundError, RuleParsingError) as e:
+            self._console.print(
+                f"In method `run` of 'StaticValidator' raised exception {e.__class__.__name__}", level=LogLevel.WARNING
+            )
             raise
 
+        self._console.print("Starting check rules..", level=LogLevel.DEBUG)
         for rule in self._rules:
             if getattr(rule.config, "type", None) == "check_syntax":
                 continue
 
-            self._console.print(f"Executing rule: {rule.config.rule_id}", level=LogLevel.DEBUG)
+            self._console.print(
+                f"Executing rule: {rule.config.rule_id}"
+                + (
+                    f" [{rule.config.check.selector.type}, {rule.config.check.constraint.type}, "
+                    f"is_critical={rule.config.is_critical}]"
+                    if not isinstance(rule.config, ShortRuleConfig)
+                    else ""
+                ),
+                level=LogLevel.INFO,
+            )
             is_passed = rule.execute(self._ast_tree, self._source_code)
             if not is_passed:
-                self._console.print(rule.config.message, level=LogLevel.ERROR)
+                self._console.print(rule.config.message, level=LogLevel.WARNING, show_user=True)
+                self._console.print(f"Rule {rule.config.rule_id} - FAIL", level=LogLevel.INFO)
                 self._failed_rules.append(rule.config.rule_id)
                 if getattr(rule.config, "is_critical", False) or self._config.stop_on_first_fail:
                     self._console.print("Critical rule failed. Halting validation.", level=LogLevel.WARNING)
                     break
+            else:
+                self._console.print(f"Rule {rule.config.rule_id} - PASS", level=LogLevel.INFO)
 
         return not self._failed_rules

code_validator/output.py

@@ -7,12 +7,50 @@ controlled via configuration (e.g., log levels, silent mode).
 
 import logging
 import sys
-from typing import Literal
+from functools import wraps
+from typing import Callable, Concatenate, Literal, ParamSpec, TypeVar
 
 from .config import LogLevel
 
-LOG_FORMAT = "%(asctime)s | %(filename)-15s | %(funcName)-15s (%(lineno)-3s) | [%(levelname)s] - %(message)s"
 DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+LOG_FORMAT = (
+    "{asctime}.{msecs:03.0f} | "
+    "{levelname:^8} | "
+    "[{processName}({process})/{threadName}({thread})] | "
+    "{filename}:{funcName}:{lineno} | "
+    "{message}"
+)
+
+TRACE_LEVEL_NUM = 5
+logging.addLevelName(TRACE_LEVEL_NUM, "TRACE")
+
+
+def trace(self, message, *args, **kws):
+    """Logs a message with TRACE level (below DEBUG).
+
+    This method allows logging messages with a custom TRACE level,
+    defined at level number 5. It only emits the log if the logger
+    is enabled for this level.
+
+    To enable usage, attach this method to the `logging.Logger` class:
+
+        logging.Logger.trace = trace
+
+    Args:
+        self: logger instance.
+        message: The log message format string.
+        *args: Arguments to be merged into the message format string.
+        **kws: Optional keyword arguments passed to the logger,
+               e.g., `exc_info`, `stacklevel`, or `extra`.
+
+    Returns:
+        None
+    """
+    if self.isEnabledFor(TRACE_LEVEL_NUM):
+        self._log(TRACE_LEVEL_NUM, message, args, **kws)
+
+
+logging.Logger.trace = trace
 
 
 def setup_logging(log_level: LogLevel) -> logging.Logger:
@@ -27,8 +65,75 @@ def setup_logging(log_level: LogLevel) -> logging.Logger:
     Returns:
         The configured root logger instance.
     """
-    logging.basicConfig(level=log_level, format=LOG_FORMAT, datefmt=DATE_FORMAT)
-    return logging.getLogger()
+    formatter = logging.Formatter(fmt=LOG_FORMAT, datefmt=DATE_FORMAT, style="{")
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+
+    if root_logger.hasHandlers():
+        root_logger.handlers.clear()
+
+    root_logger.addHandler(handler)
+
+    return root_logger
+
+
+P = ParamSpec("P")
+T_self = TypeVar("T_self")
+
+
+def log_initialization(
+    level: LogLevel | Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = LogLevel.TRACE,
+    start_message: str = "Initializing {class_name}...",
+    end_message: str = "{class_name} initialized.",
+) -> Callable[[Callable[Concatenate[T_self, P], None]], Callable[Concatenate[T_self, P], None]]:
+    """Decorator factory for logging the initialization of a class instance.
+
+    This decorator wraps a class's `__init__` method to automatically log
+    messages before and after the constructor's execution. It helps in
+    observing the lifecycle of objects, especially complex ones, without
+    cluttering the `__init__` method itself.
+
+    The log messages can include a `{class_name}` placeholder, which will
+    be replaced by the actual name of the class being initialized.
+
+    Args:
+        level: The logging level (e.g., `LogLevel.DEBUG`, `LogLevel.INFO`)
+            at which the messages should be logged.
+        start_message: the message string to log immediately before the
+            `__init__` method is called. This string can contain the
+            `{class_name}` placeholder.
+        end_message: The message string to log immediately after the
+            `__init__` method completes its execution. This string can
+            contain the `{class_name}` placeholder.
+
+    Returns:
+        A decorator function that can be applied to an `__init__` method
+        of a class.
+    """
+
+    def decorator(init_method: Callable[Concatenate[T_self, P], None]) -> Callable[Concatenate[T_self, P], None]:
+        """The actual decorator function."""
+
+        @wraps(init_method)
+        def wrapper(self: T_self, *args: P.args, **kwargs: P.kwargs) -> None:
+            """The wrapper function that adds logging around __init__."""
+            class_name = self.__class__.__name__
+            logger = logging.getLogger(self.__class__.__module__)
+            level_num = logging.getLevelName(level if isinstance(level, LogLevel) else level)
+
+            logger.log(level_num, start_message.format(class_name=class_name))
+            result = init_method(self, *args, **kwargs)
+            logger.log(level_num, end_message.format(class_name=class_name))
+
+            return result
+
+        return wrapper
+
+    return decorator
 
 
 class Console:
@@ -40,7 +145,7 @@ class Console:
 
     Attributes:
         _logger (logging.Logger): The logger instance used for all log records.
-        _is_silent (bool): A flag to suppress printing to stdout.
+        _is_quiet (bool): A flag to suppress printing to stdout.
         _stdout (TextIO): The stream to write messages to (defaults to sys.stdout).
 
     Example:
@@ -53,22 +158,58 @@ class Console:
         This is a warning.
     """
 
-    def __init__(self, logger: logging.Logger, *, is_silent: bool = False):
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self, logger: logging.Logger, *, is_quiet: bool = False, show_verdict: bool = True):
         """Initializes the Console handler.
 
         Args:
             logger: The configured logger instance to use for logging.
-            is_silent: If True, suppresses output to stdout. Defaults to False.
+            is_quiet: If True, suppresses output to stdout. Defaults to False.
+            show_verdict: If False, suppresses showing verdicts. Default to True
         """
         self._logger = logger
-        self._is_silent = is_silent
+        self._is_quiet = is_quiet
+        self._show_verdict = show_verdict
         self._stdout = sys.stdout
 
+    def should_print(self, is_verdict: bool, show_user: bool) -> bool:
+        """Decides whether a message should be printed to stdout based on console flags.
+
+        Quiet mode (Q) suppresses all output if enabled. For non-verdict messages (¬V),
+        printing is allowed only when show_user (O) is True. For verdict messages (V),
+        printing is allowed only when show_verdict (S) is True.
+
+        Mathematically:
+            F = ¬Q ∧ ( (¬V ∧ O) ∨ (V ∧ S) )
+        where
+            Q = self._is_quiet,
+            V = is_verdict,
+            S = self._show_verdict,
+            O = show_user.
+
+        Proof sketch:
+            1. If Q is True, then ¬Q = False ⇒ F = False (silent mode).
+            2. If Q is False, split on V:
+               a. V = False ⇒ F = ¬Q ∧ O;
+               b. V = True  ⇒ F = ¬Q ∧ S.
+            3. Combine branches into F = ¬Q ∧ ( (¬V ∧ O) ∨ (V ∧ S) ).
+
+        Args:
+            is_verdict: True if this message is a verdict; controls branch V.
+            show_user: True if non-verdict messages should be printed; controls branch O.
+
+        Returns:
+            True if and only if the combined condition F holds, i.e. the message may be printed.
+        """
+        return not self._is_quiet and ((not is_verdict and show_user) or (is_verdict and self._show_verdict))
+
     def print(
         self,
         message: str,
         *,
-        level: LogLevel | Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = LogLevel.INFO,
+        level: LogLevel | Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = LogLevel.TRACE,
+        is_verdict: bool = False,
+        show_user: bool = False,
     ) -> None:
         """Prints a message to stdout and logs it simultaneously.
 
@@ -80,11 +221,16 @@ class Console:
             message: The string message to be displayed and logged.
             level: The logging level for the message. Accepts both LogLevel
                    enum members and their string representations.
-                   Defaults to LogLevel.INFO.
+                   Defaults to LogLevel.TRACE.
+            is_verdict: If True, this message is considered a
+                        verdict and its printing is controlled by the
+                        console’s `show_verdict` flag. Defaults to False.
+            show_user:  If True and `is_verdict=False`, allows
+                        printing non-verdict messages to stdout. Defaults to
+                        False.
         """
-        level_str = level.value.lower() if isinstance(level, LogLevel) else level.lower()
-        log_method = getattr(self._logger, level_str)
-        log_method(message)
+        level_num = logging.getLevelName(level if isinstance(level, LogLevel) else level)
+        self._logger.log(level_num, message, stacklevel=2)
 
-        if not self._is_silent:
+        if (not self._is_quiet) and ((not is_verdict and show_user) or (is_verdict and self._show_verdict)):
             print(message, file=self._stdout)