python-code-validator 0.1.1__py3-none-any.whl

code_validator/core.py

@@ -0,0 +1,100 @@
+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 .exceptions import RuleParsingError
+from .output import Console
+
+
+class StaticValidator:
+    """Orchestrates the static validation process."""
+
+    def __init__(self, config: AppConfig, console: Console):
+        """Initializes the validator with configuration and an output handler."""
+        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._failed_rules: list[int] = []
+
+    @property
+    def failed_rules_id(self) -> list[int]:
+        """Returns 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}")
+        try:
+            self._source_code = self._config.solution_path.read_text(encoding="utf-8")
+        except FileNotFoundError:
+            raise
+        except Exception as e:
+            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}")
+        try:
+            rules_data = json.loads(self._config.rules_path.read_text(encoding="utf-8"))
+            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.")
+        except json.JSONDecodeError as e:
+            raise RuleParsingError(f"Invalid JSON in rules file: {e}") from e
+        except FileNotFoundError:
+            raise
+
+    def run(self) -> bool:
+        """Runs the entire validation process."""
+        try:
+            self._load_source_code()
+            self._load_and_parse_rules()  # Загружаем правила до парсинга AST
+
+            if not self._parse_ast_tree():
+                return False
+
+        except (FileNotFoundError, RuleParsingError):
+            raise
+
+        for rule in self._validation_rules:
+            # check_syntax уже обработан в _parse_ast_tree, пропускаем его
+            if getattr(rule.config, "type", None) == "check_syntax":
+                continue
+
+            self._console.print(f"Executing rule: {rule.config.rule_id}", level=LogLevel.DEBUG)
+            is_passed = rule.execute(self._ast_tree, self._source_code)
+            if not is_passed:
+                self._console.print(rule.config.message, level="ERROR")
+                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")
+                    break
+
+        return not self._failed_rules

code_validator/exceptions.py

@@ -0,0 +1,48 @@
+"""Defines custom exceptions for the code validator application.
+
+These custom exception classes allow for more specific error handling and
+provide clearer, more informative error messages throughout the application.
+"""
+
+
+class CodeValidatorError(Exception):
+    """Base exception for all custom errors raised by this application."""
+
+    pass
+
+
+class RuleParsingError(CodeValidatorError):
+    """Raised when a validation rule in the JSON file is malformed or invalid.
+
+    This error indicates a problem with the configuration of a rule, not with
+    the code being validated.
+
+    Attributes:
+        rule_id (int | str | None): The ID of the rule that caused the error,
+            if available.
+    """
+
+    def __init__(self, message: str, rule_id: int | str | None = None):
+        """Initializes the RuleParsingError.
+
+        Args:
+            message (str): The specific error message describing the problem.
+            rule_id (int | str | None): The ID of the problematic rule.
+        """
+        self.rule_id = rule_id
+        if rule_id:
+            super().__init__(f"Error parsing rule '{rule_id}': {message}")
+        else:
+            super().__init__(f"Error parsing rules file: {message}")
+
+
+class ValidationFailedError(CodeValidatorError):
+    """Raised to signal that the source code did not pass validation.
+
+    Note:
+        Currently, this exception is defined but not actively raised, as the
+        application handles validation failure via exit codes in the CLI.
+        It is kept for potential future use in a library context.
+    """
+
+    pass

code_validator/output.py

@@ -0,0 +1,90 @@
+"""Handles all console output and logging for the application.
+
+This module provides a centralized way to manage user-facing messages and
+internal logging. It ensures that all output is consistent and can be
+controlled via configuration (e.g., log levels, silent mode).
+"""
+
+import logging
+import sys
+from typing import Literal
+
+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"
+
+
+def setup_logging(log_level: LogLevel) -> logging.Logger:
+    """Configures the root logger for the application.
+
+    Sets up the basic configuration for logging, including the level,
+    message format, and date format.
+
+    Args:
+        log_level: The minimum level of logs to display.
+
+    Returns:
+        The configured root logger instance.
+    """
+    logging.basicConfig(level=log_level, format=LOG_FORMAT, datefmt=DATE_FORMAT)
+    return logging.getLogger()
+
+
+class Console:
+    """A centralized handler for printing messages to stdout and logging.
+
+    This class abstracts all output operations, allowing for consistent
+    formatting and easy control over verbosity (e.g., silent mode). It ensures
+    that every user-facing message is also properly logged.
+
+    Attributes:
+        _logger (logging.Logger): The logger instance used for all log records.
+        _is_silent (bool): A flag to suppress printing to stdout.
+        _stdout (TextIO): The stream to write messages to (defaults to sys.stdout).
+
+    Example:
+        >>> import logging
+        >>> logger = logging.getLogger(__name__)
+        >>> console = Console(logger)
+        >>> console.print("This is an informational message.")
+        This is an informational message.
+        >>> console.print("This is a warning.", level="WARNING")
+        This is a warning.
+    """
+
+    def __init__(self, logger: logging.Logger, *, is_silent: bool = False):
+        """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.
+        """
+        self._logger = logger
+        self._is_silent = is_silent
+        self._stdout = sys.stdout
+
+    def print(
+        self,
+        message: str,
+        *,
+        level: LogLevel | Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = LogLevel.INFO,
+    ) -> None:
+        """Prints a message to stdout and logs it simultaneously.
+
+        The message is always sent to the logger with the specified level. It is
+        printed to the configured stdout stream only if the console is not in
+        silent mode.
+
+        Args:
+            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.
+        """
+        level_str = level.value.lower() if isinstance(level, LogLevel) else level.lower()
+        log_method = getattr(self._logger, level_str)
+        log_method(message)
+
+        if not self._is_silent:
+            print(message, file=self._stdout)

code_validator/rules_library/basic_rules.py

@@ -0,0 +1,167 @@
+# 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.
+"""
+
+import ast
+import subprocess
+import sys
+
+from ..components.definitions import Constraint, Rule, Selector
+from ..config import FullRuleConfig, ShortRuleConfig
+from ..output import Console, LogLevel
+
+
+class CheckSyntaxRule(Rule):
+    """Handles the 'check_syntax' short rule.
+
+    Note:
+        The actual syntax validation is performed preemptively in the core
+        validator engine when it calls `ast.parse()`. Therefore, this rule's
+        `execute` method will only be called if the syntax is already valid.
+        Its primary purpose is to exist so that a `check_syntax` rule can be
+        formally defined in the JSON configuration.
+    """
+
+    def __init__(self, config: ShortRuleConfig, console: Console):
+        """Initializes the syntax check rule handler.
+
+        Args:
+            config: The configuration object for this short rule.
+            console: The console handler for output.
+        """
+        self.config = config
+        self._console = console
+
+    def execute(self, tree: ast.Module | None, source_code: str | None = None) -> bool:
+        """Confirms that syntax is valid.
+
+        This method is guaranteed to be called only after a successful AST parsing.
+
+        Returns:
+            Always returns True.
+        """
+        self._console.print(f"Rule {self.config.rule_id}: Syntax is valid.", level=LogLevel.DEBUG)
+        return True
+
+
+class CheckLinterRule(Rule):
+    """Handles the 'check_linter_pep8' short rule by running flake8.
+
+    This rule executes the `flake8` linter as an external subprocess on the
+    source code to check for style and common programming errors. It is
+    configurable via the 'params' field in the JSON rule.
+    """
+
+    def __init__(self, config: ShortRuleConfig, console: Console):
+        """Initializes a PEP8 linter check rule handler."""
+        self.config = config
+        self._console = console
+
+    def execute(self, tree: ast.Module | None, source_code: str | None = None) -> bool:
+        """Executes the flake8 linter on the source code via a subprocess.
+
+        It constructs a command-line call to `flake8`, passing the source code
+        via stdin. This approach ensures isolation and uses flake8's stable
+        CLI interface.
+
+        Args:
+            tree: Not used by this rule.
+            source_code: The raw source code string to be linted.
+
+        Returns:
+            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")
+            return True
+
+        self._console.print(f"Rule {self.config.rule_id}: Running flake8 linter...", level="DEBUG")
+
+        params = self.config.params
+        args = [sys.executable, "-m", "flake8", "-"]
+
+        if select_list := params.get("select"):
+            args.append(f"--select={','.join(select_list)}")
+        elif ignore_list := params.get("ignore"):
+            args.append(f"--ignore={','.join(ignore_list)}")
+
+        try:
+            process = subprocess.run(
+                args,
+                input=source_code,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                check=False,
+            )
+
+            if process.returncode != 0 and process.stdout:
+                linter_output = process.stdout.strip()
+                self._console.print(f"Flake8 found issues:\n{linter_output}", level="DEBUG")
+                return False
+            elif process.returncode != 0:
+                self._console.print(f"Flake8 exited with code {process.returncode}:\n{process.stderr}", level="ERROR")
+                return False
+
+            self._console.print("PEP8 check passed.", level="DEBUG")
+            return True
+        except FileNotFoundError:
+            self._console.print("flake8 not found. Is it installed in the venv?", level="CRITICAL")
+            return False
+        except Exception as e:
+            self._console.print(f"An unexpected error occurred while running flake8: {e}", level="CRITICAL")
+            return False
+
+
+class FullRuleHandler(Rule):
+    """Handles a full, custom rule composed of a selector and a constraint.
+
+    This class acts as a generic executor for complex rules. It does not contain
+    any specific validation logic itself but instead orchestrates the interaction
+    between a Selector and a Constraint object.
+
+    Attributes:
+        config (FullRuleConfig): The dataclass object holding the rule's config.
+        _selector (Selector): The selector object responsible for finding nodes.
+        _constraint (Constraint): The constraint object for checking the nodes.
+        _console (Console): The console handler for logging.
+    """
+
+    def __init__(self, config: FullRuleConfig, selector: Selector, constraint: Constraint, console: Console):
+        """Initializes a full rule handler.
+
+        Args:
+            config: The configuration for the full rule.
+            selector: An initialized Selector object.
+            constraint: An initialized Constraint object.
+            console: The console handler for logging.
+        """
+        self.config = config
+        self._selector = selector
+        self._constraint = constraint
+        self._console = console
+
+    def execute(self, tree: ast.Module | None, source_code: str | None = None) -> bool:
+        """Executes the rule by running the selector and applying the constraint.
+
+        Args:
+            tree: The enriched AST of the source code.
+            source_code: Not used by this rule.
+
+        Returns:
+            The boolean result of applying the constraint to the selected nodes.
+        """
+        if not tree:
+            self._console.print("AST not available, skipping rule.", level="WARNING")
+            return True
+
+        self._console.print(f"Applying selector: {self._selector.__class__.__name__}", level="DEBUG")
+        selected_nodes = self._selector.select(tree)
+
+        self._console.print(f"Applying constraint: {self._constraint.__class__.__name__}", level="DEBUG")
+        return self._constraint.check(selected_nodes)

code_validator/rules_library/constraint_logic.py

@@ -0,0 +1,257 @@
+"""Contains concrete implementations of all Constraint components.
+
+Each class in this module implements the `Constraint` protocol and encapsulates
+the logic for a specific condition that can be checked against a list of
+AST nodes found by a Selector.
+"""
+
+import ast
+from typing import Any
+
+from ..components.ast_utils import get_full_name
+from ..components.definitions import Constraint
+
+
+class IsRequiredConstraint(Constraint):
+    """Checks that at least one node was found by the selector.
+
+    This constraint is used to enforce the presence of a required language
+    construct. It can also check for an exact number of occurrences.
+
+    JSON Params:
+        count (int, optional): If provided, checks if the number of found
+            nodes is exactly equal to this value.
+    """
+
+    def __init__(self, **kwargs: Any):
+        """Initializes the constraint.
+
+        Args:
+            **kwargs: Configuration for the constraint, e.g., 'count'.
+        """
+        self.expected_count = kwargs.get("count")
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if the list of nodes is not empty or matches expected count."""
+        if self.expected_count is not None:
+            return len(nodes) == self.expected_count
+        return len(nodes) > 0
+
+
+class IsForbiddenConstraint(Constraint):
+    """Checks that no nodes were found by the selector.
+
+    This is the inverse of `IsRequiredConstraint` and is used to forbid certain
+    constructs, such as specific function calls or imports.
+    """
+
+    def __init__(self, **kwargs: Any):
+        """Initializes the constraint."""
+        pass
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if the list of nodes is empty."""
+        return not nodes
+
+
+class MustInheritFromConstraint(Constraint):
+    """Checks that a ClassDef node inherits from a specific parent class.
+
+    This constraint is designed to work with a selector that returns a single
+    `ast.ClassDef` node. It can resolve both simple names (e.g., `Exception`)
+    and attribute-based names (e.g., `arcade.Window`).
+
+    JSON Params:
+        parent_name (str): The expected name of the parent class.
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.parent_name_to_find: str | None = kwargs.get("parent_name")
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if the found class node inherits from the specified parent."""
+        if not self.parent_name_to_find or len(nodes) != 1:
+            return False
+
+        node = nodes[0]
+        if not isinstance(node, ast.ClassDef):
+            return False
+
+        for base in node.bases:
+            full_name = self._get_full_attribute_name(base)
+            if full_name == self.parent_name_to_find:
+                return True
+        return False
+
+    @staticmethod
+    def _get_full_attribute_name(node: ast.AST) -> str | None:
+        """Recursively builds the full attribute name from a base class node."""
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            base = MustInheritFromConstraint._get_full_attribute_name(node.value)
+            return f"{base}.{node.attr}" if base else node.attr
+        return None
+
+
+class MustBeTypeConstraint(Constraint):
+    """Checks the type of the value in an assignment statement.
+
+    It works for simple literals (numbers, strings, lists, etc.) and for
+    calls to built-in type constructors (e.g., `list()`, `dict()`).
+
+    JSON Params:
+        expected_type (str): The name of the type, e.g., "str", "int", "list".
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.expected_type_str: str | None = kwargs.get("expected_type")
+        self.type_map = {
+            "str": str,
+            "int": int,
+            "float": float,
+            "list": list,
+            "dict": dict,
+            "bool": bool,
+            "set": set,
+            "tuple": tuple,
+        }
+        self.constructor_map = {t: t for t in self.type_map}
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if the assigned value has the expected Python type."""
+        if not nodes or not self.expected_type_str:
+            return False
+        expected_py_type = self.type_map.get(self.expected_type_str)
+        if not expected_py_type:
+            return False
+
+        for node in nodes:
+            value_node = getattr(node, "value", None)
+            if value_node is None:
+                continue
+
+            if self._is_correct_type(value_node, expected_py_type):
+                continue
+            return False
+        return True
+
+    def _is_correct_type(self, value_node: ast.AST, expected_py_type: type) -> bool:
+        """Checks a single value node against the expected type."""
+        try:
+            assigned_value = ast.literal_eval(value_node)
+            if isinstance(assigned_value, expected_py_type):
+                return True
+        except (ValueError, TypeError, SyntaxError):
+            pass
+
+        if isinstance(value_node, ast.Call):
+            func_name = getattr(value_node.func, "id", None)
+            expected_constructor = self.constructor_map.get(self.expected_type_str)
+            if func_name == expected_constructor:
+                return True
+        return False
+
+
+class NameMustBeInConstraint(Constraint):
+    """Checks if the name of a found node is in an allowed list of names.
+
+    This is useful for rules like restricting global variables to a pre-defined
+    set of constants.
+
+    JSON Params:
+        allowed_names (list[str]): A list of strings containing the allowed names.
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.allowed_names = set(kwargs.get("allowed_names", []))
+
+    @staticmethod
+    def _get_name(node: ast.AST) -> str | None:
+        """Gets a name from various node types."""
+        if isinstance(node, (ast.Assign, ast.AnnAssign)):
+            target = node.targets[0] if isinstance(node, ast.Assign) else node.target
+            return get_full_name(target)
+        return getattr(node, "name", getattr(node, "id", None))
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if all found node names are in the allowed set."""
+        for node in nodes:
+            name_to_check = self._get_name(node)
+            if name_to_check and name_to_check not in self.allowed_names:
+                return False
+        return True
+
+
+class ValueMustBeInConstraint(Constraint):
+    """Checks if the value of a found literal node is in an allowed list.
+
+    This is primarily used to check for "magic numbers" or "magic strings",
+    allowing only a specific set of literal values to be present.
+
+    JSON Params:
+        allowed_values (list): A list of allowed literal values (e.g., [0, 1]).
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.allowed_values = set(kwargs.get("allowed_values", []))
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if all found literal values are in the allowed set."""
+        if not self.allowed_values:
+            return not nodes
+
+        for node in nodes:
+            if isinstance(node, ast.Constant):
+                if node.value not in self.allowed_values:
+                    return False
+            else:
+                return False
+        return True
+
+
+class MustHaveArgsConstraint(Constraint):
+    """Checks that a FunctionDef node has a specific signature.
+
+    This constraint can check for an exact number of arguments or for an
+    exact sequence of argument names, ignoring `self` or `cls` in methods.
+
+    JSON Params:
+        count (int, optional): The exact number of arguments required.
+        names (list[str], optional): The exact list of argument names in order.
+        exact_match (bool, optional): Used with `names`. If False, only checks
+            for presence, not for exact list match. Defaults to True.
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.expected_count: int | None = kwargs.get("count")
+        self.expected_names: list[str] | None = kwargs.get("names")
+        self.exact_match: bool = kwargs.get("exact_match", True)
+
+    def check(self, nodes: list[ast.AST]) -> bool:
+        """Checks if the function signature matches the criteria."""
+        if not nodes:
+            return True
+        if not all(isinstance(node, ast.FunctionDef) for node in nodes):
+            return False
+
+        for node in nodes:
+            actual_arg_names = [arg.arg for arg in node.args.args]
+            if hasattr(node, "parent") and isinstance(node.parent, ast.ClassDef):
+                if actual_arg_names:
+                    actual_arg_names.pop(0)
+
+            if not self._check_single_node(actual_arg_names):
+                return False
+        return True
+
+    def _check_single_node(self, actual_arg_names: list[str]) -> bool:
+        """Checks the argument list of a single function."""
+        if self.expected_names is not None:
+            if self.exact_match:
+                return actual_arg_names == self.expected_names
+            else:
+                return set(self.expected_names).issubset(set(actual_arg_names))
+        elif self.expected_count is not None:
+            return len(actual_arg_names) == self.expected_count
+        return False