pyweb-stack 0.1.0__py3-none-any.whl

pyweb/jobs.py

@@ -0,0 +1,248 @@
+"""Background jobs: @task decorator, in-memory queue, retries, progress."""
+
+from __future__ import annotations
+
+import threading
+import time
+import traceback
+import uuid
+
+
+class Job:
+    def __init__(self, job_id, fn_name):
+        self.id = job_id
+        self.fn_name = fn_name
+        self.pending = True
+        self.failed = False
+        self.error = None
+        self.result = None
+        self.progress = 0.0
+        self.traceback = None
+
+    def set_progress(self, value):
+        self.progress = max(0.0, min(1.0, float(value)))
+
+    def to_dict(self):
+        return {"id": self.id, "fn": self.fn_name, "pending": self.pending,
+                "failed": self.failed, "error": self.error,
+                "result": self.result, "progress": self.progress}
+
+
+class Queue:
+    """In-memory queue (Redis/RabbitMQ/Kafka adapters plug in here)."""
+
+    def __init__(self):
+        self.jobs: dict[str, Job] = {}
+        self._lock = threading.Lock()
+        self._threads: list[threading.Thread] = []
+
+    def submit(self, fn, *args, retries=0, **kwargs):
+        job = Job(uuid.uuid4().hex[:12], getattr(fn, "__name__", "fn"))
+        with self._lock:
+            self.jobs[job.id] = job
+            self._threads = [t for t in self._threads if t.is_alive()]
+        t = threading.Thread(target=self._run, args=(job, fn, args, kwargs, retries), daemon=True)
+        self._threads.append(t)
+        t.start()
+        return job
+
+    @staticmethod
+    def _wants_job(fn):
+        """Does ``fn`` accept the ``_job`` keyword (for progress reporting)?"""
+        import inspect
+        try:
+            params = inspect.signature(fn).parameters
+        except (TypeError, ValueError):
+            return False
+        return "_job" in params or any(p.kind is p.VAR_KEYWORD for p in params.values())
+
+    def _run(self, job, fn, args, kwargs, retries):
+        attempt = 0
+        call_kwargs = dict(kwargs)
+        if self._wants_job(fn):
+            call_kwargs["_job"] = job
+        while True:
+            try:
+                job.result = fn(*args, **call_kwargs)
+                job.pending = False
+                return
+            except Exception as exc:  # noqa: BLE001
+                err = exc
+                tb = traceback.format_exc()
+            if attempt >= retries:
+                job.pending = False
+                job.failed = True
+                job.error = f"{type(err).__name__}: {err}"
+                job.traceback = tb
+                return
+            attempt += 1
+            time.sleep(0.01 * attempt)
+
+    def get(self, job_id):
+        return self.jobs.get(job_id)
+
+    def wait(self, job, timeout=10.0):
+        end = time.time() + timeout
+        while job.pending and time.time() < end:
+            time.sleep(0.005)
+        return job
+
+
+    def save(self, path):
+        """Persist job records to JSON (survives restarts; payload fns excluded)."""
+        import json as _json
+        with self._lock:
+            data = {jid: j.to_dict() for jid, j in self.jobs.items()}
+        with open(path, "w") as fh:
+            _json.dump(data, fh)
+
+    def load(self, path):
+        """Restore job records saved with :meth:`save`."""
+        import json as _json
+        try:
+            with open(path) as fh:
+                data = _json.load(fh)
+        except FileNotFoundError:
+            return 0
+        with self._lock:
+            for jid, rec in data.items():
+                job = Job(jid, rec.get("fn", "?"))
+                job.pending = bool(rec.get("pending", False))
+                job.failed = bool(rec.get("failed", False))
+                job.error = rec.get("error")
+                job.result = rec.get("result")
+                job.progress = float(rec.get("progress", 0.0))
+                self.jobs[jid] = job
+        return len(data)
+
+
+class RedisQueue(Queue):
+    """Cross-process job queue over Redis lists + hashes.
+
+    ``submit`` pushes the job id onto ``<prefix>pending`` and stores the
+    record in ``<prefix>job:<id>``; any process running :meth:`drain`
+    (or a worker loop) can pick it up. Payloads must be JSON-serializable
+    args; the function itself is resolved from a registry so workers do
+    not need the submitting process's memory. Falls back to in-memory
+    execution when Redis is unreachable.
+    """
+
+    def __init__(self, url="redis://localhost:6379/0", client=None,
+                 prefix="pyweb:jobs:"):
+        super().__init__()
+        self._prefix = prefix
+        self._registry: dict[str, object] = {}
+        if client is not None:
+            self._r = client
+        else:
+            try:
+                import redis
+            except ImportError as e:
+                raise RuntimeError(
+                    "RedisQueue requires the 'redis' package: "
+                    "pip install redis") from e
+            self._r = redis.Redis.from_url(url)
+
+    def register(self, fn):
+        self._registry[getattr(fn, "__name__", "fn")] = fn
+        return fn
+
+    def submit(self, fn, *args, retries=0, **kwargs):
+        import json as _json
+        name = getattr(fn, "__name__", "fn")
+        self._registry.setdefault(name, fn)
+        try:
+            payload = _json.dumps({"args": args, "kwargs": kwargs})
+        except (TypeError, ValueError):
+            return super().submit(fn, *args, retries=retries, **kwargs)
+        job = Job(__import__("uuid").uuid4().hex[:12], name)
+        with self._lock:
+            self.jobs[job.id] = job
+        try:
+            self._r.hset(self._prefix + f"job:{job.id}", mapping={
+                "fn": name, "payload": payload, "retries": retries})
+            self._r.rpush(self._prefix + "pending", job.id)
+        except Exception:  # noqa: BLE001 — Redis down: run in-memory
+            return super().submit(fn, *args, retries=retries, **kwargs)
+        return job
+
+    def drain(self, timeout=0):
+        """Run one pending job from the Redis list. Returns job or None."""
+        import json as _json
+        try:
+            if timeout:
+                item = self._r.blpop(self._prefix + "pending", timeout=timeout)
+                job_id = item[1] if item else None
+            else:
+                # BLPOP with timeout=0 blocks forever on real Redis.
+                job_id = self._r.lpop(self._prefix + "pending")
+        except Exception:
+            return None
+        if not job_id:
+            return None
+        job_id = job_id.decode() if isinstance(job_id, bytes) else job_id
+        try:
+            rec = self._r.hgetall(self._prefix + f"job:{job_id}")
+            get = lambda k: (rec.get(k.encode(), b"") or b"").decode() \
+                if isinstance(rec.get(k.encode(), b""), bytes) \
+                else rec.get(k, "")
+            fn = self._registry.get(get("fn"))
+            payload = _json.loads(get("payload") or "{}")
+            retries = int(get("retries") or 0)
+        except Exception:  # noqa: BLE001
+            return self.jobs.get(job_id)
+        job = self.jobs.get(job_id)
+        if job is None:
+            job = Job(job_id, get("fn"))
+            with self._lock:
+                self.jobs[job_id] = job
+        if fn is None:
+            job.pending = False
+            job.failed = True
+            job.error = "unknown function for worker"
+            return job
+        self._run(job, fn, payload.get("args", ()),
+                  payload.get("kwargs", {}), retries)
+        try:
+            try:
+                result = _json.dumps(job.result)
+            except (TypeError, ValueError):
+                result = _json.dumps(repr(job.result))
+            self._r.hset(self._prefix + f"job:{job_id}", mapping={
+                "done": "1", "failed": "1" if job.failed else "",
+                "result": result, "error": str(job.error or "")})
+        except Exception:
+            pass
+        return job
+
+    def status(self, job_id):
+        """Job state as stored in Redis (readable from any process)."""
+        import json as _json
+        rec = self._r.hgetall(self._prefix + f"job:{job_id}")
+        if not rec:
+            return None
+        rec = {(k.decode() if isinstance(k, bytes) else k): (v.decode() if isinstance(v, bytes) else v)
+               for k, v in rec.items()}
+        return {"fn": rec.get("fn"), "done": rec.get("done") == "1",
+                "failed": rec.get("failed") == "1",
+                "result": _json.loads(rec["result"]) if rec.get("result") else None,
+                "error": rec.get("error") or None}
+
+
+_default_queue = Queue()
+
+
+def task(_fn=None, *, retries=0, queue=None):
+    q = queue or _default_queue
+
+    def deco(fn):
+        if isinstance(q, RedisQueue):
+            q.register(fn)
+
+        def wrapper(*args, **kwargs):
+            return q.submit(fn, *args, retries=retries, **kwargs)
+        wrapper.__pyweb_location__ = "worker"
+        wrapper.sync = fn
+        wrapper.queue = q
+        return wrapper
+    return deco(_fn) if _fn else deco

