pysealer 0.6.0__cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl

pysealer/cli.py

@@ -0,0 +1,367 @@
+"""
+Command-line interface for pysealer.
+
+Commands:
+- init: Initialize pysealer with a new keypair and .env file.
+- lock: Add pysealer decorators to all functions and classes in a Python file.
+- check: Check the integrity and validity of pysealer decorators in a Python file.
+- remove: Remove all pysealer decorators from a Python file.
+
+Use `pysealer --help` to see available options and command details.
+Use `pysealer --version` to see the current version of pysealer installed.
+"""
+
+from pathlib import Path
+
+import typer
+from typing_extensions import Annotated
+
+from . import __version__
+from .setup import setup_keypair
+from .add_decorators import add_decorators, add_decorators_to_folder
+from .check_decorators import check_decorators, check_decorators_in_folder
+from .remove_decorators import remove_decorators, remove_decorators_from_folder
+from .git_diff import is_git_available
+
+app = typer.Typer(
+    name="pysealer",
+    help="Version control your Python functions and classes with cryptographic decorators",
+    no_args_is_help=True,
+)
+
+
+def _format_diff_output(func_name: str, diff_lines):
+    """Format and display git diff with color coding."""
+    if not diff_lines:
+        return
+    typer.echo(typer.style(f"    Function '{func_name}' was modified:", fg=typer.colors.RED, bold=True))
+
+    for diff_type, content, line_num in diff_lines:
+        # Format line with appropriate styling
+        if diff_type == '-':
+            # Deletions in red
+            line_str = f"      {line_num:<4}{typer.style('-', fg=typer.colors.RED)}{typer.style(content, fg=typer.colors.RED)}"
+        elif diff_type == '+':
+            # Additions in green
+            line_str = f"      {line_num:<4}{typer.style('+', fg=typer.colors.GREEN)}{typer.style(content, fg=typer.colors.GREEN)}"
+        else:
+            # Context lines in dim/default color
+            line_str = f"      {line_num:<4} {content}"
+        
+        typer.echo(line_str)
+
+
+def version_callback(value: bool):
+    """Helper function to display version information."""
+    if value:
+        typer.echo(f"pysealer {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def version(
+    version: Annotated[
+        bool,
+        typer.Option("--version", help="Report the current version of pysealer installed.", callback=version_callback, is_eager=True)
+    ] = False
+):
+    """Report the current version of pysealer installed."""
+    pass
+
+
+@app.command()
+def init(
+    env_file: Annotated[
+        str,
+        typer.Argument(help="Path to the .env file")
+    ] = ".env",
+    github_token: Annotated[
+        str,
+        typer.Option("--github-token", help="GitHub personal access token for uploading public key to repository secrets.")
+    ] = None
+):
+    """Initialize pysealer with an .env file and optionally upload public key to GitHub."""
+    try:
+        env_path = Path(env_file)
+        
+        # Generate and store keypair (will raise error if keys already exist)
+        public_key, private_key = setup_keypair(env_path)
+        typer.echo(typer.style("Successfully initialized pysealer!", fg=typer.colors.BLUE, bold=True))
+        typer.echo(f"🔑 Keypair generated and stored in {env_path}")
+        typer.echo("🔍 Keep your .env file secure and add it to .gitignore")
+        
+        # GitHub secrets integration (optional, only if token provided)
+        if github_token:
+            typer.echo(typer.style("Attempting to upload public key to GitHub repository secrets...", fg=typer.colors.BLUE, bold=True))            
+            try:
+                from .github_secrets import setup_github_secrets
+                
+                success, message = setup_github_secrets(public_key, github_token)
+                
+                if success:
+                    typer.echo(typer.style(f"✓ {message}", fg=typer.colors.GREEN))
+                else:
+                    typer.echo(typer.style(f"⚠️  Warning: {message}", fg=typer.colors.YELLOW))
+                    typer.echo("   You can manually add the PYSEALER_PUBLIC_KEY to GitHub secrets later.")
+                    
+            except ImportError as e:
+                typer.echo(typer.style(f"⚠️  Warning: GitHub integration dependencies not installed: {e}", fg=typer.colors.YELLOW))
+            except Exception as e:
+                typer.echo(typer.style(f"⚠️  Warning: Failed to upload to GitHub: {e}", fg=typer.colors.YELLOW))
+                typer.echo("   You can manually add the PYSEALER_PUBLIC_KEY to GitHub secrets later.")
+        
+    except Exception as e:
+        typer.echo(typer.style(f"Error during initialization: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+
+@app.command()
+def lock(
+    file_path: Annotated[
+        str,
+        typer.Argument(help="Path to the Python file or folder to decorate")
+    ]
+):
+    """Add decorators to all functions and classes in a Python file or all Python files in a folder."""
+    path = Path(file_path)
+    
+    # Validate path exists
+    if not path.exists():
+        typer.echo(typer.style(f"Error: Path '{path}' does not exist.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    # Validate it's a Python file or directory
+    if path.is_file() and path.suffix != '.py':
+        typer.echo(typer.style(f"Error: File '{path}' is not a Python file.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    try:
+        # Handle folder path
+        if path.is_dir():
+            resolved_path = str(path.resolve())
+            decorated_files = add_decorators_to_folder(resolved_path)
+            
+            file_word = "file" if len(decorated_files) == 1 else "files"
+            typer.echo(typer.style(f"Successfully added decorators to {len(decorated_files)} {file_word}:", fg=typer.colors.BLUE, bold=True))
+            for file in decorated_files:
+                typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {file}")
+        
+        # Handle file path
+        else:
+            
+            # Add decorators to all functions and classes in the file
+            resolved_path = str(path.resolve())
+            modified_code, has_changes = add_decorators(resolved_path)
+            
+            if has_changes:
+                # Write the modified code back to the file
+                with open(resolved_path, 'w') as f:
+                    f.write(modified_code)
+                
+                typer.echo(typer.style(f"Successfully added decorators to 1 file:", fg=typer.colors.BLUE, bold=True))
+                typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {resolved_path}")
+            else:
+                typer.echo(typer.style(f"No functions or classes found in file:", fg=typer.colors.YELLOW, bold=True))
+                typer.echo(f"  {typer.style('⊘', fg=typer.colors.YELLOW)} {resolved_path}")
+        
+    except (RuntimeError, FileNotFoundError, NotADirectoryError, ValueError) as e:
+        typer.echo(typer.style(f"Error: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        typer.echo(typer.style(f"Unexpected error while locking file: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def check(
+    file_path: Annotated[
+        str,
+        typer.Argument(help="Path to the Python file or folder to check")
+    ]
+):
+    """Check the integrity of decorators in a Python file or all Python files in a folder."""
+    path = Path(file_path)
+    
+    # Validate path exists
+    if not path.exists():
+        typer.echo(typer.style(f"Error: Path '{path}' does not exist.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    # Validate it's a Python file or directory
+    if path.is_file() and path.suffix != '.py':
+        typer.echo(typer.style(f"Error: File '{path}' is not a Python file.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    try:
+        # Check if git is available for diff output
+        git_available = is_git_available()
+        if not git_available:
+            typer.echo(typer.style("Note: Git not available - diff output will not be shown for invalid signatures.", fg=typer.colors.YELLOW))
+            typer.echo()
+        
+        # Handle folder path
+        if path.is_dir():
+            resolved_path = str(path.resolve())
+            all_results = check_decorators_in_folder(resolved_path)
+            
+            total_decorated = 0
+            total_valid = 0
+            files_with_decorators = []
+            files_with_issues = []
+            
+            for file_path, results in all_results.items():
+                # Skip files with errors
+                if "error" in results:
+                    typer.echo(typer.style(f"✗ {file_path}: {results['error']}", fg=typer.colors.RED))
+                    files_with_issues.append(file_path)
+                    continue
+                
+                decorated_count = sum(1 for r in results.values() if r["has_decorator"])
+                
+                # Only count files that have decorators
+                if decorated_count > 0:
+                    valid_count = sum(1 for r in results.values() if r["valid"])
+                    files_with_decorators.append(file_path)
+                    total_decorated += decorated_count
+                    total_valid += valid_count
+                    
+                    # Track files with validation failures
+                    if valid_count < decorated_count:
+                        files_with_issues.append(file_path)
+            
+            # Summary header
+            if total_decorated == 0:
+                typer.echo(typer.style(f"No pysealer decorators found in folder.", fg=typer.colors.YELLOW, bold=True))
+            elif total_valid == total_decorated:
+                file_word = "file" if len(files_with_decorators) == 1 else "files"
+                typer.echo(typer.style(f"All decorators are valid in {len(files_with_decorators)} {file_word}:", fg=typer.colors.BLUE, bold=True))
+            else:
+                failed_count = total_decorated - total_valid
+                failed_files = len(files_with_issues)
+                decorator_word = "decorator" if failed_count == 1 else "decorators"
+                file_word = "file" if failed_files == 1 else "files"
+                typer.echo(typer.style(f"{failed_count} {decorator_word} failed in {failed_files} {file_word}:", fg=typer.colors.BLUE, bold=True), err=True)
+            
+            # File-by-file details - only show files with decorators
+            if total_decorated > 0:
+                for file_path in files_with_decorators:
+                    results = all_results[file_path]
+                    if "error" in results:
+                        continue
+                    
+                    decorated_count = sum(1 for r in results.values() if r["has_decorator"])
+                    valid_count = sum(1 for r in results.values() if r["valid"])
+                    
+                    if valid_count == decorated_count:
+                        typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {file_path}")
+                    else:
+                        typer.echo(f"  {typer.style('✗', fg=typer.colors.RED)} {file_path}")
+                        
+                        # Show diff for each failed function
+                        for func_name, result in results.items():
+                            if result["has_decorator"] and not result["valid"]:
+                                if result.get("diff"):
+                                    _format_diff_output(func_name, result["diff"])
+            
+            # Exit with error if there were failures
+            if total_decorated > 0 and total_valid < total_decorated:
+                raise typer.Exit(code=1)
+        
+        # Handle file path
+        else:
+            
+            # Check all decorators in the file
+            resolved_path = str(path.resolve())
+            results = check_decorators(resolved_path)
+            
+            # Return success if all decorated functions are valid
+            decorated_count = sum(1 for r in results.values() if r["has_decorator"])
+            valid_count = sum(1 for r in results.values() if r["valid"])
+            
+            if decorated_count == 0:
+                typer.echo(typer.style(f"No pysealer decorators found in 1 file:", fg=typer.colors.YELLOW, bold=True))
+                typer.echo(f"  {typer.style('⊘', fg=typer.colors.YELLOW)} {resolved_path}")
+            elif valid_count == decorated_count:
+                decorator_word = "decorator" if decorated_count == 1 else "decorators"
+                typer.echo(typer.style(f"All {decorator_word} are valid in 1 file:", fg=typer.colors.BLUE, bold=True))
+                typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {resolved_path}")
+            else:
+                failed = decorated_count - valid_count
+                decorator_word = "decorator" if decorated_count == 1 else "decorators"
+                typer.echo(typer.style(f"{failed}/{decorated_count} {decorator_word} failed in 1 file:", fg=typer.colors.BLUE, bold=True), err=True)
+                typer.echo(f"  {typer.style('✗', fg=typer.colors.RED)} {resolved_path}")
+                
+                # Show diff for each failed function
+                for func_name, result in results.items():
+                    if result["has_decorator"] and not result["valid"]:
+                        if result.get("diff"):
+                            _format_diff_output(func_name, result["diff"])
+                
+                raise typer.Exit(code=1)
+    
+    except (FileNotFoundError, NotADirectoryError, ValueError) as e:
+        typer.echo(typer.style(f"Error: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def remove(
+    file_path: Annotated[
+        str,
+        typer.Argument(help="Path to the Python file or folder to remove pysealer decorators from")
+    ]
+):
+    """Remove pysealer decorators from all functions and classes in a Python file or all Python files in a folder."""
+    path = Path(file_path)
+    
+    # Validate path exists
+    if not path.exists():
+        typer.echo(typer.style(f"Error: Path '{path}' does not exist.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    # Validate it's a Python file or directory
+    if path.is_file() and path.suffix != '.py':
+        typer.echo(typer.style(f"Error: File '{path}' is not a Python file.", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    
+    try:
+        # Handle folder path
+        if path.is_dir():
+            resolved_path = str(path.resolve())
+            modified_files = remove_decorators_from_folder(resolved_path)
+            
+            file_word = "file" if len(modified_files) == 1 else "files"
+            typer.echo(typer.style(f"Successfully removed decorators from {len(modified_files)} {file_word}:", fg=typer.colors.BLUE, bold=True))
+            for file in modified_files:
+                typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {file}")
+        
+        # Handle file path
+        else:
+            
+            resolved_path = str(path.resolve())
+            modified_code, found = remove_decorators(resolved_path)
+            
+            with open(resolved_path, 'w') as f:
+                f.write(modified_code)
+            
+            if found:
+                typer.echo(typer.style(f"Successfully removed decorators from 1 file:", fg=typer.colors.BLUE, bold=True))
+                typer.echo(f"  {typer.style('✓', fg=typer.colors.GREEN)} {resolved_path}")
+            else:
+                typer.echo(typer.style(f"No pysealer decorators found in 1 file:", fg=typer.colors.YELLOW, bold=True))
+                typer.echo(f"  {typer.style('⊘', fg=typer.colors.YELLOW)} {resolved_path}")
+    
+    except (FileNotFoundError, NotADirectoryError, ValueError) as e:
+        typer.echo(typer.style(f"Error: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        typer.echo(typer.style(f"Unexpected error while removing decorators: {e}", fg=typer.colors.RED, bold=True), err=True)
+        raise typer.Exit(code=1)
+
+
+def main():
+    """Main CLI entry point."""
+    app()
+
+
+if __name__ == '__main__':
+    main()

pysealer/dummy_decorators.py

@@ -0,0 +1,83 @@
+"""Defines dummy decorators for all decorators found in the target file."""
+
+import os
+import ast
+import inspect
+
+
+def _dummy_decorator(func=None, *args, **kwargs):
+    """
+    A no-op (dummy) decorator that can be used in place of any decorator.
+
+    Handles both @deco and @deco(...) usages. If used as @deco, it returns the function unchanged.
+    If used as @deco(...), it returns a wrapper that returns the function unchanged.
+
+    Args:
+        func (callable, optional): The function to decorate, or None if called with arguments.
+        *args: Positional arguments (ignored).
+        **kwargs: Keyword arguments (ignored).
+
+    Returns:
+        callable: The original function, unchanged.
+    """
+    if callable(func) and not args and not kwargs:
+        return func
+    def wrapper(f):
+        return f
+    return wrapper
+
+def _discover_decorators(file_path):
+    """
+    Yield all decorator names used in the given Python file.
+
+    This function parses the specified Python file and walks its AST to find all decorator names
+    used on functions, async functions, and classes. It handles decorators used as @deco, @deco(...),
+    and @obj.deco or @obj.deco(...).
+
+    Args:
+        file_path (str): Path to the Python file to scan.
+
+    Yields:
+        str: The name of each decorator found.
+    """
+    if not os.path.exists(file_path):
+        return
+    with open(file_path, "r") as f:
+        src = f.read()
+    try:
+        tree = ast.parse(src)
+    except Exception:
+        return
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            for deco in node.decorator_list:
+                # Handles @deco or @deco(...)
+                if isinstance(deco, ast.Name):
+                    yield deco.id
+                elif isinstance(deco, ast.Attribute):
+                    yield deco.attr
+                elif isinstance(deco.func, ast.Name):
+                    yield deco.func.id
+                elif isinstance(deco.func, ast.Attribute):
+                    yield deco.func.attr
+
+def _get_caller_file():
+    """
+    Find the filename of the module that imported this module at the top level.
+
+    Returns:
+        str or None: The filename of the caller module, or None if not found.
+    """
+    stack = inspect.stack()
+    for frame in stack:
+        if frame.function == "<module>" and frame.filename != __file__:
+            return frame.filename
+
+# Main logic: define dummy decorators for all found in the caller file
+_CALLER_FILE = _get_caller_file()
+if _CALLER_FILE:
+    _seen = set()
+    for deco_name in _discover_decorators(_CALLER_FILE):
+        if deco_name and deco_name not in globals() and deco_name not in _seen:
+            globals()[deco_name] = _dummy_decorator
+            _seen.add(deco_name)

pysealer/git_diff.py

@@ -0,0 +1,228 @@
+"""Git-based diff functionality for comparing function/class changes."""
+
+import ast
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple, List
+import difflib
+
+
+def get_file_from_git(file_path: str, ref: str = "HEAD") -> Optional[str]:
+    """
+    Retrieve file content from a specific git reference.
+    
+    Args:
+        file_path: Absolute path to the file
+        ref: Git reference (default: HEAD)
+        
+    Returns:
+        File content as string, or None if not in git or error occurs
+    """
+    try:
+        # Get relative path from git root
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=Path(file_path).parent,
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        git_root = result.stdout.strip()
+        relative_path = Path(file_path).relative_to(git_root)
+        
+        # Get file content from git
+        result = subprocess.run(
+            ["git", "show", f"{ref}:{relative_path}"],
+            cwd=git_root,
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        
+        if result.returncode == 0:
+            return result.stdout
+        return None
+        
+    except FileNotFoundError:
+        # Git command not found
+        return None
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError, ValueError, OSError):
+        return None
+
+
+def extract_function_from_source(source_code: str, function_name: str) -> Optional[Tuple[str, int]]:
+    """
+    Extract a specific function or class from source code.
+    
+    Args:
+        source_code: Python source code
+        function_name: Name of function/class to extract
+        
+    Returns:
+        Tuple of (function_source, start_line) or None if not found
+    """
+    try:
+        tree = ast.parse(source_code)
+        lines = source_code.splitlines(keepends=True)
+        
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                if node.name == function_name:
+                    # Get the source lines for this node
+                    start_line = node.lineno
+                    end_line = node.end_lineno if node.end_lineno else start_line
+                    
+                    function_lines = lines[start_line - 1:end_line]
+                    function_source = ''.join(function_lines)
+                    
+                    return function_source, start_line
+        
+        return None
+    except (SyntaxError, AttributeError):
+        return None
+
+
+def generate_function_diff(
+    old_source: str,
+    new_source: str,
+    function_name: str,
+    old_start_line: int,
+    new_start_line: int,
+    context_lines: int = 2
+) -> List[Tuple[str, str, int]]:
+    """
+    Generate a unified diff for a specific function.
+    
+    Args:
+        old_source: Old function source code
+        new_source: New function source code
+        function_name: Name of the function/class
+        old_start_line: Starting line number in old file
+        new_start_line: Starting line number in new file
+        context_lines: Number of context lines to show
+        
+    Returns:
+        List of tuples: (diff_type, line_content, line_number)
+        where diff_type is ' ', '-', or '+'
+    """
+    old_lines = old_source.splitlines(keepends=False)
+    new_lines = new_source.splitlines(keepends=False)
+    
+    # Generate unified diff
+    diff = list(difflib.unified_diff(
+        old_lines,
+        new_lines,
+        lineterm='',
+        n=context_lines
+    ))
+    
+    # Skip the header lines (first 3 lines of unified diff)
+    if len(diff) > 3:
+        diff = diff[3:]
+    
+    result = []
+    current_old_line = old_start_line
+    current_new_line = new_start_line
+    
+    for line in diff:
+        if not line:
+            continue
+            
+        prefix = line[0]
+        content = line[1:] if len(line) > 1 else ''
+        
+        if prefix == '-':
+            result.append(('-', content, current_old_line))
+            current_old_line += 1
+        elif prefix == '+':
+            result.append(('+', content, current_new_line))
+            current_new_line += 1
+        elif prefix == ' ':
+            result.append((' ', content, current_new_line))
+            current_old_line += 1
+            current_new_line += 1
+        elif prefix == '@':
+            # Parse line numbers from @@ -old_start,old_count +new_start,new_count @@
+            try:
+                parts = line.split()
+                if len(parts) >= 3:
+                    old_part = parts[1].lstrip('-')
+                    new_part = parts[2].lstrip('+')
+                    
+                    if ',' in old_part:
+                        current_old_line = int(old_part.split(',')[0])
+                    else:
+                        current_old_line = int(old_part)
+                        
+                    if ',' in new_part:
+                        current_new_line = int(new_part.split(',')[0])
+                    else:
+                        current_new_line = int(new_part)
+            except (ValueError, IndexError):
+                pass
+    
+    return result
+
+
+def is_git_available() -> bool:
+    """
+    Check if the current directory is in a git repository.
+    
+    Returns:
+        True if .git directory exists in current or parent directories, False otherwise
+    """
+    current = Path.cwd()
+    # Check current directory and all parent directories
+    for parent in [current] + list(current.parents):
+        if (parent / ".git").exists():
+            return True
+    return False
+
+
+def get_function_diff(
+    file_path: str,
+    function_name: str,
+    new_source: str,
+    new_start_line: int
+) -> Optional[List[Tuple[str, str, int]]]:
+    """
+    Get the diff for a specific function comparing current version to git HEAD.
+    
+    Args:
+        file_path: Absolute path to the Python file
+        function_name: Name of the function/class
+        new_source: Current source code of the function
+        new_start_line: Starting line number of function in current file
+        
+    Returns:
+        List of diff tuples or None if git history unavailable
+    """
+    # Get the file from git
+    old_file_content = get_file_from_git(file_path)
+    
+    if not old_file_content:
+        return None
+    
+    # Extract the old version of the function
+    old_function = extract_function_from_source(old_file_content, function_name)
+    
+    if not old_function:
+        return None
+    
+    old_source, old_start_line = old_function
+    
+    # Generate the diff
+    diff = generate_function_diff(
+        old_source,
+        new_source,
+        function_name,
+        old_start_line,
+        new_start_line,
+        context_lines=2
+    )
+    
+    return diff if diff else None