pywire 0.1.0__py3-none-any.whl

pywire/compiler/ast_nodes.py

@@ -0,0 +1,304 @@
+"""AST node definitions for PyWire compiler."""
+
+import ast
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Union
+
+
+@dataclass
+class ASTNode:
+    """Base for all AST nodes."""
+
+    line: int
+    column: int
+
+
+@dataclass
+class Directive(ASTNode):
+    """Base for directives."""
+
+    name: str
+
+
+@dataclass
+class PathDirective(Directive):
+    """!path { 'name': '/route/{param}' } or !path '/route'"""
+
+    routes: Dict[str, str]  # {'name': '/route/{param}'}
+    is_simple_string: bool = False
+
+    def __str__(self) -> str:
+        return f"PathDirective(routes={self.routes}, simple={self.is_simple_string})"
+
+
+@dataclass
+class NoSpaDirective(Directive):
+    """!no_spa - disables client-side SPA navigation for this page."""
+
+    def __str__(self) -> str:
+        return "NoSpaDirective()"
+
+
+@dataclass
+class LayoutDirective(Directive):
+    """!layout "path/to/layout.pywire" """
+
+    layout_path: str
+
+    def __str__(self) -> str:
+        return f"LayoutDirective(path={self.layout_path})"
+
+
+@dataclass
+class ComponentDirective(Directive):
+    """!component 'path/to/component' as Name"""
+
+    path: str
+    component_name: str  # PascalCase name (e.g. 'Badge')
+
+    def __str__(self) -> str:
+        return f"ComponentDirective(name={self.component_name}, path={self.path})"
+
+
+@dataclass
+class PropsDirective(Directive):
+    """!props(name: type, arg=default)"""
+
+    # List of (name, type_hint_str, default_value_str_or_None)
+    args: List[Tuple[str, str, Optional[str]]]
+
+    def __str__(self) -> str:
+        return f"PropsDirective(args={self.args})"
+
+
+@dataclass
+class InjectDirective(Directive):
+    """!inject { local: 'GLOBAL' }"""
+
+    mapping: Dict[str, str]  # {local_var: global_key}
+
+    def __str__(self) -> str:
+        return f"InjectDirective(mapping={self.mapping})"
+
+
+@dataclass
+class ProvideDirective(Directive):
+    """!provide { 'GLOBAL': local }"""
+
+    mapping: Dict[str, str]  # {global_key: local_var_expr}
+
+    def __str__(self) -> str:
+        return f"ProvideDirective(mapping={self.mapping})"
+
+
+@dataclass
+class SpecialAttribute(ASTNode):
+    """Base for special attributes ($, @, :)."""
+
+    name: str
+    value: str
+
+
+@dataclass
+class KeyAttribute(SpecialAttribute):
+    """$key={unique_id}."""
+
+    expr: str
+
+    def __str__(self) -> str:
+        return f"KeyAttribute(expr={self.expr})"
+
+
+@dataclass
+class IfAttribute(SpecialAttribute):
+    """$if={condition}."""
+
+    condition: str
+
+    def __str__(self) -> str:
+        return f"IfAttribute(condition={self.condition})"
+
+
+@dataclass
+class ShowAttribute(SpecialAttribute):
+    """$show={condition}."""
+
+    condition: str
+
+    def __str__(self) -> str:
+        return f"ShowAttribute(condition={self.condition})"
+
+
+@dataclass
+class ForAttribute(SpecialAttribute):
+    """$for={item in items}"."""
+
+    is_template_tag: bool  # <template $for>
+    loop_vars: str  # "item" or "key, value"
+    iterable: str  # "items" or "items.items()"
+    key: Optional[str] = None
+
+    def __str__(self) -> str:
+        return f"ForAttribute(vars={self.loop_vars}, in={self.iterable})"
+
+
+@dataclass
+class FieldValidationRules:
+    """Validation rules for a single form field."""
+
+    name: str
+    required: bool = False
+    required_expr: Optional[str] = None  # For required={condition}
+    pattern: Optional[str] = None
+    minlength: Optional[int] = None
+    maxlength: Optional[int] = None
+    min_value: Optional[str] = None  # String to support dates
+    min_expr: Optional[str] = None  # For min={expr}
+    max_value: Optional[str] = None
+    max_expr: Optional[str] = None  # For max={expr}
+    step: Optional[str] = None
+    input_type: str = "text"  # email, url, number, date, etc.
+    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
+
+    def __str__(self) -> str:
+        return f"FieldValidationRules(name={self.name}, required={self.required})"
+
+
+@dataclass
+class FormValidationSchema:
+    """Schema containing all validation rules for a form."""
+
+    fields: Dict[str, FieldValidationRules] = field(default_factory=dict)
+    model_name: Optional[str] = None  # For $model={ClassName}
+
+    def __str__(self) -> str:
+        return (
+            f"FormValidationSchema(fields={len(self.fields)}, model={self.model_name})"
+        )
+
+
+@dataclass
+class ModelAttribute(SpecialAttribute):
+    """$model={ModelClassName} - Pydantic model binding."""
+
+    model_name: str
+
+    def __str__(self) -> str:
+        return f"ModelAttribute(model={self.model_name})"
+
+
+@dataclass
+class EventAttribute(SpecialAttribute):
+    """@click={handler_name} or @click={handler(arg1)}."""
+
+    event_type: str  # 'click', 'submit', etc.
+    handler_name: str
+    args: List[str] = field(
+        default_factory=list
+    )  # List of python expressions for arguments
+    modifiers: List[str] = field(
+        default_factory=list
+    )  # List of modifiers (e.g. ['prevent', 'stop'])
+    # Form-specific fields
+    validation_schema: Optional[FormValidationSchema] = None  # Set for @submit handlers
+
+    def __str__(self) -> str:
+        return (
+            f"EventAttribute(event={self.event_type}, modifiers={self.modifiers}, "
+            f"handler={self.handler_name}, args={self.args})"
+        )
+
+
+@dataclass
+class ReactiveAttribute(SpecialAttribute):
+    """
+    attr={expression}
+    Represents a reactive attribute where the value is a python expression.
+    """
+
+    expr: str
+
+    def __str__(self) -> str:
+        return f"ReactiveAttribute(name={self.name}, expr={self.expr})"
+
+
+@dataclass
+class SpreadAttribute(SpecialAttribute):
+    """
+    {**attrs} (preprocessed to __pywire_spread__="{**attrs}")
+    Represents a spread of attributes.
+    """
+
+    expr: str
+
+    def __str__(self) -> str:
+        return f"SpreadAttribute(expr={self.expr})"
+
+
+@dataclass
+class InterpolationNode(ASTNode):
+    """Represents {variable} in text.
+
+    Use {$html expr} syntax for raw/unescaped output.
+    """
+
+    expression: str  # Python expression to evaluate
+    is_raw: bool = False  # If True, output is not HTML-escaped (use {$html expr})
+
+    def __str__(self) -> str:
+        raw_str = ", raw=True" if self.is_raw else ""
+        return f"InterpolationNode(expr={self.expression}{raw_str})"
+
+
+@dataclass
+class TemplateNode(ASTNode):
+    """HTML element or text node."""
+
+    tag: Optional[str]  # None for text nodes
+    attributes: Dict[str, str] = field(default_factory=dict)  # Regular HTML attributes
+    special_attributes: List[Union[SpecialAttribute, "InterpolationNode"]] = field(
+        default_factory=list
+    )
+    children: List["TemplateNode"] = field(default_factory=list)
+    text_content: Optional[str] = None
+    is_raw: bool = False
+
+    def __str__(self) -> str:
+        if self.tag:
+            return (
+                f"TemplateNode(tag={self.tag}, attrs={len(self.attributes)}, "
+                f"special={len(self.special_attributes)}, "
+                f"children={len(self.children)})"
+            )
+        return f"TemplateNode(text={self.text_content[:30] if self.text_content else None})"
+
+
+@dataclass
+class ParsedPyWire:
+    """Top-level parsed document."""
+
+    directives: List[Directive] = field(default_factory=list)
+    template: List[TemplateNode] = field(default_factory=list)
+    python_code: str = ""  # Raw Python section (above ---html---)
+    python_ast: Optional[ast.Module] = None  # Parsed Python AST
+    file_path: str = ""
+
+    def get_directive_by_type(self, directive_type: type) -> Optional[Directive]:
+        """Get first directive of specified type."""
+        for directive in self.directives:
+            if isinstance(directive, directive_type):
+                return directive
+        return None
+
+    def get_directives_by_type(self, directive_type: type) -> List[Directive]:
+        """Get all directives of specified type."""
+        return [d for d in self.directives if isinstance(d, directive_type)]
+
+    def __str__(self) -> str:
+        return (
+            f"ParsedPyWire(directives={len(self.directives)}, "
+            f"template_nodes={len(self.template)}, "
+            f"python_lines={len(self.python_code.splitlines())})"
+        )

