pywire 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

pywire/compiler/ast_nodes.py

@@ -1,304 +0,0 @@
-"""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

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

pywire/compiler/attributes/base.py

@@ -1,24 +0,0 @@
-"""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

@@ -1,37 +0,0 @@
-"""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

@@ -1,55 +0,0 @@
-"""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

@@ -1,37 +0,0 @@
-"""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

@@ -1,75 +0,0 @@
-"""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

@@ -1,34 +0,0 @@
-"""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

@@ -1,28 +0,0 @@
-"""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)