uigen 0.1.0__py3-none-any.whl

uigen/__init__.py

@@ -0,0 +1,19 @@
+"""uigen — Write UI logic once, deploy anywhere."""
+
+from uigen.core.api import ui
+from uigen.core.compiler import App
+from uigen.core.schema import Field, Model
+from uigen.theme import Theme, get_theme, list_themes, register_theme
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Model",
+    "Field",
+    "ui",
+    "App",
+    "Theme",
+    "get_theme",
+    "list_themes",
+    "register_theme",
+]

uigen/_cext.c

@@ -0,0 +1,79 @@
+/**
+ * uigen C extension — fast HTML escaping
+ *
+ * This module provides C-accelerated HTML entity escaping.
+ *
+ * Build with: python setup.py build_ext --inplace
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <string.h>
+#include <stdlib.h>
+
+/**
+ * Fast HTML entity escaping
+ */
+static PyObject* escape_html(PyObject* self, PyObject* args) {
+    const char* input;
+    Py_ssize_t input_len;
+
+    if (!PyArg_ParseTuple(args, "s#", &input, &input_len)) {
+        return NULL;
+    }
+
+    /* Allocate output buffer (worst case: every char needs escaping) */
+    char* output = (char*)malloc(input_len * 7 + 1);
+    if (!output) {
+        return PyErr_NoMemory();
+    }
+
+    char* out = output;
+    for (Py_ssize_t i = 0; i < input_len; i++) {
+        char c = input[i];
+        switch (c) {
+            case '&':  memcpy(out, "&amp;", 5);  out += 5; break;
+            case '<':  memcpy(out, "&lt;", 4);   out += 4; break;
+            case '>':  memcpy(out, "&gt;", 4);   out += 4; break;
+            case '"':  memcpy(out, "&quot;", 6); out += 6; break;
+            case '\'': memcpy(out, "&#39;", 5);  out += 5; break;
+            default:   *out++ = c; break;
+        }
+    }
+    *out = '\0';
+
+    PyObject* result = PyUnicode_FromString(output);
+    free(output);
+    return result;
+}
+
+/**
+ * Module method definitions
+ */
+static PyMethodDef uigen_methods[] = {
+    {
+        "escape_html",
+        escape_html,
+        METH_VARARGS,
+        "Escape HTML special characters"
+    },
+    {NULL, NULL, 0, NULL}
+};
+
+/**
+ * Module definition
+ */
+static struct PyModuleDef uigen_module = {
+    PyModuleDef_HEAD_INIT,
+    "uigen._cext",
+    "uigen C extension for fast HTML escaping",
+    -1,
+    uigen_methods
+};
+
+/**
+ * Module initialization
+ */
+PyMODINIT_FUNC PyInit__cext(void) {
+    return PyModule_Create(&uigen_module);
+}

uigen/accel.py