pywire/compiler/attributes/__init__.py

@@ -0,0 +1,6 @@
+"""Attribute parsers."""
+
+from pywire.compiler.attributes.base import AttributeParser
+from pywire.compiler.attributes.events import EventAttributeParser
+
+__all__ = ["AttributeParser", "EventAttributeParser"]

pywire/compiler/attributes/base.py

@@ -0,0 +1,24 @@
+"""Base attribute parser."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from pywire.compiler.ast_nodes import SpecialAttribute
+
+
+class AttributeParser(ABC):
+    """Base class for parsing special attributes - extensible for $, @, : types."""
+
+    PREFIX: str  # '@', '$', or ':'
+
+    @abstractmethod
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if this parser can handle the attribute."""
+        return attr_name.startswith(self.PREFIX)
+
+    @abstractmethod
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[SpecialAttribute]:
+        """Parse attribute. Returns None if not applicable."""
+        pass

pywire/compiler/attributes/conditional.py

@@ -0,0 +1,37 @@
+"""Conditional attribute parsers ($if, $show)."""
+
+from typing import Optional
+
+from pywire.compiler.ast_nodes import IfAttribute, ShowAttribute, SpecialAttribute
+from pywire.compiler.attributes.base import AttributeParser
+from pywire.compiler.exceptions import PyWireSyntaxError
+
+
+class ConditionalAttributeParser(AttributeParser):
+    """Parses $if and $show attributes."""
+
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if attribute is $if or $show."""
+        return attr_name in ("$if", "$show")
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[SpecialAttribute]:
+        """Parse conditional attribute."""
+        if not (attr_value.startswith("{") and attr_value.endswith("}")):
+            raise PyWireSyntaxError(
+                f"Value for '{attr_name}' must be wrapped in brackets: {attr_name}={{expr}}",
+                line=line,
+            )
+
+        expr = attr_value[1:-1].strip()
+
+        if attr_name == "$if":
+            return IfAttribute(
+                name=attr_name, value=attr_value, condition=expr, line=line, column=col
+            )
+        elif attr_name == "$show":
+            return ShowAttribute(
+                name=attr_name, value=attr_value, condition=expr, line=line, column=col
+            )
+        return None

pywire/compiler/attributes/events.py

@@ -0,0 +1,55 @@
+"""Event attribute parser."""
+
+import re
+from typing import List, Optional
+
+from pywire.compiler.ast_nodes import EventAttribute
+from pywire.compiler.attributes.base import AttributeParser
+from pywire.compiler.exceptions import PyWireSyntaxError
+
+
+class EventAttributeParser(AttributeParser):
+    """Parses @event attributes (click, submit, etc.)."""
+
+    PREFIX = "@"
+    PATTERN = re.compile(r"^@(\w+)$")
+
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if attribute starts with @."""
+        return attr_name.startswith(self.PREFIX)
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[EventAttribute]:
+        """Parse @click.prevent.stop={handler_name} attribute."""
+        # Remove @ prefix
+        full_event = attr_name[1:]
+        parts = full_event.split(".")
+        event_type = parts[0]
+        modifiers = [m for m in parts[1:] if m]
+
+        if not (attr_value.startswith("{") and attr_value.endswith("}")):
+            raise PyWireSyntaxError(
+                f"Event handler for '{attr_name}' must be wrapped in brackets: "
+                f"{attr_name}={{expr}}",
+                line=line,
+            )
+
+        handler_name = attr_value[1:-1].strip()  # Strip brackets and whitespace
+
+        # Parse handler args if present (future: handler(arg1, arg2))
+        handler_args: List[str] = []
+        if "(" in handler_name:
+            # Future: parse args
+            pass
+
+        return EventAttribute(
+            name=attr_name,
+            value=attr_value,
+            event_type=event_type,
+            handler_name=handler_name,
+            modifiers=modifiers,
+            args=handler_args,
+            line=line,
+            column=col,
+        )

