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

pywire/compiler/directives/__init__.py

@@ -1,7 +0,0 @@
-"""Directive parsers."""
-
-from pywire.compiler.directives.base import DirectiveParser
-from pywire.compiler.directives.no_spa import NoSpaDirectiveParser
-from pywire.compiler.directives.path import PathDirectiveParser
-
-__all__ = ["DirectiveParser", "PathDirectiveParser", "NoSpaDirectiveParser"]

pywire/compiler/directives/base.py

@@ -1,20 +0,0 @@
-"""Base directive parser."""
-
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from pywire.compiler.ast_nodes import Directive
-
-
-class DirectiveParser(ABC):
-    """Base class for parsing directives - extensible for new directives."""
-
-    @abstractmethod
-    def can_parse(self, line: str) -> bool:
-        """Check if this parser can handle the given line."""
-        pass
-
-    @abstractmethod
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
-        """Parse directive from line. Returns None if not applicable."""
-        pass

pywire/compiler/directives/component.py

@@ -1,33 +0,0 @@
-import re
-from typing import Optional
-
-from pywire.compiler.ast_nodes import ComponentDirective, Directive
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class ComponentDirectiveParser(DirectiveParser):
-    """Parses !component 'path' as Name"""
-
-    def can_parse(self, line: str) -> bool:
-        return line.startswith("!component")
-
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
-        # Format: !component 'path/to/file' as ComponentName
-        # or !component "path/to/file" as ComponentName
-
-        # Regex to match: !component\s+['"](.+?)['"]\s+as\s+(\w+)
-        match = re.search(r"^!component\s+['\"](.+?)['\"]\s+as\s+(\w+)", line)
-        if not match:
-            # Maybe invalid format
-            return None
-
-        path = match.group(1)
-        name = match.group(2)
-
-        return ComponentDirective(
-            line=line_num,
-            column=col_num,
-            name="!component",
-            path=path,
-            component_name=name,
-        )

pywire/compiler/directives/context.py

@@ -1,93 +0,0 @@
-import ast
-from typing import Optional
-
-from pywire.compiler.ast_nodes import Directive, InjectDirective, ProvideDirective
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class ContextDirectiveParser(DirectiveParser):
-    """Parses !inject and !provide"""
-
-    def can_parse(self, line: str) -> bool:
-        return line.startswith("!inject") or line.startswith("!provide")
-
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
-        is_inject = line.startswith("!inject")
-        directive_name = "!inject" if is_inject else "!provide"
-
-        content = line[len(directive_name) :].strip()
-
-        # Wrapped in dict braces?
-        if not content.startswith("{") or not content.endswith("}"):
-            # Maybe they omitted braces? Let's assume strict syntax for now as per design doc
-            # !inject { ... }
-            return None
-
-        try:
-            # Parse as a dictionary expression
-            # code: _ = { ... }
-            dummy_code = f"_ = {content}"
-            mod = ast.parse(dummy_code)
-            assign = mod.body[0]
-            if not isinstance(assign, ast.Assign) or not isinstance(
-                assign.value, ast.Dict
-            ):
-                return None
-
-            dict_node = assign.value
-
-            mapping = {}
-
-            for key_node, value_node in zip(dict_node.keys, dict_node.values):
-                if is_inject:
-                    # !inject { local_var: 'GLOBAL_KEY' }
-                    # key should be the local variable name (Name node or Constant string)
-                    # value should be the context key (Constant string)
-
-                    local_var = None
-                    if isinstance(key_node, ast.Name):
-                        local_var = key_node.id
-                    elif isinstance(key_node, ast.Constant) and isinstance(
-                        key_node.value, str
-                    ):
-                        local_var = key_node.value
-
-                    global_key = None
-                    if isinstance(value_node, ast.Constant) and isinstance(
-                        value_node.value, str
-                    ):
-                        global_key = value_node.value
-
-                    if local_var and global_key:
-                        mapping[local_var] = global_key
-
-                else:
-                    # !provide { 'GLOBAL_KEY': local_expr }
-                    # key must be string
-                    # value is expression to be evaluated at runtime
-
-                    global_key = None
-                    if isinstance(key_node, ast.Constant) and isinstance(
-                        key_node.value, str
-                    ):
-                        global_key = key_node.value
-
-                    # Convert value node back to source string to be put in generated code
-                    val_expr = ""
-                    if hasattr(ast, "unparse"):
-                        val_expr = ast.unparse(value_node)
-
-                    if global_key:
-                        mapping[global_key] = val_expr
-
-            if is_inject:
-                return InjectDirective(
-                    line=line_num, column=col_num, name="!inject", mapping=mapping
-                )
-            else:
-                return ProvideDirective(
-                    line=line_num, column=col_num, name="!provide", mapping=mapping
-                )
-
-        except Exception:
-            return None

