Nexa.py 0.5.0__py3-none-any.whl

Nexa/Core/__init__.py

@@ -0,0 +1,5 @@
+"""Nexa Core browser/Python communication runtime."""
+
+from .core import Core
+
+__all__ = ["Core"]

Nexa/Core/core.py

@@ -0,0 +1,80 @@
+"""Event-based browser/Python communication over an NXserver instance."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+from weakref import WeakKeyDictionary
+
+from ..nxserver import NXserver, jsonify, request
+
+
+class Core:
+    """Register browser-callable Python events on the existing NXserver.
+
+    Browser clients POST ``{"event": "name", "data": {...}}`` to the
+    app-specific ``core_event_endpoint`` installed by :meth:`init_app`.
+    """
+
+    _event_handlers: dict[str, Callable[[dict[str, Any]], Any]] = {}
+    _apps: WeakKeyDictionary[NXserver, str] = WeakKeyDictionary()
+
+    @classmethod
+    def event(cls, name: str):
+        """Register a Python handler callable from a browser event request."""
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError("Core event names must be non-empty strings.")
+        name = name.strip()
+
+        def decorator(handler: Callable[[dict[str, Any]], Any]):
+            if name in cls._event_handlers:
+                raise ValueError(f"Core event {name!r} is already registered.")
+            cls._event_handlers[name] = handler
+            return handler
+
+        return decorator
+
+    @classmethod
+    def init_app(cls, app: NXserver) -> NXserver:
+        """Attach Core's event endpoint to *app* without starting another server."""
+        if not isinstance(app, NXserver):
+            raise TypeError("Core.init_app() requires an NXserver instance.")
+        if app in cls._apps:
+            return app
+
+        endpoint = "/__nexa/core/events"
+        suffix = 1
+        while app.router.route_for_path(endpoint) is not None:
+            endpoint = f"/__nexa/core/events-{suffix}"
+            suffix += 1
+
+        @app.post(endpoint)
+        def dispatch_event():
+            payload = request.json
+            if not isinstance(payload, dict):
+                return jsonify(
+                    {"error": "Request body must be a JSON object."}, status=400
+                )
+
+            event_name = payload.get("event")
+            if not isinstance(event_name, str) or not event_name:
+                return jsonify(
+                    {"error": "A non-empty 'event' name is required."}, status=400
+                )
+
+            handler = cls._event_handlers.get(event_name)
+            if handler is None:
+                return jsonify(
+                    {"error": f"Unknown Core event {event_name!r}."}, status=404
+                )
+
+            data = payload.get("data", {})
+            if not isinstance(data, dict):
+                return jsonify(
+                    {"error": "Core event 'data' must be a JSON object."}, status=400
+                )
+
+            return jsonify(handler(data))
+
+        app.core_event_endpoint = endpoint
+        cls._apps[app] = endpoint
+        return app

Nexa/LIB/env.py

@@ -0,0 +1,43 @@
+
+import sys
+import tomllib
+from pathlib import Path
+
+
+class __env_init_err__(Exception):
+    pass
+
+
+def __get_lib__bin(script: str):
+    try:
+        import importlib
+        return importlib.import_module(f"nexa.BIN.{script}")
+    except ModuleNotFoundError as exc:
+        if exc.name == f"nexa.BIN.{script}" or exc.name.startswith("nexa.BIN."):
+            raise __env_init_err__(
+                f"CDE CNTFNDCRPT: Cannot find nexa.BIN.{script}"
+            ) from exc
+        raise
+
+
+def __env_setup__():
+    cwd = Path.cwd()
+    cwd_str = str(cwd)
+
+    if cwd_str not in sys.path:
+        sys.path.insert(0, cwd_str)
+
+    config_path = cwd / "nexa.toml"
+
+    if not config_path.is_file():
+        raise __env_init_err__(
+            f"CDE CNTFNDTOML: nexa.toml not found in {cwd}"
+        )
+
+    try:
+        with config_path.open("rb") as file:
+            return tomllib.load(file)
+    except tomllib.TOMLDecodeError as exc:
+        raise __env_init_err__(
+            f"CDE INVALIDTOML: {exc}"
+        ) from exc

Nexa/NEXA/nexa_stp.py