pywire/compiler/attributes/form.py

@@ -0,0 +1,37 @@
+"""Form attribute parsers for $model and $field."""
+
+from typing import Optional
+
+from pywire.compiler.ast_nodes import ModelAttribute
+from pywire.compiler.attributes.base import AttributeParser
+
+
+class ModelAttributeParser(AttributeParser):
+    """Parses $model={ModelClassName} attribute for Pydantic binding."""
+
+    PREFIX = "$model"
+
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if attribute is $model."""
+        return attr_name == "$model"
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[ModelAttribute]:
+        """Parse $model={ClassName} attribute."""
+        if attr_name != "$model":
+            return None
+
+        model_name = attr_value.strip().strip("\"'")
+        if model_name.startswith("{") and model_name.endswith("}"):
+            model_name = model_name[1:-1].strip()
+        if not model_name:
+            return None
+
+        return ModelAttribute(
+            name=attr_name,
+            value=attr_value,
+            model_name=model_name,
+            line=line,
+            column=col,
+        )

pywire/compiler/attributes/loop.py

@@ -0,0 +1,75 @@
+"""Loop attribute parsers ($for, $key)."""
+
+from typing import Optional
+
+from pywire.compiler.ast_nodes import ForAttribute, KeyAttribute, SpecialAttribute
+from pywire.compiler.attributes.base import AttributeParser
+from pywire.compiler.exceptions import PyWireSyntaxError
+
+
+class LoopAttributeParser(AttributeParser):
+    """Parses $for attributes."""
+
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if attribute is $for."""
+        return attr_name == "$for"
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[SpecialAttribute]:
+        """Parse $for attribute."""
+        if not (attr_value.startswith("{") and attr_value.endswith("}")):
+            raise PyWireSyntaxError(
+                f"Value for '{attr_name}' must be wrapped in brackets: "
+                f"{attr_name}={{item in items}}",
+                line=line,
+            )
+
+        expr = attr_value[1:-1].strip()
+        # Parse "item in items" or "key, value in items"
+        parts = expr.split(" in ", 1)
+        if len(parts) != 2:
+            # We don't raise error here, just return nothing or let it be
+            # handled as valid attribute?
+            # Ideally validation happens here.
+            # But creating AST node blindly is safer if we want to defer errors.
+            # But "item in items" is pretty fundamental.
+            raise ValueError(
+                f"Invalid $for syntax at line {line}: '{attr_value}'. Expected 'item in items'."
+            )
+
+        loop_vars = parts[0].strip()
+        iterable = parts[1].strip()
+
+        return ForAttribute(
+            name=attr_name,
+            value=attr_value,
+            is_template_tag=False,  # Populated later
+            loop_vars=loop_vars,
+            iterable=iterable,
+            line=line,
+            column=col,
+        )
+
+
+class KeyAttributeParser(AttributeParser):
+    """Parses $key attributes."""
+
+    def can_parse(self, attr_name: str) -> bool:
+        """Check if attribute is $key."""
+        return attr_name == "$key"
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[SpecialAttribute]:
+        """Parse $key attribute."""
+        if not (attr_value.startswith("{") and attr_value.endswith("}")):
+            raise PyWireSyntaxError(
+                f"Value for '{attr_name}' must be wrapped in brackets: {attr_name}={{expr}}",
+                line=line,
+            )
+
+        expr = attr_value[1:-1].strip()
+        return KeyAttribute(
+            name=attr_name, value=attr_value, expr=expr, line=line, column=col
+        )

