fast-validators 0.1.0__py3-none-win_amd64.whl

fast_validators/__init__.py

@@ -0,0 +1,24 @@
+"""
+Validators package for content validation in file operations.
+
+This package provides a validation system for different file formats
+to ensure content integrity after text replacement operations.
+"""
+
+from .base_validator import BaseValidator
+from .json_validator import JsonValidator
+from .yaml_validator import YamlValidator
+from .php_validator import PhpValidator
+from .go_validator import GoValidator
+from .js_ts_validator import JS_TS_Validator
+from .validators_catalog import ValidatorsCatalog
+
+__all__ = [
+    'BaseValidator',
+    'JsonValidator',
+    'YamlValidator',
+    'PhpValidator',
+    'GoValidator',
+    'JS_TS_Validator',
+    'ValidatorsCatalog'
+]

fast_validators/_validator_tree.py

@@ -0,0 +1,73 @@
+import os
+import ctypes
+import platform
+from enum import IntEnum
+from pathlib import Path
+
+
+class Language(IntEnum):
+    CPP = 0
+    # _DEPRECATED_JAVASCRIPT = 1
+    # _DEPRECATED_TYPESCRIPT = 2
+    PHP = 3
+    GO = 4
+    # _DEPRECATED_TSX = 5
+
+
+def validate_syntax(source_code: str, language: Language, filename: str = "<code>") -> tuple[bool, str]:
+    # filename is used for display in error messages
+
+    lang_id = int(language)
+    debug_dump = False
+    c_result = _lib.validate_code(
+        source_code.encode("utf-8"),
+        filename.encode("utf-8"),
+        lang_id,
+        debug_dump,
+    )
+    try:
+        if not c_result.has_error:
+            return True, ""
+        return False, c_result.formatted_report.decode("utf-8")
+    finally:
+        _lib.free_validation_result(c_result)
+
+
+# --- Private ctypes Implementation ---
+
+class _Validation_Result(ctypes.Structure):
+    _fields_ = [
+        ("has_error",        ctypes.c_bool  ),
+        ("lineno",           ctypes.c_uint32),
+        ("column",           ctypes.c_uint32),
+        ("end_lineno",       ctypes.c_uint32),
+        ("end_column",       ctypes.c_uint32),
+        ("message",          ctypes.c_char_p),
+        ("formatted_report", ctypes.c_char_p),
+    ]
+
+
+CURRENT_OS = platform.system().lower()
+
+def _load_library(name: str):
+    if CURRENT_OS == "darwin":
+        LIB_EXT = ".dylib"
+    elif CURRENT_OS == "windows":
+        LIB_EXT = ".dll"
+    else:
+        LIB_EXT = ".so"
+
+    lib_path = Path(__file__).parent / f"{name}{LIB_EXT}"
+    if not lib_path.exists():
+        raise ImportError(f"Cannot find compiled library at {lib_path}. "
+                          "Please build it first.")
+
+    return ctypes.CDLL(os.fsdecode(lib_path))
+
+_lib = _load_library("_validator_tree")
+
+_lib.validate_code.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint8, ctypes.c_bool]
+_lib.validate_code.restype = _Validation_Result
+
+_lib.free_validation_result.argtypes = [_Validation_Result]
+_lib.free_validation_result.restype = None

