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

code_validator/core.py

@@ -1,100 +1,223 @@
+"""The core engine of the Python Code Validator.
+
+This module contains the main orchestrator class, `StaticValidator`, which is
+responsible for managing the entire validation lifecycle. It loads the source
+code and a set of JSON rules, then uses a factory-based component system to
+execute each rule and report the results.
+
+The core is designed to be decoupled from the specific implementations of rules,
+selectors, and constraints, allowing for high extensibility.
+
+Example:
+    To run a validation, you would typically use the CLI, but the core can also
+    be used programmatically:
+
+    .. code-block:: python
+
+        from code_validator import StaticValidator, AppConfig, LogLevel
+        from code_validator.output import Console, setup_logging
+        from pathlib import Path
+        import logging
+
+        logger = logging.getLogger(__name__)
+        console = Console(logger)
+        config = AppConfig(
+            solution_path=Path("path/to/solution.py"),
+            rules_path=Path("path/to/rules.json"),
+            log_level=LogLevel.INFO,
+            is_silent=False,
+            stop_on_first_fail=False
+        )
+
+        validator = StaticValidator(config, console)
+        is_valid = validator.run()
+
+        if is_valid:
+            print("Validation Passed!")
+        else:
+            print(f"Validation Failed. Errors in: {validator.failed_rules_id}")
+
+"""
+
 import ast
 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:
-    """Orchestrates the static validation process."""
+    """Orchestrates the static validation process.
+
+    This class is the main entry point for running a validation session. It
+    manages loading of source files and rules, parsing the code into an AST,
+    and iterating through the rules to execute them.
+
+    Attributes:
+        _config (AppConfig): The application configuration object.
+        _console (Console): The handler for all logging and stdout printing.
+        _rule_factory (RuleFactory): The factory responsible for creating rule objects.
+        _source_code (str): The raw text content of the Python file being validated.
+        _ast_tree (ast.Module | None): The Abstract Syntax Tree of the source code.
+        _rules (list[Rule]): A list of initialized, executable rule objects.
+        _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 validator with configuration and an output handler."""
+        """Initializes the StaticValidator.
+
+        Args:
+            config: An `AppConfig` object containing all necessary run
+                configurations, such as file paths and flags.
+            console: A `Console` object for handling all output.
+        """
         self._config = config
         self._console = console
+
         self._rule_factory = RuleFactory(self._console)
         self._source_code: str = ""
         self._ast_tree: ast.Module | None = None
-        self._validation_rules: list[Rule] = []
+        self._rules: list[Rule] = []
         self._failed_rules: list[int] = []
 
     @property
     def failed_rules_id(self) -> list[int]:
-        """Returns a list of rule IDs that failed during the last run."""
+        """list[int]: A list of rule IDs that failed during the last run."""
         return self._failed_rules
 
     def _load_source_code(self) -> None:
-        """Loads the content of the student's solution file."""
-        self._console.print(f"Reading source file: {self._config.solution_path}")
+        """Loads the content of the student's solution file into memory.
+
+        Raises:
+            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}", 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."""
-        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:
-            # Ищем правило check_syntax, чтобы вывести его кастомное сообщение
-            for rule in self._validation_rules:
-                if getattr(rule.config, "type", None) == "check_syntax":
-                    self._console.print(rule.config.message, level="ERROR")
-                    self._failed_rules.append(rule.config.rule_id)
-                    return False
-            # Если такого правила нет, выводим стандартное сообщение
-            self._console.print(f"Syntax Error found: {e}", level="ERROR")
-            return False
-
     def _load_and_parse_rules(self) -> None:
-        """Loads and parses the JSON file with validation rules."""
-        self._console.print(f"Loading rules from: {self._config.rules_path}")
+        """Loads and parses the JSON file into executable Rule objects.
+
+        This method reads the JSON rules file, validates its basic structure,
+        and then uses the `RuleFactory` to instantiate a list of concrete
+        Rule objects.
+
+        Raises:
+            FileNotFoundError: If the rules file does not exist.
+            RuleParsingError: If the JSON is malformed or a rule configuration
+                is invalid.
+        """
+        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._validation_rules = [self._rule_factory.create(rule) for rule in raw_rules]
-            self._console.print(f"Successfully parsed {len(self._validation_rules)} rules.")
+            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.", 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."""
+        """Runs the entire validation process from start to finish.
+
+        This is the main public method of the class. It orchestrates the
+        sequence of loading, parsing, and rule execution.
+
+        Returns:
+            bool: True if all validation rules passed, False otherwise.
+
+        Raises:
+            RuleParsingError: Propagated from loading/parsing steps.
+            FileNotFoundError: Propagated from loading steps.
+        """
         try:
             self._load_source_code()
-            self._load_and_parse_rules()  # Загружаем правила до парсинга AST
+            self._load_and_parse_rules()
 
             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
 
-        for rule in self._validation_rules:
-            # check_syntax уже обработан в _parse_ast_tree, пропускаем его
+        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="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="WARNING")
+                    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)

code_validator/rules_library/basic_rules.py

