pywire 0.1.0__py3-none-any.whl

pywire/runtime/style_collector.py

@@ -0,0 +1,31 @@
+"""Style collector for scoped CSS."""
+
+from typing import Dict
+
+
+class StyleCollector:
+    """Collects and deduplicates scoped styles per request."""
+
+    def __init__(self) -> None:
+        self._styles: Dict[str, str] = {}  # scope_id -> css
+
+    def add(self, scope_id: str, css: str) -> bool:
+        """Add CSS for scope_id. Returns True if new (first occurrence)."""
+        if scope_id in self._styles:
+            return False
+        self._styles[scope_id] = css
+        return True
+
+    def render(self) -> str:
+        """Render all collected styles as a single <style> block."""
+        if not self._styles:
+            return ""
+
+        # Sort by scope_id to ensure deterministic output (important for tests)
+        # But maybe preserving insertion order is better?
+        # Actually insertion order implicitly handles dependency order if children render first?
+        # No, children render inside parent body.
+        # But we collect during render.
+        # Let's just join values. Dicts preserve insertion order in modern Python.
+        combined = "\n".join(self._styles.values())
+        return f"<style>{combined}</style>"

pywire/runtime/upload_manager.py

@@ -0,0 +1,76 @@
+import shutil
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Optional
+
+from starlette.datastructures import UploadFile
+
+from pywire.runtime.files import FileUpload
+
+
+class UploadManager:
+    """
+    Manages temporary storage of uploaded files using generated IDs.
+    Files are stored in a temporary directory and accessed by ID.
+    Ideally, these should be cleaned up after request processing or via a TTL mechanism.
+    For this implementation, we rely on OS temp cleaning or process restart for now.
+    """
+
+    def __init__(self) -> None:
+        self._temp_dir = Path(tempfile.mkdtemp(prefix="pywire_uploads_"))
+
+    def save(self, file: UploadFile) -> str:
+        """
+        Save an uploaded file and return a unique ID.
+        """
+        upload_id = str(uuid.uuid4())
+        file_path = self._temp_dir / upload_id
+
+        # Save content
+        with open(file_path, "wb") as f:
+            shutil.copyfileobj(file.file, f)
+
+        # Store metadata in a separate file or just keep it simple?
+        # We need filename, content_type, size.
+        # Let's write a metadata file next to it.
+        # Format: filename\ncontent_type
+        # Size comes from file size.
+
+        meta_path = file_path.with_suffix(".meta")
+        with open(meta_path, "w") as f:
+            f.write(f"{file.filename}\n{file.content_type}")
+
+        return upload_id
+
+    def get(self, upload_id: str) -> Optional[FileUpload]:
+        """
+        Retrieve a file by ID.
+        """
+        file_path = self._temp_dir / upload_id
+        meta_path = file_path.with_suffix(".meta")
+
+        if not file_path.exists() or not meta_path.exists():
+            return None
+
+        try:
+            with open(meta_path, "r") as f:
+                lines = f.read().splitlines()
+                filename = lines[0]
+                content_type = (
+                    lines[1] if len(lines) > 1 else "application/octet-stream"
+                )
+
+            return FileUpload(
+                filename=filename,
+                content_type=content_type,
+                size=file_path.stat().st_size,
+                content=file_path.read_bytes(),
+            )
+        except Exception as e:
+            print(f"Error retrieving upload {upload_id}: {e}")
+            return None
+
+
+# Global instance
+upload_manager = UploadManager()

pywire/runtime/validation.py