pywire/compiler/directives/layout.py

@@ -1,49 +0,0 @@
-"""Layout directive parser."""
-
-import ast
-import re
-from typing import Optional
-
-from pywire.compiler.ast_nodes import LayoutDirective
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class LayoutDirectiveParser(DirectiveParser):
-    """Parses !layout directives."""
-
-    PATTERN = re.compile(r"^!layout\s+(.+)$", re.DOTALL)
-
-    def can_parse(self, line: str) -> bool:
-        """Check if line starts with !layout."""
-        return line.strip().startswith("!layout")
-
-    def parse(
-        self, line: str, line_num: int, col_num: int
-    ) -> Optional[LayoutDirective]:
-        """Parse !layout "path/to/layout" directive."""
-        match = self.PATTERN.match(line.strip())
-        if not match:
-            return None
-
-        path_str = match.group(1).strip()
-        if not path_str:
-            return None
-
-        try:
-            # Parse python string
-            # We expect a simple string literal
-            expr_ast = ast.parse(path_str, mode="eval")
-
-            if isinstance(expr_ast.body, ast.Constant) and isinstance(
-                expr_ast.body.value, str
-            ):
-                return LayoutDirective(
-                    name="layout",
-                    layout_path=expr_ast.body.value,
-                    line=line_num,
-                    column=col_num,
-                )
-
-            return None
-        except (SyntaxError, ValueError, AttributeError):
-            return None

pywire/compiler/directives/no_spa.py

@@ -1,24 +0,0 @@
-"""No-SPA directive parser."""
-
-import re
-from typing import Optional
-
-from pywire.compiler.ast_nodes import NoSpaDirective
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class NoSpaDirectiveParser(DirectiveParser):
-    """Parses !no_spa directive to disable client-side navigation."""
-
-    PATTERN = re.compile(r"^!no_spa\s*$")
-
-    def can_parse(self, line: str) -> bool:
-        """Check if line is !no_spa."""
-        return line.strip() == "!no_spa"
-
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[NoSpaDirective]:
-        """Parse !no_spa directive."""
-        if not self.PATTERN.match(line.strip()):
-            return None
-
-        return NoSpaDirective(name="no_spa", line=line_num, column=col_num)

pywire/compiler/directives/path.py

@@ -1,71 +0,0 @@
-"""Path directive parser."""
-
-import ast
-import re
-from typing import Dict, Optional
-
-from pywire.compiler.ast_nodes import PathDirective
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class PathDirectiveParser(DirectiveParser):
-    """Parses !path directives."""
-
-    PATTERN = re.compile(r"^!path\s+(.+)$", re.DOTALL)
-
-    def can_parse(self, line: str) -> bool:
-        """Check if line starts with !path."""
-        return line.strip().startswith("!path")
-
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[PathDirective]:
-        """Parse !path { 'name': '/route' } directive."""
-        match = self.PATTERN.match(line.strip())
-        if not match:
-            return None
-
-        routes_str = match.group(1).strip()
-        if not routes_str:
-            return None
-
-        try:
-            # Parse python expression
-            expr_ast = ast.parse(routes_str, mode="eval")
-
-            # Case 1: Dictionary !path {'main': '/'}
-            if isinstance(expr_ast.body, ast.Dict):
-                routes: Dict[str, str] = {}
-                for key_node, value_node in zip(
-                    expr_ast.body.keys, expr_ast.body.values
-                ):
-                    if (
-                        not isinstance(key_node, ast.Constant)
-                        or not isinstance(key_node.value, str)
-                        or not isinstance(value_node, ast.Constant)
-                        or not isinstance(value_node.value, str)
-                    ):
-                        return None
-                    routes[key_node.value] = value_node.value
-
-                return PathDirective(
-                    name="path",
-                    routes=routes,
-                    is_simple_string=False,
-                    line=line_num,
-                    column=col_num,
-                )
-
-            # Case 2: String !path '/test'
-            elif isinstance(expr_ast.body, ast.Constant) and isinstance(
-                expr_ast.body.value, str
-            ):
-                return PathDirective(
-                    name="path",
-                    routes={"main": expr_ast.body.value},
-                    is_simple_string=True,
-                    line=line_num,
-                    column=col_num,
-                )
-
-            return None
-        except (SyntaxError, ValueError, AttributeError):
-            return None

pywire/compiler/directives/props.py