fast_validators/base_validator.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+class BaseValidator(ABC):
+    """
+    Abstract base class for content validators.
+    Each validator checks specific file format validity.
+    """
+    
+    @abstractmethod
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        """
+        Validate the content for correctness.
+        
+        Args:
+            new_text: The content to validate
+            filename: The target filename (for context)
+            
+        Returns:
+            tuple: (is_valid: bool, error_message: str)
+                - is_valid: True if content is valid, False otherwise
+                - error_message: Empty string if valid, error description if invalid
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def supported_extensions(self) -> list[str]:
+        """Return list of file extensions this validator supports"""
+        pass
+    
+    def get_validation_name(self) -> str:
+        """Return human-readable name of this validator"""
+        return self.__class__.__name__

fast_validators/go_validator.py

@@ -0,0 +1,25 @@
+from .base_validator import BaseValidator
+
+try:
+    from ._validator_tree import validate_syntax, Language
+    LIBRARY_MISSING_ERROR = ""
+except (ImportError, OSError) as e:
+    LIBRARY_MISSING_ERROR = (
+        "The GO validator component could not be loaded.\n"
+        "Please ensure the library has been built by running 'python nob.py build'.\n"
+        f"Details: {e}"
+    )
+
+class GoValidator(BaseValidator):
+    @property
+    def supported_extensions(self) -> list[str]:
+        return [".go"]
+
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        if LIBRARY_MISSING_ERROR:
+            return False, LIBRARY_MISSING_ERROR
+
+        try:
+            return validate_syntax(new_text, Language.GO, filename)
+        except Exception as e:
+            return False, f"An unexpected error occurred while validating {filename}: {str(e)}"

fast_validators/js_ts_validator.py

@@ -0,0 +1,50 @@
+import ctypes
+from pathlib import Path
+from .base_validator import BaseValidator
+
+try:
+    from ._validator_tree import _load_library
+
+    _lib = _load_library("_validator_js_ts")
+
+    _lib.validate.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+    _lib.validate.restype = ctypes.c_void_p
+
+    _lib.free_result.argtypes = [ctypes.c_void_p]
+    _lib.free_result.restype = None
+
+    LIBRARY_MISSING_ERROR = ""
+except (ImportError, OSError) as e:
+    LIBRARY_MISSING_ERROR = (
+        "The JavaScript/TypeScript validator could not be loaded. "
+        "Please ensure the library has been built.\n"
+        f"Details: {e}"
+    )
+
+
+class JS_TS_Validator(BaseValidator):
+    @property
+    def supported_extensions(self) -> list[str]:
+        return ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts']
+
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        if LIBRARY_MISSING_ERROR:
+            return False, LIBRARY_MISSING_ERROR
+
+        try:
+            error_address = _lib.validate(
+                new_text.encode("utf-8"),
+                filename.encode("utf-8")
+            )
+
+            try:
+                if not error_address:
+                    return True, ""
+
+                error_string_ptr = ctypes.cast(error_address, ctypes.c_char_p)
+                error_message = error_string_ptr.value.decode("utf-8")
+                return False, error_message
+            finally:
+                _lib.free_result(error_address)
+        except Exception as e:
+            return False, f"An unexpected error occurred while validating {filename}: {str(e)}"

fast_validators/json_validator.py

@@ -0,0 +1,32 @@
+import json
+from .base_validator import BaseValidator
+
+class JsonValidator(BaseValidator):
+    """Validator for JSON file content"""
+
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        """
+        Validate JSON syntax and structure.
+
+        Returns:
+            tuple: (is_valid, error_message)
+        """
+        try:
+            json.loads(new_text)
+            return True, ""
+        except json.JSONDecodeError as e:
+            error_msg = self._format_json_error(e, filename)
+            return False, error_msg
+        except Exception as e:
+            return False, f"Unexpected error validating JSON in {filename}: {str(e)}"
+
+    @property
+    def supported_extensions(self) -> list[str]:
+        return ['.json', '.jsonl', '.geojson']
+
+    def _format_json_error(self, error: json.JSONDecodeError, filename: str) -> str:
+        """Format JSON parsing error for user display"""
+        return (f"JSON validation failed for {filename}:\n"
+                f"Error: {error.msg}\n"
+                f"Line: {error.lineno}, Column: {error.colno}\n"
+                f"Position: {error.pos}")

fast_validators/php_validator.py

@@ -0,0 +1,25 @@
+from .base_validator import BaseValidator
+
+try:
+    from ._validator_tree import validate_syntax, Language
+    LIBRARY_MISSING_ERROR = ""
+except (ImportError, OSError) as e:
+    LIBRARY_MISSING_ERROR = (
+        "The PHP validator component could not be loaded.\n"
+        "Please ensure the library has been built by running 'python nob.py build'.\n"
+        f"Details: {e}"
+    )
+
+class PhpValidator(BaseValidator):
+    @property
+    def supported_extensions(self) -> list[str]:
+        return [".php", ".phtml", ".phps", ".php3", ".php4", ".php5", ".php7", ".php8", ".pht"]
+
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        if LIBRARY_MISSING_ERROR:
+            return False, LIBRARY_MISSING_ERROR
+
+        try:
+            return validate_syntax(new_text, Language.PHP, filename)
+        except Exception as e:
+            return False, f"An unexpected error occurred while validating {filename}: {str(e)}"

fast_validators/python_validator.py

@@ -0,0 +1,190 @@
+import ast
+import re
+import sys
+from typing import List, Tuple, Set
+from .base_validator import BaseValidator
+
+class PythonValidator(BaseValidator):
+    """Validator for Python code content"""
+    
+    # Potentially dangerous patterns to check for
+    DANGEROUS_PATTERNS = [
+        (r'\beval\s*\(', 'Use of eval() can be dangerous'),
+        (r'\bexec\s*\(', 'Use of exec() can be dangerous'),
+        (r'__import__\s*\(', 'Dynamic imports with __import__ should be used carefully'),
+        (r'\bcompile\s*\(', 'Use of compile() should be reviewed'),
+        (r'subprocess\.call\s*\(.*shell\s*=\s*True', 'subprocess with shell=True can be dangerous'),
+        (r'os\.system\s*\(', 'os.system() can be dangerous, consider subprocess instead'),
+        (r'input\s*\(.*\beval\b', 'eval() in input() is dangerous'),
+    ]
+    
+    def validate(self, new_text: str, filename: str) -> Tuple[bool, str]:
+        """
+        Validate Python code syntax and basic quality checks.
+        
+        Returns:
+            tuple: (is_valid, error_message)
+        """
+        try:
+            # Handle empty or whitespace-only content
+            if not new_text or new_text.strip() == "":
+                return True, ""
+            
+            # Check if file contains only comments and whitespace
+            if self._is_comments_only(new_text):
+                return True, ""
+            
+            # 1. Syntax validation using AST
+            syntax_valid, syntax_error = self._validate_syntax(new_text, filename)
+            if not syntax_valid:
+                return False, syntax_error
+            
+            # 2. Import validation
+            import_valid, import_error = self._validate_imports(new_text, filename)
+            if not import_valid:
+                return False, import_error
+            
+            # 3. Basic code quality checks
+            quality_valid, quality_error = self._validate_code_quality(new_text, filename)
+            if not quality_valid:
+                return False, quality_error
+            
+            # 4. Security checks (warnings, not failures)
+            security_warnings = self._check_security_patterns(new_text, filename)
+            if security_warnings:
+                # For now, just return warnings as part of error message
+                # In production, you might want to handle warnings differently
+                return False, f"Security warnings in {filename}:\n" + "\n".join(security_warnings)
+            
+            return True, ""
+            
+        except Exception as e:
+            return False, f"Unexpected error validating Python code in {filename}: {str(e)}"
+    
+    @property
+    def supported_extensions(self) -> List[str]:
+        return ['.py', '.pyw']
+    
+    def _validate_syntax(self, code: str, filename: str) -> Tuple[bool, str]:
+        """Validate Python syntax using AST parsing"""
+        try:
+            ast.parse(code, filename=filename)
+            return True, ""
+        except SyntaxError as e:
+            # Check if this is a tabs/spaces mixing error
+            if "inconsistent use of tabs and spaces" in str(e):
+                return False, f"Mixed tabs and spaces for indentation in {filename}"
+            error_msg = self._format_syntax_error(e, filename)
+            return False, error_msg
+        except Exception as e:
+            return False, f"Syntax validation failed for {filename}: {str(e)}"
+    
+    def _validate_imports(self, code: str, filename: str) -> Tuple[bool, str]:
+        """Validate import statements"""
+        try:
+            tree = ast.parse(code, filename=filename)
+            
+            # Check for problematic import patterns
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name.startswith('.'):
+                            return False, f"Invalid import in {filename} line {node.lineno}: relative import '{alias.name}' not allowed in import statement"
+                
+                elif isinstance(node, ast.ImportFrom):
+                    # Check for excessive relative imports (4 or more dots)
+                    if node.level and node.level >= 4:
+                        return False, f"Excessive relative import in {filename} line {node.lineno}: too many parent directory references"
+                    
+                    # Check for star imports (warning level)
+                    for alias in node.names:
+                        if alias.name == '*':
+                            # This could be a warning instead of error
+                            pass
+            
+            return True, ""
+            
+        except Exception as e:
+            return False, f"Import validation failed for {filename}: {str(e)}"
+    
+    def _validate_code_quality(self, code: str, filename: str) -> Tuple[bool, str]:
+        """Basic code quality checks"""
+        lines = code.split('\n')
+        
+        # Check for mixed tabs and spaces
+        has_tabs = any('\t' in line for line in lines)
+        has_spaces_indent = any(line.startswith('    ') for line in lines if line.strip())
+        
+        if has_tabs and has_spaces_indent:
+            return False, f"Mixed tabs and spaces for indentation in {filename}"
+        
+        # Check for extremely long lines (configurable threshold)
+        max_line_length = 1000
+        for i, line in enumerate(lines, 1):
+            if len(line) > max_line_length:
+                return False, f"Line too long in {filename} line {i}: {len(line)} characters (max {max_line_length})"
+        
+        # Check for basic structure issues
+        try:
+            tree = ast.parse(code, filename=filename)
+            
+            # Check for functions/classes with no content (only pass/docstring)
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                    if len(node.body) == 1:
+                        first_stmt = node.body[0]
+                        if isinstance(first_stmt, ast.Pass):
+                            # This is just a warning, not an error
+                            pass
+                        elif isinstance(first_stmt, ast.Expr) and isinstance(first_stmt.value, ast.Constant):
+                            # Just a docstring, might want to warn
+                            pass
+            
+            return True, ""
+            
+        except Exception as e:
+            return False, f"Code quality validation failed for {filename}: {str(e)}"
+    
+    def _check_security_patterns(self, code: str, filename: str) -> List[str]:
+        """Check for potentially dangerous code patterns"""
+        warnings = []
+        
+        for pattern, message in self.DANGEROUS_PATTERNS:
+            matches = re.finditer(pattern, code, re.IGNORECASE | re.MULTILINE)
+            for match in matches:
+                # Find line number
+                line_num = code[:match.start()].count('\n') + 1
+                warnings.append(f"Line {line_num}: {message}")
+        
+        return warnings
+    
+    def _is_comments_only(self, code: str) -> bool:
+        """Check if code contains only comments and whitespace"""
+        lines = code.split('\n')
+        for line in lines:
+            stripped = line.strip()
+            if stripped and not stripped.startswith('#'):
+                return False
+        return True
+    
+    def _format_syntax_error(self, error: SyntaxError, filename: str) -> str:
+        """Format syntax error for user display"""
+        error_details = [f"Python syntax error in {filename}:"]
+        
+        if error.msg:
+            error_details.append(f"Error: {error.msg}")
+        
+        if error.lineno:
+            error_details.append(f"Line: {error.lineno}")
+        
+        if error.offset:
+            error_details.append(f"Column: {error.offset}")
+        
+        if error.text:
+            error_details.append(f"Code: {error.text.strip()}")
+            if error.offset:
+                # Add pointer to error location
+                pointer = ' ' * (error.offset - 1) + '^'
+                error_details.append(f"      {pointer}")
+        
+        return "\n".join(error_details)

fast_validators/validators_catalog.py

@@ -0,0 +1,78 @@
+import os
+from .base_validator import BaseValidator
+from .json_validator import JsonValidator
+from .yaml_validator import YamlValidator
+from .python_validator import PythonValidator
+from .php_validator import PhpValidator
+from .go_validator import GoValidator
+from .js_ts_validator import JS_TS_Validator
+
+class ValidatorsCatalog:
+    """
+    Central registry for all file content validators.
+    Uses simple includes instead of complex registration methods.
+    """
+
+    def __init__(self):
+        # Simple includes - just instantiate the validators we want
+        self._validators = [
+            JsonValidator(),
+            YamlValidator(),
+            PythonValidator(),
+            PhpValidator(),
+            GoValidator(),
+            JS_TS_Validator(),
+        ]
+
+        # Build extension to validator mapping for fast lookup
+        self._extension_map = {}
+        for validator in self._validators:
+            for ext in validator.supported_extensions:
+                self._extension_map[ext.lower()] = validator
+
+    def validate_content(self, new_text: str, filename: str) -> tuple[bool, str]:
+        """
+        Validate content for a specific file.
+
+        Args:
+            new_text: The new content to validate
+            filename: The target filename (used to determine validator)
+
+        Returns:
+            tuple: (is_valid: bool, error_message: str)
+        """
+        validator = self.get_validator_for_file(filename)
+        if validator is None:
+            # No validator found for this file type - consider it valid
+            return True, ""
+
+        return validator.validate(new_text, filename)
+
+    def get_validator_for_file(self, filename: str) -> BaseValidator:
+        """Get appropriate validator based on file extension"""
+        if not filename:
+            return None
+
+        # Extract file extension
+        _, ext = os.path.splitext(filename)
+        ext = ext.lower()
+
+        return self._extension_map.get(ext)
+
+    def get_supported_extensions(self) -> list[str]:
+        """Get list of all supported file extensions"""
+        return list(self._extension_map.keys())
+
+    def get_validator(self, filename: str) -> BaseValidator:
+        """Get appropriate validator based on file extension (alias for get_validator_for_file)"""
+        return self.get_validator_for_file(filename)
+
+    def get_validators_info(self) -> list[dict]:
+        """Get information about all registered validators"""
+        info = []
+        for validator in self._validators:
+            info.append({
+                'name': validator.get_validation_name(),
+                'extensions': validator.supported_extensions
+            })
+        return info

fast_validators/yaml_validator.py

@@ -0,0 +1,85 @@
+import yaml
+from .base_validator import BaseValidator
+
+class YamlValidator(BaseValidator):
+    """Validator for YAML file content"""
+
+    def validate(self, new_text: str, filename: str) -> tuple[bool, str]:
+        """
+        Validate YAML syntax and structure.
+
+        Returns:
+            tuple: (is_valid, error_message)
+        """
+        try:
+            # Handle empty or whitespace-only content
+            if not new_text or new_text.strip() == "":
+                return True, ""
+
+            # Check for duplicate keys using a custom loader
+            self._check_duplicate_keys(new_text)
+
+            # Load YAML with safe loader - handle multi-document YAML
+            docs = list(yaml.safe_load_all(new_text))
+            return True, ""
+        except yaml.YAMLError as e:
+            error_msg = self._format_yaml_error(e, filename)
+            return False, error_msg
+        except Exception as e:
+            return False, f"Unexpected error validating YAML in {filename}: {str(e)}"
+
+    @property
+    def supported_extensions(self) -> list[str]:
+        return ['.yaml', '.yml']
+
+    def _check_duplicate_keys(self, yaml_content: str):
+        """Check for duplicate keys in YAML content"""
+        class DuplicateKeyLoader(yaml.SafeLoader):
+            def construct_mapping(self, node, deep=False):
+                mapping = {}
+                for key_node, value_node in node.value:
+                    key = self.construct_object(key_node, deep=deep)
+                    if key in mapping:
+                        raise yaml.constructor.ConstructorError(
+                            None, None,
+                            f"found duplicate key: {key}",
+                            key_node.start_mark
+                        )
+                    value = self.construct_object(value_node, deep=deep)
+                    mapping[key] = value
+                return mapping
+
+        try:
+            # Load all documents in case of multi-document YAML
+            docs = list(yaml.load_all(yaml_content, Loader=DuplicateKeyLoader))
+        except yaml.constructor.ConstructorError as e:
+            if "duplicate key" in str(e):
+                raise yaml.YAMLError(f"duplicate key found: {str(e)}")
+
+    def _format_yaml_error(self, error: yaml.YAMLError, filename: str) -> str:
+        """Format YAML parsing error for user display"""
+        error_details = []
+        error_details.append(f"yaml validation failed for {filename}:")
+
+        if hasattr(error, 'problem'):
+            problem = error.problem
+            # Replace \\t with 'tab' for better readability - handle all possible patterns
+            problem = problem.replace("'\\\\t'", "'tab'")
+            problem = problem.replace('\\\\t', 'tab')
+            problem = problem.replace("'\\t'", "'tab'")
+            problem = problem.replace('\\t', 'tab')
+            error_details.append(f"problem: {problem}")
+
+        if hasattr(error, 'problem_mark'):
+            mark = error.problem_mark
+            error_details.append(f"line: {mark.line + 1}, column: {mark.column + 1}")
+
+        if hasattr(error, 'context'):
+            error_details.append(f"context: {error.context}")
+
+        # Handle duplicate key errors
+        error_str = str(error)
+        if "duplicate key" in error_str.lower():
+            error_details = [f"yaml validation failed for {filename}:", f"duplicate key detected"]
+
+        return "\n".join(error_details)

fast_validators-0.1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: fast_validators
+Version: 0.1.0
+Summary: Code validators (manual wheel build)
+Requires-Dist: PyYAML (~=6.0)

fast_validators-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+fast_validators-0.1.0.dist-info/METADATA,sha256=PxLy04HTrokj1OeseiRteVSc_hO6nR4miMPg5NG_4Hk,140
+fast_validators-0.1.0.dist-info/RECORD,,
+fast_validators-0.1.0.dist-info/WHEEL,sha256=_bOreq1gx9SJE5Dzh5pOxe8hEzRe-UVEK4LPtxfwHI0,160
+fast_validators/__init__.py,sha256=NYsyPj5Z127_nvU5oyl6lIIgxzHEfzj2NdMG-ISxDmY,691
+fast_validators/_validator_js_ts.dll,sha256=Ti_YrlqSLAHpQ6usgODti4miePdGrGi388jPL12sT_w,18341888
+fast_validators/_validator_tree.dll,sha256=c44X05uSjdZy5PlfkxQfUHMgOAznGM2jn1oShtenxyY,6605312
+fast_validators/_validator_tree.py,sha256=DTRCMUdnaigXNH8bI9fgo3ir599T0jfA4UEUILP51JA,2087
+fast_validators/base_validator.py,sha256=7F_E5Xio837F2AudbDlW2wZ84amVHop-ytCt6LVZAiA,1078
+fast_validators/go_validator.py,sha256=geAS04Dl9s-21CII7Q-xpE0jpC1ojp0ZwQZru_hMh-w,893
+fast_validators/js_ts_validator.py,sha256=QKpQ_hCwcAQv4Rhdp7A9iuW9vy6aCfS5109-Jih6nEc,1651
+fast_validators/json_validator.py,sha256=PfLMaenjRh25jnK1S7qF5qtQjp4bO1L_HN-Hi_QGsZY,1162
+fast_validators/php_validator.py,sha256=O7bVc4vVYgSMouMiGACZZCw9FtiYPwaSdbFQM41BJl4,969
+fast_validators/python_validator.py,sha256=cbiotwfeLXugHRk4wyaSxUdN_h43UHPyCvZiXzKyrhQ,8439
+fast_validators/validators_catalog.py,sha256=lYWTWGUgur3-hLGQoQ2yg7FCTW2Vls4HDm5Nr6GLTxo,2772
+fast_validators/yaml_validator.py,sha256=KyRCIYHyQtTeYmvSJoTtchDs_L-DveQ5zy5T_RJ8ang,3519

fast_validators-0.1.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: ship.py (manual)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+Tag: py3-none-mingw_x86_64_clang
+Tag: py3-none-mingw_x86_64