pywire/compiler/attributes/reactive.py

@@ -0,0 +1,34 @@
+"""Reactive attribute parser (:attr)."""
+
+from typing import Optional
+
+from pywire.compiler.ast_nodes import ReactiveAttribute, SpecialAttribute
+from pywire.compiler.attributes.base import AttributeParser
+
+
+class ReactiveAttributeParser(AttributeParser):
+    """Parses reactive attributes starting with :"""
+
+    def can_parse(self, attr_name: str) -> bool:
+        """
+        Check if attribute starts with : but is NOT a directive like :class (if we had those)
+        or other special chars.
+        Actually requirements say: ":attribute"
+        "it explicitly does NOT support framework attributes like anything starting with @ or $"
+        But @ and $ are handled by other parsers anyway.
+        So we just check for starting with :
+        """
+        # Disabled: :prop="val" syntax is deprecated.
+        # Reactive attributes must use prop={expr} syntax which is handled by parser fallback.
+        return False
+
+    def parse(
+        self, attr_name: str, attr_value: str, line: int, col: int
+    ) -> Optional[SpecialAttribute]:
+        """Parse attr={expr}"."""
+        # Strip the leading :
+        real_name = attr_name[1:]
+
+        return ReactiveAttribute(
+            name=real_name, value=attr_value, expr=attr_value, line=line, column=col
+        )

pywire/compiler/build.py

@@ -0,0 +1,28 @@
+"""Build system for production."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from pywire.compiler.build_artifacts import BuildSummary
+
+
+def build_project(
+    optimize: bool = False,
+    pages_dir: Optional[Path] = None,
+    out_dir: Optional[Path] = None,
+) -> BuildSummary:
+    """Build project for production."""
+    if pages_dir is None:
+        pages_dir = Path("pages")
+
+    from pywire.cli.validate import validate_project
+    from pywire.compiler.build_artifacts import build_artifacts
+
+    errors = validate_project(pages_dir=pages_dir)
+    if errors:
+        raise ValueError(f"Build failed with {len(errors)} errors")
+
+    return build_artifacts(pages_dir=pages_dir, out_dir=out_dir, optimize=optimize)