@@ -1,10 +1,10 @@
-# src/code_validator/rules_library/basic_rules.py
-
 """Contains concrete implementations of executable validation rules.
 
 This module defines the handler classes for both "short" (pre-defined) and
-"full" (custom selector/constraint) rules. Each class implements the `Rule`
-protocol and encapsulates the logic for a specific type of validation check.
+"full" (custom selector/constraint) rules. Each class in this module implements
+the `Rule` protocol from `definitions.py` and encapsulates the logic for a
+specific type of validation check. The `RuleFactory` uses these classes to
+instantiate the correct handler for each rule defined in a JSON file.
 """
 
 import ast
@@ -13,7 +13,7 @@ import sys
 
 from ..components.definitions import Constraint, Rule, Selector
 from ..config import FullRuleConfig, ShortRuleConfig
-from ..output import Console, LogLevel
+from ..output import Console, LogLevel, log_initialization
 
 
 class CheckSyntaxRule(Rule):
@@ -27,6 +27,7 @@ class CheckSyntaxRule(Rule):
         formally defined in the JSON configuration.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, config: ShortRuleConfig, console: Console):
         """Initializes the syntax check rule handler.
 
@@ -45,7 +46,7 @@ class CheckSyntaxRule(Rule):
         Returns:
             Always returns True.
         """
-        self._console.print(f"Rule {self.config.rule_id}: Syntax is valid.", level=LogLevel.DEBUG)
+        self._console.print(f"Rule {self.config.rule_id}: Syntax is valid.", level=LogLevel.INFO)
         return True
 
 
@@ -57,6 +58,7 @@ class CheckLinterRule(Rule):
     configurable via the 'params' field in the JSON rule.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, config: ShortRuleConfig, console: Console):
         """Initializes a PEP8 linter check rule handler."""
         self.config = config
@@ -77,10 +79,10 @@ class CheckLinterRule(Rule):
             True if no PEP8 violations are found, False otherwise.
         """
         if not source_code:
-            self._console.print("Source code is empty, skipping PEP8 check.", level="WARNING")
+            self._console.print("Source code is empty, skipping PEP8 check.", level=LogLevel.WARNING)
             return True
 
-        self._console.print(f"Rule {self.config.rule_id}: Running flake8 linter...", level="DEBUG")
+        self._console.print(f"Rule {self.config.rule_id}: Running PEP8 linter...", level=LogLevel.INFO)
 
         params = self.config.params
         args = [sys.executable, "-m", "flake8", "-"]
@@ -90,6 +92,8 @@ class CheckLinterRule(Rule):
         elif ignore_list := params.get("ignore"):
             args.append(f"--ignore={','.join(ignore_list)}")
 
+        self._console.print(f"Arguments for flake8: {args}", level=LogLevel.TRACE)
+
         try:
             process = subprocess.run(
                 args,
@@ -102,19 +106,21 @@ class CheckLinterRule(Rule):
 
             if process.returncode != 0 and process.stdout:
                 linter_output = process.stdout.strip()
-                self._console.print(f"Flake8 found issues:\n{linter_output}", level="DEBUG")
+                self._console.print(f"Flake8 found issues:\n{linter_output}", level=LogLevel.WARNING, show_user=True)
                 return False
             elif process.returncode != 0:
-                self._console.print(f"Flake8 exited with code {process.returncode}:\n{process.stderr}", level="ERROR")
+                self._console.print(
+                    f"Flake8 exited with code {process.returncode}:\n{process.stderr}", level=LogLevel.ERROR
+                )
                 return False
 
-            self._console.print("PEP8 check passed.", level="DEBUG")
+            self._console.print("PEP8 check passed.", level=LogLevel.INFO)
             return True
         except FileNotFoundError:
-            self._console.print("flake8 not found. Is it installed in the venv?", level="CRITICAL")
+            self._console.print("flake8 not found. Is it installed in the venv?", level=LogLevel.CRITICAL)
             return False
         except Exception as e:
-            self._console.print(f"An unexpected error occurred while running flake8: {e}", level="CRITICAL")
+            self._console.print(f"An unexpected error occurred while running flake8: {e}", level=LogLevel.CRITICAL)
             return False
 
 
@@ -132,6 +138,7 @@ class FullRuleHandler(Rule):
         _console (Console): The console handler for logging.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, config: FullRuleConfig, selector: Selector, constraint: Constraint, console: Console):
         """Initializes a full rule handler.
 
@@ -157,11 +164,11 @@ class FullRuleHandler(Rule):
             The boolean result of applying the constraint to the selected nodes.
         """
         if not tree:
-            self._console.print("AST not available, skipping rule.", level="WARNING")
+            self._console.print("AST not available, skipping rule.", level=LogLevel.WARNING)
             return True
 
-        self._console.print(f"Applying selector: {self._selector.__class__.__name__}", level="DEBUG")
+        self._console.print(f"Applying selector: {self._selector.__class__.__name__}", level=LogLevel.TRACE)
         selected_nodes = self._selector.select(tree)
 
-        self._console.print(f"Applying constraint: {self._constraint.__class__.__name__}", level="DEBUG")
+        self._console.print(f"Applying constraint: {self._constraint.__class__.__name__}", level=LogLevel.TRACE)
         return self._constraint.check(selected_nodes)