pyweb/live.py

@@ -0,0 +1,88 @@
+"""Live queries: dependency-tracked subscriptions with minimal patches.
+
+A ``LiveTable`` wraps rows and a ``Bus`` channel. ``live_query`` records
+which rows a selector reads; ``commit`` diffs versions and only notifies
+subscribers whose dependency set intersects the changed rows.
+"""
+
+from __future__ import annotations
+
+import threading
+
+from .realtime import Bus
+
+
+class LiveTable:
+    def __init__(self, name, bus=None):
+        self.name = name
+        self.bus = bus or Bus()
+        self._rows: dict[str, dict] = {}
+        self._versions: dict[str, int] = {}
+        self._lock = threading.Lock()
+
+    def set(self, row_id, data):
+        with self._lock:
+            self._rows[row_id] = dict(data)
+            self._versions[row_id] = self._versions.get(row_id, 0) + 1
+            version = self._versions[row_id]
+        self.bus.publish(f"live:{self.name}", {"row": row_id, "version": version})
+        return version
+
+    def delete(self, row_id):
+        with self._lock:
+            self._rows.pop(row_id, None)
+            self._versions[row_id] = self._versions.get(row_id, 0) + 1
+        self.bus.publish(f"live:{self.name}", {"row": row_id, "deleted": True})
+
+    def read(self, row_id, tracker=None):
+        with self._lock:
+            row = dict(self._rows.get(row_id, {}))
+        if tracker is not None:
+            tracker.add(row_id)
+        return row
+
+    def all(self, tracker=None):
+        with self._lock:
+            rows = {k: dict(v) for k, v in self._rows.items()}
+        if tracker is not None:
+            tracker.update(rows.keys())
+        return rows
+
+
+class LiveQuery:
+    """A selector + subscriber set; only fires when deps change."""
+
+    def __init__(self, table, selector):
+        self.table = table
+        self.selector = selector
+        self.deps: set[str] = set()
+        self.value = None
+        self.fires = 0
+        self._subs: list = []
+        self.refresh()
+        table.bus.channel(f"live:{table.name}").subscribe(self._on_change)
+
+    def refresh(self):
+        tracker: set[str] = set()
+        import inspect
+        try:
+            if len(inspect.signature(self.selector).parameters) >= 2:
+                self.value = self.selector(self.table, tracker)
+            else:
+                self.value = self.selector(tracker)
+        except TypeError:
+            self.value = self.selector()
+        self.deps = set(tracker)
+        return self.value
+
+    def _on_change(self, msg):
+        if not self.deps or msg.get("row") in self.deps:
+            self.refresh()
+            self.fires += 1
+            for sub in list(self._subs):
+                sub(self.value)
+
+    def subscribe(self, fn):
+        self._subs.append(fn)
+        fn(self.value)
+        return lambda: self._subs.remove(fn)

