evenis 0.1.0__py3-none-any.whl

evenis/__init__.py

@@ -0,0 +1,102 @@
+"""evenis — production-grade Python UI framework.
+
+Двухслойная система:
+  • compile-time (Python): UI-дерево (AST) → layout → theme→CSS → HTML → JS inject;
+  • runtime (browser JS): SPA-роутинг, реактивный store, DOM-обновления, анимации.
+
+Пользователь описывает UI ТОЛЬКО на Python — без HTML/CSS/JS.
+
+Пример:
+    import evenis as ui
+
+    app = ui.App(title="Demo", state={"count": 0})
+
+    @app.page("/", title="Home")
+    def home():
+        return ui.Column(
+            ui.Heading("Счётчик"),
+            ui.Text("Значение: {{ count }}"),
+            ui.Button("+1", on_click=ui.increment("count"), variant="primary"),
+        )
+
+    app.build("dist")
+"""
+
+from .core import App, Component, Element, For, Fragment, If, Node, Page, to_vnode
+from .layout import (
+    AdaptiveLayout,
+    Column,
+    Container,
+    Grid,
+    Motion,
+    Responsive,
+    Row,
+    Scrollable,
+    Spacer,
+    Stack,
+)
+from .components import (
+    Button,
+    Card,
+    DangerButton,
+    Divider,
+    GhostButton,
+    Heading,
+    Image,
+    Input,
+    Link,
+    PrimaryButton,
+    Text,
+)
+from .style import Theme, default_theme, light_theme
+from .state import (
+    append,
+    batch,
+    decrement,
+    fetch_json,
+    increment,
+    js,
+    log,
+    navigate,
+    prefetch,
+    redirect_if,
+    remove_at,
+    set_from_event,
+    set_value,
+    toggle,
+)
+from .router import Router
+from .compiler import build_app, build_manifest
+from .server import (
+    LiveState,
+    action,
+    enable_auth,
+    protected,
+    serve,
+    server,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # core
+    "App", "Page", "Component", "Element", "Node", "Fragment", "If", "For", "to_vnode",
+    # layout
+    "Row", "Column", "Grid", "Stack", "Container", "Spacer", "Responsive",
+    "AdaptiveLayout", "Scrollable", "Motion",
+    # components
+    "Text", "Heading", "Button", "PrimaryButton", "DangerButton", "GhostButton",
+    "Card", "Input", "Link", "Image", "Divider",
+    # style
+    "Theme", "default_theme", "light_theme",
+    # state / actions
+    "set_value", "increment", "decrement", "toggle", "set_from_event",
+    "append", "remove_at", "navigate", "js", "fetch_json", "batch",
+    # middleware
+    "redirect_if", "log", "prefetch",
+    # router / compiler
+    "Router", "build_app", "build_manifest",
+    # server (fullstack)
+    "server", "action", "LiveState", "protected", "enable_auth", "serve",
+    "__version__",
+]

evenis/__main__.py

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

evenis/cli.py