@@ -1,88 +0,0 @@
-import ast
-from typing import List, Optional, Tuple
-
-from pywire.compiler.ast_nodes import Directive, PropsDirective
-from pywire.compiler.directives.base import DirectiveParser
-
-
-class PropsDirectiveParser(DirectiveParser):
-    """Parses !props(name: type, arg=default)"""
-
-    def can_parse(self, line: str) -> bool:
-        return line.startswith("!props")
-
-    def parse(self, line: str, line_num: int, col_num: int) -> Optional[Directive]:
-        # Format: !props(arg: type, arg2=default)
-
-        # 1. Extract content inside parentheses
-        # Note: 'line' might be multiline string passed from parser.
-        # We assume the parser handles accumulation until matching parens if needed.
-        # Or we rely on the fact that directives are usually single line or we need to handle it.
-        # The main parser accumulates if braces/brackets match, but what about parens?
-        # The main parser logic: "Count open braces/brackets". It does NOT count parens currently.
-        # We might need to update the main parser to also count parens for !props?
-        # For now, let's assume it's passed correctly or single line.
-
-        # Strip '!props'
-        content = line[len("!props") :].strip()
-        if not content.startswith("(") or not content.endswith(")"):
-            return None
-
-        # content is "(...)"
-
-        # 2. Use AST parsing by wrapping in a function def
-        # This handles complex types, strings with commas, etc.
-        dummy_code = f"def _p{content}: pass"
-
-        try:
-            mod = ast.parse(dummy_code)
-            func_def = mod.body[0]
-            if not isinstance(func_def, ast.FunctionDef):
-                return None
-
-            args = func_def.args
-
-            parsed_args: List[Tuple[str, str, Optional[str]]] = []
-
-            # Helper to get source segment if possible, or unparse
-            def unparse_node(node: ast.AST) -> str:
-                if hasattr(ast, "unparse"):
-                    source = ast.unparse(node)
-                    # ast.unparse might return something slightly different formatted,
-                    # which is fine for type strings
-                    return source
-                return ""  # Fallback for older python if needed, but we likely preserve 3.9+
-
-            # Process args (normal arguments)
-            # defaults are at the end of the list.
-            # e.g. args.args = [a, b], args.defaults = [def_b] -> a has no default, b has def_b
-
-            num_args = len(args.args)
-            num_defaults = len(args.defaults)
-            offset = num_args - num_defaults
-
-            for i, arg in enumerate(args.args):
-                name = arg.arg
-                type_hint = "Any"
-                if arg.annotation:
-                    type_hint = unparse_node(arg.annotation)
-
-                default_val = None
-                if i >= offset:
-                    default_idx = i - offset
-                    default_val = unparse_node(args.defaults[default_idx])
-
-                parsed_args.append((name, type_hint, default_val))
-
-            # TODO: Handle kwonlyargs if we want to enforce keyword only props?
-            # For now simple args.
-
-            return PropsDirective(
-                line=line_num, column=col_num, name="!props", args=parsed_args
-            )
-
-        except SyntaxError:
-            # Invalid python syntax in props
-            return None
-        except Exception:
-            return None

pywire/compiler/exceptions.py

@@ -1,19 +0,0 @@
-"""Compiler exceptions."""
-
-
-class PyWireSyntaxError(Exception):
-    """Raised when PyWire syntax is invalid."""
-
-    def __init__(
-        self, message: str, file_path: str = "", line: int = 0, column: int = 0
-    ):
-        self.message = message
-        self.file_path = file_path
-        self.line = line
-        self.column = column
-        super().__init__(message)
-
-    def __str__(self) -> str:
-        if self.file_path and self.line:
-            return f"{self.file_path}:{self.line}: {self.message}"
-        return self.message

pywire/compiler/interpolation/__init__.py

@@ -1,6 +0,0 @@
-"""Interpolation parsers."""
-
-from pywire.compiler.interpolation.base import InterpolationParser
-from pywire.compiler.interpolation.jinja import JinjaInterpolationParser
-
-__all__ = ["InterpolationParser", "JinjaInterpolationParser"]

pywire/compiler/interpolation/base.py

@@ -1,28 +0,0 @@
-"""Base interpolation parser."""
-
-from abc import ABC, abstractmethod
-from typing import List, Union
-
-from pywire.compiler.ast_nodes import InterpolationNode
-
-
-class InterpolationParser(ABC):
-    """Base class for parsing interpolations - can swap Jinja for custom later."""
-
-    @abstractmethod
-    def parse(
-        self, text: str, line: int, col: int
-    ) -> List[Union[str, InterpolationNode]]:
-        """
-        Parse text with interpolations into mix of strings and InterpolationNodes.
-        Returns: ['Hello, ', InterpolationNode(expr='name'), '!']
-        """
-        pass
-
-    @abstractmethod
-    def compile(self, text: str) -> str:
-        """
-        Compile to Python code for runtime.
-        'Hello {name}!' → f'Hello {self.name}!'
-        """
-        pass