@@ -0,0 +1,60 @@
+"""Accelerated functions using C extension (optional)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _check_cext() -> bool:
+    """Check if C extension is available."""
+    try:
+        import uigen._cext  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+HAS_CEXT = _check_cext()
+
+
+def escape_html(text: str) -> str:
+    """Escape HTML special characters.
+
+    Uses C extension if available, falls back to pure Python.
+    """
+    if HAS_CEXT:
+        from uigen._cext import escape_html as _escape_html
+        return _escape_html(text)
+
+    # Pure Python fallback
+    replacements = {
+        "&": "&",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;",
+    }
+    for char, escaped in replacements.items():
+        text = text.replace(char, escaped)
+    return text
+
+
+def concat_strings(parts: list[str]) -> str:
+    """Fast string concatenation.
+
+    Uses C extension if available, falls back to pure Python.
+    """
+    if HAS_CEXT:
+        from uigen._cext import concat_strings as _concat
+        return _concat(parts)
+
+    # Pure Python fallback
+    return "".join(parts)
+
+
+def get_info() -> dict[str, Any]:
+    """Get information about the C extension."""
+    return {
+        "has_cext": HAS_CEXT,
+        "backend": "C" if HAS_CEXT else "Python",
+    }

uigen/cli.py

@@ -0,0 +1,139 @@
+"""CLI — command-line interface for uigen."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Main entry point for the uigen CLI."""
+    parser = argparse.ArgumentParser(
+        prog="uigen",
+        description="Write UI logic once, deploy anywhere.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # uigen init
+    init_parser = subparsers.add_parser("init", help="Initialize a new uigen project")
+    init_parser.add_argument("name", help="Project name")
+
+    # uigen generate
+    gen_parser = subparsers.add_parser("generate", help="Generate frontend code")
+    gen_parser.add_argument(
+        "--renderer", "-r",
+        default="lnative",
+        choices=["lnative", "lreact", "lflask", "ldjango"],
+        help="Renderer to use (default: lnative)",
+    )
+    gen_parser.add_argument(
+        "--output", "-o",
+        default="./dist",
+        help="Output directory (default: ./dist)",
+    )
+
+    # uigen renderers
+    subparsers.add_parser("renderers", help="List available renderers")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "init":
+        return _init_project(args.name)
+    elif args.command == "generate":
+        return _generate(args.renderer, args.output)
+    elif args.command == "renderers":
+        _list_renderers()
+        return 0
+    else:
+        parser.print_help()
+        return 1
+
+
+def _init_project(name: str) -> int:
+    """Initialize a new uigen project."""
+    project_dir = Path(name)
+
+    if project_dir.exists():
+        print(f"Error: Directory '{name}' already exists.", file=sys.stderr)
+        return 1
+
+    project_dir.mkdir(parents=True)
+
+    # Create main.py
+    main_file = project_dir / "main.py"
+    main_file.write_text(f'''"""Generated by uigen — {name}"""
+
+from uigen import App, Model, ui
+
+
+class User(Model):
+    name: str
+    email: str
+    role: str = "viewer"
+
+
+# Build your UI here
+page = ui.page(
+    ui.card(
+        ui.heading("Welcome to {name}"),
+        ui.text("Edit main.py to customize this page."),
+        ui.button("Get Started"),
+    ),
+    title="{name}",
+)
+
+app = App(title="{name}", pages=[page])
+
+if __name__ == "__main__":
+    output = app.render("lnative", output="./dist")
+    print(f"Generated UI at {{output}}")
+''')
+
+    print(f"Created project: {name}")
+    print(f"  cd {name}")
+    print("  python main.py")
+    return 0
+
+
+def _generate(renderer: str, output: str) -> int:
+    """Generate frontend from main.py."""
+    main_file = Path("main.py")
+    if not main_file.exists():
+        print("Error: No main.py found. Run 'uigen init' first.", file=sys.stderr)
+        return 1
+
+    # Execute main.py to get the app object
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("main", main_file)
+    if spec is None or spec.loader is None:
+        print("Error: Could not load main.py", file=sys.stderr)
+        return 1
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    if not hasattr(module, "app"):
+        print(
+            "Error: main.py must define an 'app' variable (App instance)",
+            file=sys.stderr,
+        )
+        return 1
+
+    app = module.app
+    output_path = app.render(renderer, output=output)
+    print(f"Generated {renderer} output at {output_path}")
+    return 0
+
+
+def _list_renderers() -> None:
+    """List available renderers."""
+    print("Available renderers:")
+    print("  lnative  - Static HTML/CSS/JS (ready)")
+    print("  lreact   - React components (coming soon)")
+    print("  lflask   - Flask/Jinja2 templates (coming soon)")
+    print("  ldjango  - Django templates (coming soon)")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

uigen/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core components of uigen."""
+
+from uigen.core.api import ui
+from uigen.core.compiler import App
+from uigen.core.schema import Field, Model
+
+__all__ = ["Model", "Field", "ui", "App"]

uigen/core/api.py

@@ -0,0 +1,128 @@
+"""Public API — the ui object that users interact with."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from uigen.core.components import (
+    Button,
+    Card,
+    Component,
+    Form,
+    Grid,
+    Heading,
+    Input,
+    Modal,
+    Page,
+    Select,
+    Stack,
+    Table,
+    Text,
+)
+from uigen.core.schema import Model
+
+
+class UI:
+    """The ui namespace — provides methods to create UI components."""
+
+    def page(
+        self, *children: Component, title: str = "", description: str = ""
+    ) -> Page:
+        """Create a page container."""
+        return Page(
+            children=list(children),
+            title=title,
+            description=description,
+        )
+
+    def card(self, *children: Component, **attrs: Any) -> Card:
+        """Create a card container."""
+        return Card(children=list(children), attrs=attrs)
+
+    def heading(self, text: str, level: int = 1) -> Heading:
+        """Create a heading element."""
+        return Heading(text=text, level=level)
+
+    def text(self, content: str) -> Text:
+        """Create a paragraph/text element."""
+        return Text(text=content)
+
+    def button(self, text: str, variant: str = "primary", onclick: str = "") -> Button:
+        """Create a button element."""
+        return Button(text=text, variant=variant, onclick=onclick)
+
+    def input(
+        self,
+        name: str,
+        label: str = "",
+        type: str = "text",
+        placeholder: str = "",
+        value: str = "",
+        required: bool = False,
+    ) -> Input:
+        """Create a form input."""
+        return Input(
+            name=name,
+            label=label or name.replace("_", " ").title(),
+            input_type=type,
+            placeholder=placeholder,
+            value=value,
+            required=required,
+        )
+
+    def select(
+        self, name: str, options: list[str], label: str = "", value: str = ""
+    ) -> Select:
+        """Create a select dropdown."""
+        return Select(
+            name=name,
+            options=options,
+            label=label or name.replace("_", " ").title(),
+            value=value,
+        )
+
+    def table(
+        self,
+        data: list[dict[str, Any]] | Model | None = None,
+        columns: list[str] | None = None,
+    ) -> Table:
+        """Create a data table.
+
+        Args:
+            data: List of dicts, a Model class (uses its fields), or None.
+            columns: Column names. If None, auto-detected from data.
+        """
+        rows: list[dict[str, Any]] = []
+        cols = columns or []
+
+        if data is None:
+            cols = cols or []
+        elif isinstance(data, type) and issubclass(data, Model):
+            cols = cols or data.field_names()
+        elif isinstance(data, list):
+            rows = data
+            if not cols and rows:
+                cols = list(rows[0].keys())
+
+        return Table(columns=cols, rows=rows)
+
+    def form(
+        self, *children: Component, action: str = "", method: str = "POST"
+    ) -> Form:
+        """Create a form container."""
+        return Form(children=list(children), action=action, method=method)
+
+    def modal(self, *children: Component, title: str = "") -> Modal:
+        """Create a modal dialog."""
+        return Modal(children=list(children), title=title)
+
+    def grid(self, *children: Component, columns: int = 2) -> Grid:
+        """Create a grid layout."""
+        return Grid(children=list(children), columns=columns)
+
+    def stack(self, *children: Component, spacing: str = "md") -> Stack:
+        """Create a vertical stack layout."""
+        return Stack(children=list(children), spacing=spacing)
+
+
+ui = UI()