@@ -0,0 +1,449 @@
+"""Server-side form validation matching HTML5 constraints."""
+
+import re
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal, InvalidOperation
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+
+from pywire.runtime.files import FileUpload
+from pywire.runtime.upload_manager import upload_manager
+
+
+@dataclass
+class FieldRules:
+    """Runtime validation rules for a single field."""
+
+    required: bool = False
+    required_expr: Optional[str] = None  # Python expression for conditional required
+    pattern: Optional[str] = None
+    minlength: Optional[int] = None
+    maxlength: Optional[int] = None
+    min_value: Optional[str] = None
+    min_expr: Optional[str] = None  # Python expression for dynamic min
+    max_value: Optional[str] = None
+    max_expr: Optional[str] = None  # Python expression for dynamic max
+    step: Optional[str] = None
+    input_type: str = "text"
+    title: Optional[str] = None  # Custom error message
+    max_size: Optional[int] = None  # Max file size in bytes
+    allowed_types: Optional[List[str]] = None  # Allowed MIME types or extensions
+
+
+@dataclass
+class FormValidationSchema:
+    """Runtime schema containing all validation rules for a form."""
+
+    fields: Dict[str, FieldRules]
+    model_name: Optional[str] = None
+
+
+class FormValidator:
+    """Server-side form validation matching HTML5 constraints."""
+
+    # Email regex (simplified but sufficient for most cases)
+    EMAIL_PATTERN = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
+
+    # URL regex (simplified)
+    URL_PATTERN = re.compile(r"^https?://[^\s/$.?#].[^\s]*$", re.IGNORECASE)
+
+    def validate_field(
+        self,
+        name: str,
+        value: Any,
+        rules: FieldRules,
+        state_getter: Optional[Callable[[str], Any]] = None,
+    ) -> Optional[str]:
+        """
+        Validate a single field against rules.
+
+        Args:
+            name: Field name
+            value: Field value (string from form)
+            rules: Validation rules
+            state_getter: Optional function to evaluate expressions against page state
+
+        Returns:
+            Error message string, or None if valid.
+        """
+        # Handle conditional required
+        is_required = rules.required
+        if rules.required_expr and state_getter:
+            try:
+                is_required = bool(state_getter(rules.required_expr))
+            except Exception:
+                is_required = rules.required
+
+        # Check required
+        if is_required:
+            if value is None or (isinstance(value, str) and value.strip() == ""):
+                return rules.title or "This field is required"
+
+        # If empty and not required, skip other validations
+        if value is None or (isinstance(value, str) and value.strip() == ""):
+            return None
+
+        str_value = str(value).strip()
+
+        # Pattern validation
+        if rules.pattern:
+            try:
+                if not re.fullmatch(rules.pattern, str_value):
+                    return rules.title or "Value does not match the required pattern"
+            except re.error:
+                pass  # Invalid regex, skip
+
+        # Length validations
+        if rules.minlength is not None:
+            if len(str_value) < rules.minlength:
+                return rules.title or f"Must be at least {rules.minlength} characters"
+
+        if rules.maxlength is not None:
+            if len(str_value) > rules.maxlength:
+                return rules.title or f"Must be at most {rules.maxlength} characters"
+
+        # Type-based validation
+        if rules.input_type == "email":
+            if not self.EMAIL_PATTERN.match(str_value):
+                return rules.title or "Please enter a valid email address"
+
+        elif rules.input_type == "url":
+            if not self.URL_PATTERN.match(str_value):
+                return rules.title or "Please enter a valid URL"
+
+        elif rules.input_type == "number":
+            return self._validate_number(str_value, rules, state_getter)
+
+        elif rules.input_type == "date":
+            return self._validate_date(str_value, rules, state_getter)
+
+        elif rules.input_type == "file":
+            # File validation
+            if isinstance(value, FileUpload):
+                # Check size
+                if rules.max_size is not None and value.size > rules.max_size:
+                    size_mb = rules.max_size / (1024 * 1024)
+                    return rules.title or f"File is too large (max {size_mb:.1f}MB)"
+
+                # Check type
+                if rules.allowed_types:
+                    # Simple MIME type check
+                    # rules.allowed_types is list like ['image/*', 'application/pdf', '.jpg']
+                    allowed = False
+                    for pattern in rules.allowed_types:
+                        pattern = pattern.strip()
+                        if pattern.startswith("."):
+                            # Extension check
+                            if value.filename.lower().endswith(pattern.lower()):
+                                allowed = True
+                                break
+                        elif pattern.endswith("/*"):
+                            # Wildcard MIME check (e.g. image/*)
+                            base_type = pattern[:-2]  # remove /*
+                            if value.content_type.startswith(base_type):
+                                allowed = True
+                                break
+                        else:
+                            # Exact MIME check
+                            if value.content_type == pattern:
+                                allowed = True
+                                break
+
+                    if not allowed:
+                        return (
+                            rules.title
+                            or f"File type not allowed. Accepted: {', '.join(rules.allowed_types)}"
+                        )
+
+        # Range validation for non-typed fields
+        if rules.input_type == "text":
+            # Only apply if min/max look numeric
+            if rules.min_value or rules.max_value or rules.min_expr or rules.max_expr:
+                try:
+                    num_value = Decimal(str_value)
+                    return self._validate_numeric_range(num_value, rules, state_getter)
+                except InvalidOperation:
+                    pass  # Not a number, skip range validation
+
+        return None
+
+    def _validate_number(
+        self,
+        str_value: str,
+        rules: FieldRules,
+        state_getter: Optional[Callable[[str], Any]] = None,
+    ) -> Optional[str]:
+        """Validate a number input."""
+        try:
+            num_value = Decimal(str_value)
+        except InvalidOperation:
+            return rules.title or "Please enter a valid number"
+
+        return self._validate_numeric_range(num_value, rules, state_getter)
+
+    def _validate_numeric_range(
+        self,
+        num_value: Decimal,
+        rules: FieldRules,
+        state_getter: Optional[Callable[[str], Any]] = None,
+    ) -> Optional[str]:
+        """Validate numeric range constraints."""
+        # Get min value (static or dynamic)
+        min_val = None
+        if rules.min_expr and state_getter:
+            try:
+                min_val = Decimal(str(state_getter(rules.min_expr)))
+            except (InvalidOperation, Exception):
+                pass
+        elif rules.min_value:
+            try:
+                min_val = Decimal(rules.min_value)
+            except InvalidOperation:
+                pass
+
+        if min_val is not None and num_value < min_val:
+            return rules.title or f"Value must be at least {min_val}"
+
+        # Get max value (static or dynamic)
+        max_val = None
+        if rules.max_expr and state_getter:
+            try:
+                max_val = Decimal(str(state_getter(rules.max_expr)))
+            except (InvalidOperation, Exception):
+                pass
+        elif rules.max_value:
+            try:
+                max_val = Decimal(rules.max_value)
+            except InvalidOperation:
+                pass
+
+        if max_val is not None and num_value > max_val:
+            return rules.title or f"Value must be at most {max_val}"
+
+        # Step validation
+        if rules.step:
+            try:
+                step = Decimal(rules.step)
+                if step > 0:
+                    base = min_val if min_val is not None else Decimal("0")
+                    diff = num_value - base
+                    if diff % step != 0:
+                        return rules.title or f"Value must be a multiple of {step}"
+            except InvalidOperation:
+                pass
+
+        return None
+
+    def _validate_date(
+        self,
+        str_value: str,
+        rules: FieldRules,
+        state_getter: Optional[Callable[[str], Any]] = None,
+    ) -> Optional[str]:
+        """Validate a date input."""
+        try:
+            date_value = date.fromisoformat(str_value)
+        except ValueError:
+            return rules.title or "Please enter a valid date (YYYY-MM-DD)"
+
+        # Get min date (static or dynamic)
+        min_date = None
+        if rules.min_expr and state_getter:
+            try:
+                min_str = str(state_getter(rules.min_expr))
+                min_date = date.fromisoformat(min_str)
+            except (ValueError, Exception):
+                pass
+        elif rules.min_value:
+            try:
+                min_date = date.fromisoformat(rules.min_value)
+            except ValueError:
+                pass
+
+        if min_date is not None and date_value < min_date:
+            return rules.title or f"Date must be on or after {min_date.isoformat()}"
+
+        # Get max date (static or dynamic)
+        max_date = None
+        if rules.max_expr and state_getter:
+            try:
+                max_str = str(state_getter(rules.max_expr))
+                max_date = date.fromisoformat(max_str)
+            except (ValueError, Exception):
+                pass
+        elif rules.max_value:
+            try:
+                max_date = date.fromisoformat(rules.max_value)
+            except ValueError:
+                pass
+
+        if max_date is not None and date_value > max_date:
+            return rules.title or f"Date must be on or before {max_date.isoformat()}"
+
+        return None
+
+    def validate_form(
+        self,
+        data: Dict[str, Any],
+        schema: Dict[str, FieldRules],
+        state_getter: Callable[[str], Any],
+    ) -> Tuple[Dict[str, Any], Dict[str, str]]:
+        """
+        Validate data against schema.
+        Returns: (cleaned_data, errors)
+        """
+        errors: Dict[str, str] = {}
+        cleaned_data: Dict[str, Any] = {}
+
+        # 1. Validate fields present in schema
+        for field_name, rules in schema.items():
+            value = data.get(field_name)
+
+            # Helper to evaluate rules against state
+            def eval_rule(attr_name: str) -> Any:
+                expr = getattr(rules, f"{attr_name}_expr")
+                if expr:
+                    return state_getter(expr)
+                return getattr(rules, attr_name)
+
+            # Check required
+            is_required = eval_rule("required")
+            if is_required and (value is None or value == ""):
+                errors[field_name] = f"{rules.title or field_name} is required."
+                continue
+
+            # If empty and not required, skip other validations
+            if value is None or value == "":
+                if rules.input_type == "checkbox":
+                    cleaned_data[field_name] = False
+                else:
+                    cleaned_data[field_name] = None
+                continue
+
+            # Type conversion (strings to int/float/bool)
+            try:
+                converted_value = self._convert_value(value, rules.input_type)
+                cleaned_data[field_name] = converted_value
+            except ValueError:
+                errors[field_name] = (
+                    f"{rules.title or field_name} must be a valid {rules.input_type}."
+                )
+                continue
+
+            # Validate rules against converted value
+            error = self.validate_field(
+                field_name, converted_value, rules, state_getter
+            )  # Use original state_getter for validate_field
+            if error:
+                errors[field_name] = error
+
+        # 2. Pass through data not in schema?
+        # For strict typing, maybe we only want schema fields?
+        # But for flexibility, let's merge original data for non-schema fields.
+        final_data = data.copy()
+        final_data.update(cleaned_data)
+
+        return final_data, errors
+
+    def _convert_value(self, value: Any, input_type: str) -> Any:
+        """Convert string value to appropriate type."""
+        if value is None or value == "":
+            return None
+
+        if input_type == "number":
+            # Try int first, then float? Or just float?
+            # HTML input type="number" can be either.
+            try:
+                if isinstance(value, str) and "." in value:
+                    return float(value)
+                return int(value)
+            except ValueError:
+                # If int conversion fails, try float as a last resort
+                return float(value)
+
+        elif input_type == "checkbox":
+            # Checkbox value usually "on" or "true" string, but handled by client framework?
+            # If it comes from FormData, unchecked might be missing (handled in
+            # validate_form required check).
+            # Checked might be "on".
+            # Convert to boolean. Common values for "true" are "on", "true", 1.
+            if isinstance(value, str):
+                return value.lower() in ("on", "true", "1")
+            return bool(value)
+
+        elif input_type == "file":
+            # File uploads come as dicts from client.
+            # If it has _upload_id, resolve it via UploadManager.
+            # If it has content (old way), use from_dict.
+            if isinstance(value, dict):
+                if "_upload_id" in value:
+                    file = upload_manager.get(value["_upload_id"])
+                    if file:
+                        return file
+                    return None  # Pending or expired?
+                elif "content" in value:
+                    return FileUpload.from_dict(value)
+            return value
+
+        return value
+
+    def convert_to_type(self, value: Any, target_type: Type) -> Any:
+        """Convert value to specific Python type hints (e.g. Enums)."""
+        if value is None:
+            return None
+
+        # Enum conversion
+        if isinstance(target_type, type) and issubclass(target_type, Enum):
+            # Try matching by value first
+            try:
+                return target_type(value)
+            except ValueError:
+                pass
+
+            # Try matching by name
+            if isinstance(value, str):
+                try:
+                    return target_type[value]
+                except KeyError:
+                    pass
+                try:
+                    return target_type[value.upper()]
+                except KeyError:
+                    pass
+
+            # Return original if generic match fails, likely invalid
+            return value
+
+        return value
+
+        return value
+
+    @staticmethod
+    def parse_nested_data(flat_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Parse flat form data with dot notation into nested dicts.
+
+        Example:
+            {'customer.name': 'John', 'customer.email': 'john@example.com'}
+            ->
+            {'customer': {'name': 'John', 'email': 'john@example.com'}}
+        """
+        result: Dict[str, Any] = {}
+
+        for key, value in flat_data.items():
+            parts = key.split(".")
+            current = result
+
+            for i, part in enumerate(parts[:-1]):
+                if part not in current:
+                    current[part] = {}
+                current = current[part]
+
+            current[parts[-1]] = value
+
+        return result
+
+
+# Global validator instance
+form_validator = FormValidator()