additory 0.1.0a4__py3-none-any.whl → 0.1.1a1__py3-none-any.whl

additory/expressions/integrity.py

@@ -0,0 +1,179 @@
+"""
+Expression integrity verification for Additory.
+
+Verifies SHA-256 hashes of expressions to detect tampering or corruption.
+"""
+
+import hashlib
+import re
+from typing import Dict
+from pathlib import Path
+
+
+def verify_sha(expression: str, expected_sha: str) -> bool:
+    """
+    Verify SHA hash of expression.
+    
+    Args:
+        expression: Expression string
+        expected_sha: Expected SHA hash
+        
+    Returns:
+        True if matches, False if mismatch
+        
+    Example:
+        is_valid = verify_sha('weight / (height ** 2)', 'a1b2c3d4e5f6...')
+    """
+    # Compute actual SHA
+    actual_sha = compute_sha(expression)
+    
+    # Compare
+    if actual_sha != expected_sha:
+        return False
+    
+    return True
+
+
+def compute_sha(expression: str) -> str:
+    """
+    Compute SHA-256 hash of expression.
+    
+    Args:
+        expression: Expression string
+        
+    Returns:
+        SHA-256 hash as hex string
+        
+    Example:
+        sha = compute_sha('weight / (height ** 2)')
+        # Returns: 'a1b2c3d4e5f6...'
+    """
+    # Normalize expression
+    normalized = normalize_expression(expression)
+    
+    # Compute SHA-256
+    sha = hashlib.sha256(normalized.encode('utf-8')).hexdigest()
+    
+    return sha
+
+
+def normalize_expression(expression: str) -> str:
+    """
+    Normalize expression for consistent hashing.
+    
+    Args:
+        expression: Expression string
+        
+    Returns:
+        Normalized expression string
+        
+    Example:
+        normalized = normalize_expression('  weight  /  ( height ** 2 )  ')
+        # Returns: 'weight / (height ** 2)'
+    """
+    # Remove leading/trailing whitespace
+    normalized = expression.strip()
+    
+    # Collapse multiple spaces to single space
+    normalized = re.sub(r'\s+', ' ', normalized)
+    
+    return normalized
+
+
+def generate_sha_for_file(file_path: str) -> Dict[str, str]:
+    """
+    Generate SHA hashes for all expressions in a file.
+    
+    Args:
+        file_path: Path to .add file
+        
+    Returns:
+        Dictionary mapping expression name to SHA hash
+        
+    Example:
+        hashes = generate_sha_for_file('core.add')
+        # Returns: {'bmi': 'a1b2c3...', 'bsa': 'f6e5d4...'}
+    """
+    from additory.expressions.loader import load_expressions_from_file
+    
+    # Load expressions from file (use 'temp' as namespace for generation)
+    expressions = load_expressions_from_file(file_path, 'temp')
+    
+    # Generate SHA for each expression
+    hashes = {}
+    for name, expr_def in expressions.items():
+        # Extract expression string from definition
+        if isinstance(expr_def, dict):
+            expr_string = expr_def.get('expression', '')
+        else:
+            expr_string = expr_def
+        
+        hashes[name] = compute_sha(expr_string)
+    
+    return hashes
+
+
+def verify_all_expressions(expressions: Dict[str, Dict]) -> Dict[str, bool]:
+    """
+    Verify SHA hashes for all expressions.
+    
+    Args:
+        expressions: Dictionary of expression definitions
+                    Each value should have 'expression' and 'sha' keys
+        
+    Returns:
+        Dictionary mapping expression name to verification result
+        
+    Example:
+        results = verify_all_expressions(loaded_expressions)
+        # Returns: {'bmi': True, 'bsa': True, 'custom': False}
+    """
+    results = {}
+    
+    for name, expr_def in expressions.items():
+        # Get expression string and expected SHA
+        expr_string = expr_def.get('expression', '')
+        expected_sha = expr_def.get('sha', '')
+        
+        # Skip if no SHA provided
+        if not expected_sha:
+            results[name] = True
+            continue
+        
+        # Verify SHA
+        is_valid = verify_sha(expr_string, expected_sha)
+        results[name] = is_valid
+        
+        # Log warning if mismatch
+        if not is_valid:
+            actual_sha = compute_sha(expr_string)
+            namespace = expr_def.get('namespace', 'unknown')
+            log_integrity_warning(name, namespace, expected_sha, actual_sha)
+    
+    return results
+
+
+def log_integrity_warning(
+    expression_name: str,
+    namespace: str,
+    expected_sha: str,
+    actual_sha: str
+):
+    """
+    Log integrity warning.
+    
+    Args:
+        expression_name: Name of expression
+        namespace: Namespace name
+        expected_sha: Expected SHA hash
+        actual_sha: Actual SHA hash
+    """
+    from additory.core.logging import Logger
+    
+    logger = Logger()
+    logger.warning(
+        f"Expression '{expression_name}' in namespace '{namespace}' failed integrity check\n"
+        f"  Expected SHA: {expected_sha}\n"
+        f"  Actual SHA:   {actual_sha}\n"
+        f"  This expression may have been modified. Use in development mode only."
+    )