@@ -0,0 +1,118 @@
+
+from pathlib import Path
+import runpy
+import sys
+import tomllib
+
+
+class AbordErr(Exception):
+    pass
+
+
+class ScriptError(Exception):
+    pass
+
+
+def getYNinput(text: str) -> bool:
+    while True:
+        try:
+            inp = input(text).strip().lower()
+        except KeyboardInterrupt:
+            print()
+            continue
+
+        if inp == "y":
+            return True
+        if inp == "n":
+            return False
+        print("Please enter y or n.")
+
+
+class Scripts:
+    def __init__(self, config_path="nexa.toml"):
+        self.project_dir = Path.cwd().resolve()
+        self.config_path = self.project_dir / config_path
+
+        if not self.config_path.is_file():
+            raise ScriptError(
+                f"Nexa configuration not found: {self.config_path}"
+            )
+
+        try:
+            with self.config_path.open("rb") as file:
+                self.config = tomllib.load(file)
+        except tomllib.TOMLDecodeError as exc:
+            raise ScriptError(f"Invalid nexa.toml: {exc}") from exc
+
+        self.scripts = self.config.get("scripts", {})
+
+    def resolve(self, script_name: str) -> Path:
+        # Use an alias if one exists; otherwise treat it as a file path.
+        target = self.scripts.get(script_name, script_name)
+        path = Path(target)
+
+        if not path.is_absolute():
+            path = self.project_dir / path
+
+        path = path.resolve()
+
+        if not path.is_file():
+            available = ", ".join(self.scripts) or "(none)"
+            raise ScriptError(
+                f"Script file not found: {path}\n"
+                f"Configured targets: {available}"
+            )
+
+        if path.suffix.lower() not in {".py", ".nx"}:
+            raise ScriptError(f"Unsupported script type: {path.suffix}")
+
+        return path
+
+    def toexec(self, script_name: str, noenv: bool = False):
+        project = str(self.project_dir)
+        if project not in sys.path:
+            sys.path.insert(0, project)
+
+        path = self.resolve(script_name)
+
+        if not noenv:
+            try:
+                from ..LIB.env import __env_setup__
+                __env_setup__()
+            except Exception as exc:
+                raise ScriptError(
+                    f"Environment initialization failed: {exc}"
+                ) from exc
+
+        sys.argv = [str(path)]
+
+        def execute():
+            if path.suffix.lower() == ".py":
+                runpy.run_path(str(path), run_name="__main__")
+                return
+
+            try:
+                from compiler import compile_file
+            except ImportError as exc:
+                raise ScriptError(
+                    f"Cannot import compile_file from compiler.py: {exc}"
+                ) from exc
+
+            source = compile_file(path)
+            code = compile(source, str(path), "exec")
+            namespace = {
+                "__name__": "__main__",
+                "__file__": str(path),
+                "__package__": None,
+            }
+            exec(code, namespace)
+
+        while True:
+            try:
+                execute()
+                return
+            except KeyboardInterrupt:
+                print()
+                if getYNinput("Are you sure you want to abort? [y/n]: "):
+                    raise AbordErr("Execution aborted by user.")
+                print("Resuming execution...")

Nexa/__init__.py

@@ -0,0 +1,79 @@
+
+try:
+    from .nexa import app
+except ImportError:
+    app = None  # typer not installed
+from .nx import App, Element, Fragment
+from .nxserver import NXserver, Nserver, jsonify, render_template,request
+from .blueprint import Blueprint
+from .Core import Core
+from .nforms import (
+    Form,
+    ValidationError,
+    CharField,
+    EmailField,
+    IntegerField,
+    FloatField,
+    BooleanField,
+    DateField,
+    DateTimeField,
+    ChoiceField,
+    MultipleChoiceField,
+    PasswordField,
+    TextInput,
+    EmailInput,
+    PasswordInput,
+    NumberInput,
+    CheckboxInput,
+    Select,
+    Textarea,
+    HiddenInput,
+)
+
+# Create Nforms namespace class for cleaner imports
+class Nforms:
+    '''Nexa's native form-handling system.'''
+    Form = Form
+    ValidationError = ValidationError
+    CharField = CharField
+    EmailField = EmailField
+    IntegerField = IntegerField
+    FloatField = FloatField
+    BooleanField = BooleanField
+    DateField = DateField
+    DateTimeField = DateTimeField
+    ChoiceField = ChoiceField
+    MultipleChoiceField = MultipleChoiceField
+    PasswordField = PasswordField
+    TextInput = TextInput
+    EmailInput = EmailInput
+    PasswordInput = PasswordInput
+    NumberInput = NumberInput
+    CheckboxInput = CheckboxInput
+    Select = Select
+    Textarea = Textarea
+    HiddenInput = HiddenInput
+
+    # Also expose widgets that map to field types
+    DateInput = TextInput  # DateField uses TextInput for now
+    
+from os import getenv as _env
+
+def getenv(key:str,default):
+    return _env(key,default)
+
+
+__all__ = [
+    "app",
+    "App",
+    "Element",
+    "Fragment",
+    "NXserver",
+    "Nserver",
+    "Core",
+    "jsonify",
+    "render_template",
+    "Blueprint",
+    "getenv",
+    "Nforms"
+]

Nexa/__json.py