pyweb/lsp.py

@@ -0,0 +1,214 @@
+"""Language-server helpers: symbols, completions, hover, boundary lens.
+
+These are pure functions over source text + compiler output so any
+LSP transport (e.g. pygls) can wrap them without importing server code.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass
+
+from .compiler import parser as P
+
+BROWSER_APIS = ["storage", "clipboard", "location", "camera", "notifications",
+                "fetch", "websocket", "indexeddb", "geolocation", "canvas"]
+DECORATORS = ["@app.page", "@server", "@edge", "@worker",
+              "@component", "@task", "@cache", "@realtime",
+              "@auth.required", "@permission"]
+HTML_TAGS = ["main", "div", "span", "p", "h1", "h2", "article", "section",
+             "button", "input", "form", "label", "ul", "li", "a", "img"]
+
+
+def symbols(source):
+    """Outline: pages, components, server fns, models, signals (best-effort)."""
+    out = []
+    try:
+        tree = ast.parse(P.split_sources(source)[0])
+    except SyntaxError:
+        return out
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            bases = [getattr(b, "id", "") for b in node.bases]
+            kind = "model" if "Model" in bases else "class"
+            out.append({"kind": kind, "name": node.name, "line": node.lineno})
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            decos = [ast.unparse(d) if hasattr(ast, "unparse") else "" for d in node.decorator_list]
+            joined = " ".join(decos)
+            if "page" in joined:
+                kind = "page"
+            elif any(k in joined for k in ("server", "worker", "edge", "browser", "task", "realtime")):
+                kind = "rpc"
+            elif "component" in joined:
+                kind = "component"
+            else:
+                kind = "function"
+            out.append({"kind": kind, "name": node.name, "line": node.lineno,
+                        "decorators": decos})
+    return out
+
+
+def complete(source, line, col):
+    """Prefix completions for the token ending at (line, col), 1-based line."""
+    lines = source.splitlines()
+    if not (1 <= line <= len(lines)):
+        return []
+    frag = lines[line - 1][:col]
+    m = re.search(r"(@[\w.]*|[A-Za-z_][\w]*)$", frag)
+    token = m.group(1) if m else ""
+    pool = DECORATORS if token.startswith("@") else (
+        BROWSER_APIS if "browser." in frag or "pyweb.browser" in frag else
+        HTML_TAGS if "<" in frag else
+        ["Signal", "Computed", "Resource", "Effect", "live", "App", "Model"])
+    if token.startswith("@"):
+        base = token[1:]
+        out = []
+        for c in pool:
+            name = c[1:] if c.startswith("@") else c
+            if name.startswith(base):
+                out.append({"label": c, "insert": name[len(base):]})
+        return out
+    return [{"label": c, "insert": c[len(token):]} for c in pool
+            if c.startswith(token)]
+
+
+def hover(compiled, symbol):
+    """Placement + reason lens for a signal/handler/rpc name."""
+    for name, page in compiled.get("pages", {}).items():
+        if symbol in page.get("placement", {}):
+            loc, reason = page["placement"][symbol]
+            return {"page": name, "symbol": symbol, "location": loc, "reason": reason}
+    for spec in compiled.get("rpc", []):
+        if spec["name"] == symbol:
+            return {"symbol": symbol, "location": spec["location"],
+                    "reason": f"typed RPC ({spec.get('line', '?')})"}
+    return None
+
+
+def boundary_lens(compiled):
+    """Every symbol with its execution location for editor gutters."""
+    lens = []
+    for name, page in compiled.get("pages", {}).items():
+        for sym, (loc, reason) in page.get("placement", {}).items():
+            lens.append({"page": name, "symbol": sym, "location": loc, "reason": reason})
+    return sorted(lens, key=lambda e: (e["page"], e["symbol"]))
+
+
+@dataclass
+class CompletionItem:
+    label: str
+    kind: str = "Keyword"
+    detail: str = ""
+    insert_text: str = ""
+
+    def to_dict(self):
+        return {"label": self.label, "kind": self.kind,
+                "detail": self.detail,
+                "insertText": self.insert_text or self.label}
+
+
+@dataclass
+class DocumentState:
+    components: dict = None
+    routes: list = None
+    models: dict = None
+    keywords: tuple = ("signal", "route", "rpc", "component")
+
+    def __post_init__(self):
+        if self.components is None:
+            self.components = {}
+        if self.routes is None:
+            self.routes = []
+        if self.models is None:
+            self.models = {}
+
+
+def _prefix(items, prefix):
+    return sorted(i for i in items if i.startswith(prefix))
+
+
+def complete_components(state, prefix=""):
+    return [CompletionItem(name, "Component",
+                           detail=f"props: {', '.join(state.components[name]) or '—'}")
+            for name in _prefix(state.components, prefix)]
+
+
+def complete_props(state, component, prefix=""):
+    return [CompletionItem(p, "Property", detail=f"{component}.{p}")
+            for p in _prefix(state.components.get(component, []), prefix)]
+
+
+def complete_routes(state, prefix=""):
+    return [CompletionItem(r, "File", detail="route")
+            for r in _prefix(state.routes, prefix)]
+
+
+def complete_model_fields(state, model, prefix=""):
+    return [CompletionItem(f, "Field", detail=f"{model}.{f}")
+            for f in _prefix(state.models.get(model, []), prefix)]
+
+
+def complete_state(state, prefix=""):
+    items = complete_components(state, prefix)
+    items += complete_routes(state, prefix)
+    for model in _prefix(state.models, prefix):
+        items.append(CompletionItem(model, "Field",
+                                    detail=f"model: {', '.join(state.models[model])}"))
+    items += [CompletionItem(k, "Keyword") for k in _prefix(state.keywords, prefix)]
+    return items
+
+
+def state_from_graph(graph):
+    to_dict = getattr(graph, "to_dict", None)
+    data = to_dict() if callable(to_dict) else (graph if isinstance(graph, dict) else {})
+    components = {c["name"]: list(c.get("props", [])) for c in data.get("components", [])}
+    routes = [r["path"] for r in data.get("routes", [])]
+    models = {}
+    for m in data.get("models", []):
+        if isinstance(m, dict):
+            models[m.get("name", "?")] = list(m.get("fields", []))
+    return DocumentState(components=components, routes=routes, models=models)
+
+
+def _int_or(value, default):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def diagnostics_for_compile_error(error):
+    errors = list(error) if isinstance(error, (list, tuple)) else [error]
+    diags = []
+    for err in errors:
+        message = (getattr(err, "message", None) or getattr(err, "msg", None)
+                   or (err.get("message") if isinstance(err, dict) else None)
+                   or str(err))
+        span = getattr(err, "span", None) if not isinstance(err, dict) else None
+        if isinstance(err, dict):
+            inner = err.get("span")
+            span = {**err, **inner} if isinstance(inner, dict) else err
+        if span is not None and not isinstance(span, dict):
+            line = _int_or(getattr(span, "line", None), 1)
+            col = _int_or(getattr(span, "col", getattr(span, "column", None)), 0)
+            end_line = _int_or(getattr(span, "end_line", None), line)
+            end_col = _int_or(getattr(span, "end_col", getattr(span, "end_column", None)), col + 1)
+        else:
+            span = span or {}
+            line = _int_or(span.get("line"), 1)
+            col = _int_or(span.get("col", span.get("column")), 0)
+            end_line = _int_or(span.get("end_line"), line)
+            end_col = _int_or(span.get("end_col", span.get("end_column")), col + 1)
+        source = getattr(err, "file", getattr(err, "path", None))
+        if source is None and isinstance(span, dict):
+            source = span.get("file", span.get("path"))
+        diags.append({
+            "message": str(message),
+            "severity": 1,
+            "source": "pyweb",
+            "range": {"start": {"line": max(line - 1, 0), "character": max(col, 0)},
+                      "end": {"line": max(end_line - 1, 0), "character": max(end_col, 0)}},
+            **({"uri": str(source)} if source else {}),
+        })
+    return diags