additory/expressions/loader.py

@@ -0,0 +1,263 @@
+"""
+Expression loader for Additory.
+
+Loads expressions from .add files (TOML format) in specified folders.
+"""
+
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+# Use tomllib for Python 3.11+ or tomli for earlier versions
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        raise ImportError(
+            "tomli is required for Python < 3.11. Install with: pip install tomli"
+        )
+
+
+def load_expressions_from_folder(folder_path: str, namespace: str) -> Dict[str, Dict]:
+    """
+    Load all expressions from .add files in a folder.
+    
+    Args:
+        folder_path: Path to folder containing .add files
+        namespace: Namespace name for these expressions
+        
+    Returns:
+        Dictionary mapping expression name to definition
+        
+    Example:
+        expressions = load_expressions_from_folder('/path/to/inbuilt', 'inbuilt')
+        # Returns: {'bmi': {...}, 'bsa': {...}, ...}
+    """
+    # Check if folder exists
+    folder = Path(folder_path)
+    if not folder.exists():
+        raise FileNotFoundError(f"Folder '{folder_path}' not found")
+    
+    if not folder.is_dir():
+        raise ValueError(f"'{folder_path}' is not a directory")
+    
+    # Find all .add files
+    add_files = find_add_files(folder_path)
+    
+    if not add_files:
+        return {}
+    
+    # Load expressions from each file
+    all_expressions = {}
+    
+    for file_path in add_files:
+        file_expressions = load_expressions_from_file(file_path, namespace)
+        
+        # Check for duplicates
+        check_duplicate_names(all_expressions, file_expressions, file_path)
+        
+        # Add to combined dictionary
+        all_expressions.update(file_expressions)
+    
+    return all_expressions
+
+
+def load_expressions_from_file(file_path: str, namespace: str) -> Dict[str, Dict]:
+    """
+    Load expressions from a single .add file.
+    
+    Args:
+        file_path: Path to .add file
+        namespace: Namespace name
+        
+    Returns:
+        Dictionary mapping expression name to definition
+        
+    Example:
+        expressions = load_expressions_from_file('/path/to/core.add', 'inbuilt')
+        # Returns: {'bmi': {...}, 'bsa': {...}}
+    """
+    # Parse TOML file
+    try:
+        toml_data = parse_toml_file(file_path)
+    except Exception as e:
+        raise ValueError(f"File '{Path(file_path).name}' is not valid TOML: {str(e)}")
+    
+    # Process each expression
+    expressions = {}
+    file_name = Path(file_path).name
+    
+    for name, definition in toml_data.items():
+        # Validate definition
+        validate_expression_definition(name, definition, file_path)
+        
+        # Add metadata
+        expression_def = {
+            'name': name,
+            'expression': definition['expression'],
+            'description': definition['description'],
+            'sha': definition['sha'],
+            'namespace': namespace,
+            'source_file': file_name
+        }
+        
+        # Add optional fields
+        if 'author' in definition:
+            expression_def['author'] = definition['author']
+        if 'version' in definition:
+            expression_def['version'] = definition['version']
+        if 'tags' in definition:
+            expression_def['tags'] = definition['tags']
+        
+        expressions[name] = expression_def
+    
+    return expressions
+
+
+def parse_toml_file(file_path: str) -> Dict:
+    """
+    Parse TOML file.
+    
+    Args:
+        file_path: Path to TOML file
+        
+    Returns:
+        Parsed TOML as dictionary
+    """
+    path = Path(file_path)
+    
+    if not path.exists():
+        raise FileNotFoundError(f"File '{file_path}' not found")
+    
+    # Read and parse TOML
+    with open(path, 'rb') as f:
+        return tomllib.load(f)
+
+
+def validate_expression_definition(name: str, definition: Dict, file_path: str) -> bool:
+    """
+    Validate expression definition has required fields.
+    
+    Args:
+        name: Expression name
+        definition: Expression definition dictionary
+        file_path: Source file path (for error messages)
+        
+    Returns:
+        True if valid
+        
+    Raises:
+        ValueError: If validation fails
+    """
+    file_name = Path(file_path).name
+    
+    # Check if definition is a dictionary
+    if not isinstance(definition, dict):
+        raise ValueError(
+            f"Expression '{name}' in '{file_name}' must be a table/dictionary"
+        )
+    
+    # Required fields
+    required_fields = ['expression', 'description', 'sha']
+    
+    for field in required_fields:
+        if field not in definition:
+            raise ValueError(
+                f"Expression '{name}' in '{file_name}' missing required field '{field}'"
+            )
+        
+        # Check field is a string
+        if not isinstance(definition[field], str):
+            raise ValueError(
+                f"Expression '{name}' in '{file_name}' field '{field}' must be a string"
+            )
+        
+        # Check field is not empty
+        if not definition[field].strip():
+            raise ValueError(
+                f"Expression '{name}' in '{file_name}' field '{field}' cannot be empty"
+            )
+    
+    # Validate optional fields if present
+    if 'author' in definition and not isinstance(definition['author'], str):
+        raise ValueError(
+            f"Expression '{name}' in '{file_name}' field 'author' must be a string"
+        )
+    
+    if 'version' in definition and not isinstance(definition['version'], str):
+        raise ValueError(
+            f"Expression '{name}' in '{file_name}' field 'version' must be a string"
+        )
+    
+    if 'tags' in definition:
+        if not isinstance(definition['tags'], list):
+            raise ValueError(
+                f"Expression '{name}' in '{file_name}' field 'tags' must be a list"
+            )
+        if not all(isinstance(tag, str) for tag in definition['tags']):
+            raise ValueError(
+                f"Expression '{name}' in '{file_name}' field 'tags' must contain only strings"
+            )
+    
+    return True
+
+
+def find_add_files(folder_path: str) -> List[str]:
+    """
+    Find all .add files in a folder.
+    
+    Args:
+        folder_path: Path to folder
+        
+    Returns:
+        List of .add file paths (sorted alphabetically)
+    """
+    folder = Path(folder_path)
+    
+    # Find all .add files (not recursive)
+    add_files = list(folder.glob('*.add'))
+    
+    # Sort alphabetically
+    add_files.sort()
+    
+    # Convert to strings
+    return [str(f) for f in add_files]
+
+
+def check_duplicate_names(
+    expressions_dict: Dict[str, Dict],
+    new_expressions: Dict[str, Dict],
+    source_file: str
+) -> bool:
+    """
+    Check for duplicate expression names.
+    
+    Args:
+        expressions_dict: Existing expressions
+        new_expressions: New expressions to add
+        source_file: Source file of new expressions
+        
+    Returns:
+        True if no duplicates
+        
+    Raises:
+        ValueError: If duplicates found
+    """
+    duplicates = []
+    
+    for name in new_expressions:
+        if name in expressions_dict:
+            existing_file = expressions_dict[name]['source_file']
+            new_file = Path(source_file).name
+            duplicates.append((name, existing_file, new_file))
+    
+    if duplicates:
+        error_lines = ["Duplicate expression names found:"]
+        for name, existing_file, new_file in duplicates:
+            error_lines.append(f"  - '{name}' in '{existing_file}' and '{new_file}'")
+        error_lines.append("Please rename one of them.")
+        raise ValueError('\n'.join(error_lines))
+    
+    return True