@@ -0,0 +1,33 @@
+
+import json
+from typing import Any
+
+
+class JSONResponse:
+    """A response that renders its data as JSON.
+    
+    This class is also re-exported by nxserver.jsonify() and can be used
+    directly if you prefer the explicit style.
+    """
+
+    def __init__(self, data: Any, status: int = 200) -> None:
+        self.data = data
+        self.status = status
+
+    def render(self) -> str:
+        """Return the JSON-encoded body for this response."""
+        return json.dumps(self.data, ensure_ascii=False)
+
+
+def jsonify(data: Any, status: int = 200) -> JSONResponse:
+    """Create a JSON response for a Nexa route.
+
+    Args:
+        data: Any JSON-serializable value (dicts, lists, strings, numbers,
+            booleans, and None all work).
+        status: HTTP status code to attach to the response. Defaults to 200.
+
+    Returns:
+        A JSONResponse instance that the Nexa server can render.
+    """
+    return JSONResponse(data=data, status=status)

Nexa/__main__.py

@@ -0,0 +1,4 @@
+from .nexa import app
+if __name__ == "__main__":
+    app()
+    

Nexa/blueprint.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Optional
+
+_METHOD_NAMES = {"GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}
+
+
+class Blueprint:
+    """A Blueprint groups related routes under a common prefix.
+
+    Blueprints use the same decorator-style API as :class:`NXserver`::
+
+        api = Blueprint("api", prefix="/api")
+
+        @api.get("/ping")
+        def pong():
+            return jsonify({"status": "ok"})
+
+        @api.route("/users", methods=["GET", "POST"])
+        def users():
+            ...
+
+    The blueprint is registered on the server with
+    :meth:`NXserver.register_blueprint`.
+    """
+
+    def __init__(self, name: str, prefix: str = "") -> None:
+        if not name.isidentifier():
+            raise ValueError(f"Blueprint name {name!r} must be a valid Python identifier")
+        self.name = name
+        self.prefix = prefix.rstrip("/")
+        self._routes: list[tuple[str, Callable, set[str]]] = []
+
+    def _add_route(self, path: str, methods: Optional[set[str]] = None):
+        """Return a decorator that registers a route."""
+        if not path.startswith("/"):
+            raise ValueError("Routes must start with '/'")
+
+        if methods is None:
+            method_set = {"GET", "HEAD"}
+        else:
+            method_set = {m.upper() for m in methods}
+            for m in method_set:
+                if m not in _METHOD_NAMES and m != "HEAD":
+                    raise ValueError(f"Unsupported HTTP method {m!r}")
+
+        if "HEAD" not in method_set:
+            method_set.add("HEAD")
+
+        def decorator(handler: Callable) -> Callable:
+            self._routes.append((path, handler, method_set))
+            return handler
+
+        return decorator
+
+    def route(self, path: str, methods: Optional[list[str]] = None):
+        """Register a handler for *path* on this blueprint.
+
+        Args:
+            path: URL path relative to the blueprint prefix, e.g. ``"/ping"``.
+            methods: Optional explicit list of HTTP methods. When omitted the
+                handler responds to GET and HEAD.
+        """
+        method_set: Optional[set[str]] = None
+        if methods is not None:
+            method_set = {m.upper() for m in methods}
+        return self._add_route(path, method_set)
+
+    def get(self, path: str):
+        return self._add_route(path, {"GET"})
+
+    def post(self, path: str):
+        return self._add_route(path, {"POST"})
+
+    def put(self, path: str):
+        return self._add_route(path, {"PUT"})
+
+    def patch(self, path: str):
+        return self._add_route(path, {"PATCH"})
+
+    def delete(self, path: str):
+        return self._add_route(path, {"DELETE"})
+
+    def head(self, path: str):
+        return self._add_route(path, {"HEAD"})
+
+    def options(self, path: str):
+        return self._add_route(path, {"OPTIONS"})

Nexa/compiler.py

@@ -0,0 +1,217 @@
+
+import re
+from pathlib import Path
+
+
+class NexaSyntaxError(Exception):
+    pass
+
+
+TAG_OPEN = re.compile(
+    r"^\s*<([A-Za-z][\w.-]*)(.*?)>\s*$"
+)
+
+TAG_INLINE = re.compile(
+    r"^\s*<([A-Za-z][\w.-]*)(.*?)>(.*?)</\1>\s*$"
+)
+
+FOR_LINE = re.compile(r"^for\s+(.+?)\s*:\s*$")
+
+ATTRIBUTE = re.compile(
+    r"""([:\w-]+)\s*=\s*("([^"]*)"|'([^']*)'|\{([^{}]*)\})"""
+)
+
+
+def indentation(line):
+    return len(line) - len(line.lstrip())
+
+
+def compile_text(text):
+    """Convert text with {expressions} into a Python expression."""
+    parts = []
+    position = 0
+
+    for match in re.finditer(r"\{([^{}]+)\}", text):
+        literal = text[position:match.start()]
+        expression = match.group(1).strip()
+
+        if literal:
+            parts.append(repr(literal))
+
+        if not expression:
+            raise NexaSyntaxError("Empty expression inside {}")
+
+        parts.append(f"str({expression})")
+        position = match.end()
+
+    remaining = text[position:]
+
+    if remaining:
+        parts.append(repr(remaining))
+
+    if not parts:
+        return "''"
+
+    return " + ".join(parts)
+
+
+def compile_attributes(source):
+    props = {}
+
+    for match in ATTRIBUTE.finditer(source):
+        name = match.group(1)
+
+        if match.group(5) is not None:
+            value = match.group(5).strip()
+            if not value:
+                raise NexaSyntaxError(
+                    f"Empty expression for attribute {name!r}"
+                )
+        else:
+            value = repr(
+                match.group(3)
+                if match.group(3) is not None
+                else match.group(4)
+            )
+
+        props[name] = value
+
+    # Reject attribute syntax this prototype doesn't understand.
+    residue = ATTRIBUTE.sub("", source).strip()
+    if residue:
+        raise NexaSyntaxError(
+            f"Unsupported attribute syntax: {residue}"
+        )
+
+    return "{" + ", ".join(
+        f"{name!r}: {value}"
+        for name, value in props.items()
+    ) + "}"
+
+
+def parse_node(lines, index):
+    """Parse one JSX-like element or a loop containing one element."""
+    while index < len(lines) and not lines[index].strip():
+        index += 1
+
+    if index >= len(lines):
+        raise NexaSyntaxError("Expected an element")
+
+    line = lines[index]
+    indent = indentation(line)
+    stripped = line.strip()
+
+    loop_match = FOR_LINE.fullmatch(stripped)
+
+    if loop_match:
+        target = loop_match.group(1)
+
+        body_index = index + 1
+        while body_index < len(lines) and not lines[body_index].strip():
+            body_index += 1
+
+        if body_index >= len(lines):
+            raise NexaSyntaxError("Loop has no body")
+
+        if indentation(lines[body_index]) <= indent:
+            raise NexaSyntaxError(
+                f"Loop body must be indented: {stripped}"
+            )
+
+        body_expr, next_index = parse_node(lines, body_index)
+
+        return (
+            f"*({body_expr} for {target})",
+            next_index,
+        )
+
+    inline = TAG_INLINE.fullmatch(line)
+
+    if inline:
+        tag = inline.group(1)
+        raw_attrs = opening.group(2).strip()
+
+        # Remove the trailing slash from self-closing tags.
+        if raw_attrs.endswith("/"):
+            raw_attrs = raw_attrs[:-1].rstrip()
+
+        attrs = compile_attributes(raw_attrs)
+        content = compile_text(inline.group(3))
+
+        return f"Element({tag!r}, {attrs}, {content})", index + 1
+
+    opening = TAG_OPEN.fullmatch(line)
+
+    if not opening:
+        raise NexaSyntaxError(
+            f"Expected a JSX element at line {index + 1}: {stripped}"
+        )
+
+    tag = opening.group(1)
+    attrs = compile_attributes(opening.group(2))
+    children = []
+    index += 1
+
+    while index < len(lines):
+        current = lines[index]
+        current_text = current.strip()
+
+        if not current_text:
+            index += 1
+            continue
+
+        if current_text == f"</{tag}>":
+            index += 1
+            break
+
+        if current_text.startswith("</"):
+            raise NexaSyntaxError(
+                f"Unexpected closing tag at line {index + 1}: "
+                f"{current_text}"
+            )
+
+        if indentation(current) <= indent:
+            raise NexaSyntaxError(
+                f"Missing closing tag </{tag}>"
+            )
+
+        child_expr, index = parse_node(lines, index)
+        children.append(child_expr)
+
+    else:
+        raise NexaSyntaxError(f"Missing closing tag </{tag}>")
+
+    return (
+        f"Element({tag!r}, {attrs}"
+        + (", " + ", ".join(children) if children else "")
+        + ")",
+        index,
+    )
+
+
+def compile_source(source):
+    """Translate supported .nx markup into Python source."""
+    lines = source.splitlines()
+    output = []
+    index = 0
+
+    while index < len(lines):
+        line = lines[index]
+        stripped = line.strip()
+
+        if stripped.startswith("<") and not stripped.startswith("</"):
+            indent = indentation(line)
+            expression, next_index = parse_node(lines, index)
+
+            output.append(" " * indent + expression)
+            index = next_index
+        else:
+            output.append(line)
+            index += 1
+
+    return "\n".join(output) + "\n"
+
+
+def compile_file(path):
+    path = Path(path)
+    return compile_source(path.read_text(encoding="utf-8"))