@@ -0,0 +1,129 @@
+"""evenis.cli — одна команда для сборки и dev-режима.
+
+    evenis build app.py [--out dist]   — собрать сайт в каталог.
+    evenis dev   app.py [--out dist] [--port 8000]
+        — собрать с dev=True (hot reload), поднять статический сервер и
+          пересобирать при изменении исходников (polling watcher).
+
+`app.py` должен экспортировать переменную `app` (экземпляр evenis.App) либо
+функцию `app()`/`create_app()`, возвращающую App.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import os
+import sys
+import time
+
+
+def _load_app(path: str):
+    spec = importlib.util.spec_from_file_location("_evenis_user_app", path)
+    if spec is None or spec.loader is None:
+        raise SystemExit(f"Не удалось загрузить модуль: {path}")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    candidate = getattr(mod, "app", None) or getattr(mod, "create_app", None)
+    if candidate is None:
+        raise SystemExit("В модуле нет `app` (экземпляр App) или фабрики create_app().")
+    app = candidate() if callable(candidate) else candidate
+    return app
+
+
+def _snapshot(root: str) -> float:
+    """Максимальное mtime по дереву *.py — простой watcher без зависимостей."""
+    latest = 0.0
+    for dirpath, _dirs, files in os.walk(root):
+        if "__pycache__" in dirpath or "/dist" in dirpath:
+            continue
+        for f in files:
+            if f.endswith(".py"):
+                try:
+                    latest = max(latest, os.path.getmtime(os.path.join(dirpath, f)))
+                except OSError:
+                    pass
+    return latest
+
+
+def cmd_build(args) -> None:
+    app = _load_app(args.entry)
+    out = app.build(args.out)
+    print(f"evenis: собрано → {out}")
+
+
+def cmd_dev(args) -> None:
+    import functools
+    import http.server
+    import socketserver
+    import threading
+
+    entry = os.path.abspath(args.entry)
+    watch_root = os.path.dirname(entry)
+
+    def rebuild():
+        app = _load_app(entry)
+        app.dev = True
+        app.build(args.out)
+
+    rebuild()
+    out_abs = os.path.abspath(args.out)
+    print(f"evenis: dev-сборка → {out_abs}")
+
+    handler = functools.partial(http.server.SimpleHTTPRequestHandler, directory=out_abs)
+    httpd = socketserver.TCPServer(("", args.port), handler)
+    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    print(f"evenis: http://localhost:{args.port}  (Ctrl+C для выхода)")
+
+    last = _snapshot(watch_root)
+    try:
+        while True:
+            time.sleep(0.6)
+            cur = _snapshot(watch_root)
+            if cur > last:
+                last = cur
+                try:
+                    rebuild()
+                    print("evenis: пересобрано, обновляю браузер…")
+                except Exception as e:  # noqa: BLE001 - dev-цикл не должен падать
+                    print(f"evenis: ошибка сборки: {e}", file=sys.stderr)
+    except KeyboardInterrupt:
+        print("\nevenis: остановлено.")
+        httpd.shutdown()
+
+
+def cmd_serve(args) -> None:
+    from .server import serve
+
+    app = _load_app(args.entry)
+    serve(app, outdir=args.out, port=args.port, host=args.host)
+
+
+def main(argv=None) -> None:
+    parser = argparse.ArgumentParser(prog="evenis", description="evenis — Python UI framework")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("build", help="собрать сайт в каталог")
+    b.add_argument("entry", help="путь к app.py (экспортирует app)")
+    b.add_argument("--out", default="dist", help="каталог вывода (по умолчанию dist)")
+    b.set_defaults(func=cmd_build)
+
+    d = sub.add_parser("dev", help="dev-сервер с hot reload")
+    d.add_argument("entry", help="путь к app.py (экспортирует app)")
+    d.add_argument("--out", default="dist", help="каталог вывода")
+    d.add_argument("--port", type=int, default=8000, help="порт (по умолчанию 8000)")
+    d.set_defaults(func=cmd_dev)
+
+    s = sub.add_parser("serve", help="fullstack-сервер (фронт + FastAPI API + WebSocket)")
+    s.add_argument("entry", help="путь к app.py (экспортирует app)")
+    s.add_argument("--out", default="dist", help="каталог вывода")
+    s.add_argument("--port", type=int, default=8000, help="желаемый порт (свободный подберётся рядом)")
+    s.add_argument("--host", default="127.0.0.1", help="хост (по умолчанию 127.0.0.1)")
+    s.set_defaults(func=cmd_serve)
+
+    args = parser.parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

evenis/compiler/__init__.py

@@ -0,0 +1,134 @@
+"""evenis.compiler — конвейер компиляции (compile-time слой).
+
+Этапы:
+  1. AST: собрать VNode-дерево каждой страницы (App.pages → manifest маршрутов).
+  2. layout resolve: уже выполнен при построении VNode (Row/Column/... → классы).
+  3. CSS generator: theme → style.css.
+  4. HTML generator: SSR начального маршрута → index.html (первый кадр).
+  5. JS runtime injector: runtime + манифест приложения → app.js.
+
+Результат пишется в каталог `outdir` (по умолчанию dist/):
+    dist/index.html, dist/style.css, dist/app.js
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import TYPE_CHECKING
+
+from ..router import build_routes
+from ..style.css import generate_css
+from .html import render_page_html
+from .runtime import RUNTIME_JS
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..core import App
+
+
+def build_manifest(app: "App") -> dict:
+    """Собрать JSON-манифест приложения для рантайма."""
+    routes = build_routes(app.pages)
+    if not routes:
+        raise ValueError("В приложении нет страниц: добавьте хотя бы одну Page")
+    fallback = app.pages[0].path
+    computed = [{"name": k, "expr": v} for k, v in app.computed.items()]
+    manifest = {
+        "title": app.title,
+        "mount": "app",
+        "state": app.state,
+        "routes": routes,
+        "fallback": fallback,
+        "breakpoint": app.theme.breakpoint,
+        "computed": computed,
+        "middleware": app.middleware,
+        "features": app.features,
+        "dev": app.dev,
+    }
+    # Серверный слой (если использовались @server/@action/LiveState).
+    try:
+        from ..server import REGISTRY, server_manifest
+
+        if REGISTRY.endpoints or REGISTRY.livestates:
+            sm = server_manifest()
+            manifest["server"] = sm
+            # начальные значения LiveState кладём прямо в state, чтобы первый кадр
+            # уже показывал актуальные данные ещё до WebSocket-подключения.
+            for k, v in sm.get("live", {}).items():
+                manifest["state"].setdefault(k, v)
+    except Exception:
+        pass
+    # Загрузка данных при входе на страницу (Page.load → server endpoint).
+    for path, route in routes.items():
+        page = next((p for p in app.pages if p.path == path), None)
+        if page is not None and getattr(page, "load", None):
+            route["load"] = page.load
+    return manifest
+
+
+_HOT_RELOAD = """
+  <script>
+  (function(){
+    var cur=null;
+    setInterval(function(){
+      fetch('__evenis_buildid?ts='+Date.now()).then(function(r){return r.text();}).then(function(id){
+        if(cur===null){cur=id;return;} if(id!==cur){location.reload();}
+      }).catch(function(){});
+    }, 800);
+  })();
+  </script>"""
+
+
+def _index_html(app: "App", manifest: dict) -> str:
+    initial_path = manifest["fallback"]
+    initial_page = manifest["routes"][initial_path]
+    ssr = render_page_html(initial_page, app.state)
+    title = manifest["routes"][initial_path].get("title", app.title)
+    hot = _HOT_RELOAD if app.dev else ""
+    return f"""<!doctype html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>{title} · {app.title}</title>
+  <link rel="stylesheet" href="style.css" />
+</head>
+<body>
+  <div id="app">{ssr}</div>
+  <script src="app.js"></script>{hot}
+</body>
+</html>
+"""
+
+
+def _app_js(manifest: dict) -> str:
+    data = json.dumps(manifest, ensure_ascii=False)
+    return RUNTIME_JS + "\n;window.EVENIS.start(" + data + ");\n"
+
+
+def build_app(app: "App", outdir: str = "dist") -> str:
+    """Скомпилировать App в готовый сайт. Возвращает абсолютный путь к outdir."""
+    os.makedirs(outdir, exist_ok=True)
+
+    manifest = build_manifest(app)
+
+    css = generate_css(app.theme, features=app.features)
+    html_doc = _index_html(app, manifest)
+    js = _app_js(manifest)
+
+    with open(os.path.join(outdir, "style.css"), "w", encoding="utf-8") as f:
+        f.write(css)
+    with open(os.path.join(outdir, "index.html"), "w", encoding="utf-8") as f:
+        f.write(html_doc)
+    with open(os.path.join(outdir, "app.js"), "w", encoding="utf-8") as f:
+        f.write(js)
+    if app.dev:
+        import time
+
+        with open(os.path.join(outdir, "__evenis_buildid"), "w", encoding="utf-8") as f:
+            f.write(str(time.time()))
+
+    return os.path.abspath(outdir)
+
+
+__all__ = ["build_app", "build_manifest"]