uigen/core/compiler.py

@@ -0,0 +1,212 @@
+"""Compiler — transforms UI definitions into renderer output."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from uigen.core.components import Page
+from uigen.core.schema import Model
+
+
+class App:
+    """Main application class that wires models and pages to renderers."""
+
+    def __init__(
+        self,
+        title: str = "My App",
+        models: list[type[Model]] | None = None,
+        pages: list[Page] | None = None,
+        theme: str | None = None,
+    ) -> None:
+        self.title = title
+        self.models = models or []
+        self.pages = pages or []
+        self.theme = theme
+        self._renderer: Any = None
+
+    def add_page(self, page: Page) -> App:
+        """Add a page to the app."""
+        self.pages.append(page)
+        return self
+
+    def render(self, renderer_name: str, output: str = "./dist") -> Path:
+        """Render all pages using the specified renderer.
+
+        Args:
+            renderer_name: Name of the renderer (e.g., "lnative", "lreact").
+            output: Output directory path.
+
+        Returns:
+            Path to the output directory.
+        """
+        renderer = self._get_renderer(renderer_name)
+        output_path = Path(output)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        if renderer_name == "lreact":
+            return self._render_react(renderer, output_path)
+        elif renderer_name == "lflask":
+            return self._render_flask(renderer, output_path)
+        elif renderer_name == "ldjango":
+            return self._render_django(renderer, output_path)
+        else:
+            return self._render_native(renderer, output_path)
+
+    def _render_native(self, renderer: Any, output_path: Path) -> Path:
+        """Render pages as static HTML files."""
+        for i, page in enumerate(self.pages):
+            filename = "index.html" if i == 0 else f"page_{i}.html"
+            content = renderer.render_page(page, title=self.title)
+            (output_path / filename).write_text(content)
+        return output_path
+
+    def _render_react(self, renderer: Any, output_path: Path) -> Path:
+        """Render pages as a React project."""
+        components_dir = output_path / "src" / "components"
+        components_dir.mkdir(parents=True, exist_ok=True)
+
+        component_names = []
+        for i, page in enumerate(self.pages):
+            page_title = page.title or f"Page{i}"
+            component_name = renderer._to_pascal_case(page_title)
+            component_names.append(component_name)
+
+            content = renderer.render_page(page, title=self.title)
+            (components_dir / f"{component_name}.tsx").write_text(content)
+
+        # Generate package.json
+        (output_path / "package.json").write_text(
+            renderer.generate_package_json(self.title)
+        )
+
+        # Generate index.html
+        (output_path / "index.html").write_text(
+            renderer.generate_index_html(self.title)
+        )
+
+        # Generate App.tsx
+        (output_path / "src" / "App.tsx").write_text(
+            renderer.generate_app_tsx(component_names)
+        )
+
+        # Generate index.tsx
+        (output_path / "src" / "index.tsx").write_text(
+            """import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+const root = ReactDOM.createRoot(
+  document.getElementById('root') as HTMLElement
+);
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);"""
+        )
+
+        return output_path
+
+    def _render_flask(self, renderer: Any, output_path: Path) -> Path:
+        """Render pages as a Flask project."""
+        templates_dir = output_path / "templates" / "pages"
+        static_dir = output_path / "static"
+        templates_dir.mkdir(parents=True, exist_ok=True)
+        static_dir.mkdir(parents=True, exist_ok=True)
+
+        route_names = []
+        for i, page in enumerate(self.pages):
+            page_title = page.title or f"Page{i}"
+            route_name = renderer._to_snake_case(page_title)
+            route_names.append(route_name)
+
+            content = renderer.render_page(page, title=self.title)
+            (templates_dir / f"{route_name}.html").write_text(content)
+
+        # Generate base.html
+        (output_path / "templates" / "base.html").write_text(
+            renderer.generate_base_html(self.title)
+        )
+
+        # Generate app.py
+        (output_path / "app.py").write_text(
+            renderer.generate_app_py(self.title, route_names)
+        )
+
+        # Generate requirements.txt
+        (output_path / "requirements.txt").write_text(
+            renderer.generate_requirements()
+        )
+
+        return output_path
+
+    def _render_django(self, renderer: Any, output_path: Path) -> Path:
+        """Render pages as a Django project."""
+        project_name = renderer._to_snake_case(self.title)
+        templates_dir = output_path / "templates" / "pages"
+        app_dir = output_path / project_name
+        templates_dir.mkdir(parents=True, exist_ok=True)
+        app_dir.mkdir(parents=True, exist_ok=True)
+
+        route_names = []
+        for i, page in enumerate(self.pages):
+            page_title = page.title or f"Page{i}"
+            route_name = renderer._to_snake_case(page_title)
+            route_names.append(route_name)
+
+            content = renderer.render_page(page, title=self.title)
+            (templates_dir / f"{route_name}.html").write_text(content)
+
+        # Generate base.html
+        (output_path / "templates" / "base.html").write_text(
+            renderer.generate_base_html(self.title)
+        )
+
+        # Generate views.py
+        (app_dir / "views.py").write_text(
+            renderer.generate_views_py(self.title, route_names)
+        )
+
+        # Generate urls.py
+        (app_dir / "urls.py").write_text(
+            renderer.generate_urls_py(route_names)
+        )
+
+        # Generate settings.py
+        (output_path / "settings.py").write_text(
+            renderer.generate_settings_py(self.title)
+        )
+
+        # Generate requirements.txt
+        (output_path / "requirements.txt").write_text(
+            renderer.generate_requirements()
+        )
+
+        return output_path
+
+    def _get_renderer(self, name: str) -> Any:
+        """Import and instantiate a renderer by name."""
+        if name == "lnative":
+            from uigen.renderers.lnative import LNativeRenderer
+            return LNativeRenderer(theme=self.theme)
+        elif name == "lreact":
+            from uigen.renderers.lreact import LReactRenderer
+            return LReactRenderer()
+        elif name == "lflask":
+            from uigen.renderers.lflask import LFlaskRenderer
+            return LFlaskRenderer()
+        elif name == "ldjango":
+            from uigen.renderers.ldjango import LDjangoRenderer
+            return LDjangoRenderer()
+        else:
+            available = "lnative, lreact, lflask, ldjango"
+            raise ValueError(
+                f"Unknown renderer: {name}. Available: {available}"
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"App(title={self.title!r}, "
+            f"pages={len(self.pages)}, models={len(self.models)})"
+        )