evenis/compiler/html.py

@@ -0,0 +1,120 @@
+"""evenis.compiler.html — генератор HTML из VNode (server-side, первый кадр).
+
+Рендерит VNode-дерево в строку HTML, вычисляя биндинги/if/for на начальном
+state. Это нужно для мгновенного первого кадра и graceful-деградации без JS;
+дальше управление перехватывает рантайм. Логика интерпретации намеренно
+совпадает с рантаймом (см. runtime.py).
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from typing import Any, Dict
+
+_VOID = {"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"}
+_BINDING = re.compile(r"\{\{\s*(.*?)\s*\}\}")
+
+
+def _eval(expr: str, scope: Dict[str, Any]) -> Any:
+    """Безопасно вычислить выражение над scope (подмножество, без builtins)."""
+    try:
+        return eval(expr, {"__builtins__": {}}, dict(scope))  # noqa: S307 - sandboxed scope
+    except Exception:
+        return None
+
+
+def _interpolate(text: str, scope: Dict[str, Any]) -> str:
+    def repl(m):
+        val = _eval(m.group(1), scope)
+        return "" if val is None else str(val)
+
+    return _BINDING.sub(repl, text)
+
+
+def _render_attrs(props: Dict[str, Any], scope: Dict[str, Any]) -> str:
+    out = []
+    for k, v in props.items():
+        if v is True:
+            out.append(f" {k}")
+        elif v is False or v is None:
+            continue
+        else:
+            val = _interpolate(str(v), scope)
+            out.append(f' {k}="{html.escape(val, quote=True)}"')
+    return "".join(out)
+
+
+def render_vnode(vnode: Any, scope: Dict[str, Any]) -> str:
+    if vnode is None:
+        return ""
+    t = vnode.get("type")
+
+    if t == "text":
+        return html.escape(_interpolate(vnode.get("value", ""), scope))
+
+    if t == "fragment":
+        return "".join(render_vnode(c, scope) for c in vnode.get("children", []))
+
+    if t == "if":
+        if _eval(vnode["cond"], scope):
+            return render_vnode(vnode["then"], scope)
+        return render_vnode(vnode["else"], scope) if vnode.get("else") else ""
+
+    if t == "for":
+        items = _eval(vnode["items"], scope)
+        if not isinstance(items, (list, tuple)):
+            return ""
+        var, idx = vnode.get("var", "item"), vnode.get("index", "index")
+        chunks = []
+        for i, it in enumerate(items):
+            inner = dict(scope)
+            inner[var] = it
+            inner[idx] = i
+            chunks.append(render_vnode(vnode["body"], inner))
+        return "".join(chunks)
+
+    if t == "responsive":
+        # SSR рендерит desktop-ветку (рантайм переопределит по ширине окна)
+        return render_vnode(vnode["desktop"], scope)
+
+    if t == "adaptive":
+        # SSR — статичная сетка; рантайм пересчитает число колонок по ширине окна
+        gap = vnode.get("gap", 16)
+        max_cols = vnode.get("maxCols", 6)
+        inner = "".join(render_vnode(c, scope) for c in vnode.get("children", []))
+        n = len(vnode.get("children", []))
+        cols = max(1, min(max_cols, n or 1))
+        style = (
+            f"display:grid; gap:{gap}px; "
+            f"grid-template-columns:repeat({cols},minmax(0,1fr)); padding:16px"
+        )
+        return f'<div class="evenis-adaptive" style="{html.escape(style, quote=True)}">{inner}</div>'
+
+    if t == "page":
+        cls = f"evenis-page evenis-anim-{vnode.get('transition', 'fade-in')}"
+        return f'<div class="{cls}" data-page="{html.escape(vnode.get("path",""))}">' + render_vnode(vnode["child"], scope) + "</div>"
+
+    if t == "element":
+        tag = vnode["tag"]
+        props = dict(vnode.get("props", {}))
+        # bindClass: добавить классы по условиям
+        bind_class = vnode.get("bindClass")
+        if bind_class:
+            extra = [cn for cn, expr in bind_class.items() if _eval(expr, scope)]
+            if extra:
+                props["class"] = (props.get("class", "") + " " + " ".join(extra)).strip()
+        attrs = _render_attrs(props, scope)
+        if tag in _VOID:
+            return f"<{tag}{attrs}>"
+        inner = "".join(render_vnode(c, scope) for c in vnode.get("children", []))
+        return f"<{tag}{attrs}>{inner}</{tag}>"
+
+    return ""
+
+
+def render_page_html(page_vnode: dict, state: Dict[str, Any]) -> str:
+    return render_vnode(page_vnode, state)
+
+
+__all__ = ["render_vnode", "render_page_html"]