pyweb-stack 0.6.0__tar.gz → 0.6.1__tar.gz

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/CHANGELOG.md

@@ -6,6 +6,59 @@ project uses [semantic versioning](https://semver.org).
 
 ## [Unreleased]
 
+## [0.6.1]
+
+Better error messages, `pyweb doctor`, a `pyweb dev` that keeps your place
+when it reloads, much faster reloads and tests, and fixes found by
+installing 0.6.0 from PyPI and putting every template through every
+command. Nothing to change in your apps.
+
+### Added
+- **Better error messages.** Compile errors show the line with a caret under
+  the problem, suggest the name you meant (a prop, component, variable,
+  server function argument, kit variant or motion preset: "did you mean
+  'name'?"), and link the docs page that explains them. The CLI, the
+  `pyweb dev` overlay and the MCP tools (`frame`, `docs` fields) show the
+  same. When page code raises in `pyweb dev`, the error page starts with the
+  frames in your own files and their source lines.
+- **`pyweb dev` keeps your place when it reloads.** After a save, the page
+  comes back with its variables (a counter's count, a bound input's text),
+  unbound form fields, scroll position and focus as they were. A variable
+  whose type changed, or that was renamed, starts over; add `?fresh` to the
+  URL to start everything over. Production builds only grow by the names
+  of page variables.
+- **`pyweb doctor`** checks the project and the machine in one go: Python,
+  whether the app compiles, optional packages the app needs, the database
+  and pending migrations, Redis, secrets written in the source, changes
+  `pyweb upgrade` wants, a stale dev server link, tests, the port and the
+  editor extension, each with a fix (`--production` adds the production
+  settings, `--json` for CI). Assistants get it as the `pyweb_doctor` tool.
+- **Faster reloads and tests.** The UI kit is compiled once per process and
+  each file's Python code is reused until it changes: on the saas example a
+  `pyweb dev` reload after a save went from about 255 to 60 ms, a
+  `TestClient` from about 255 to 55 ms, and compiling from about 240 to
+  60 ms. The dev server notices a save within 0.1 s (was 0.4 s) and the
+  page asks for the new version every 0.25 s (was 0.6 s).
+  `python -m pyweb.bench --system` reports `reload_ms` and `test_client_ms`,
+  and CI's benchmark gate watches them.
+- `pyweb check` warns about kit props and motion values that won't work
+  (`<Button variant="outlin">`), as the editor already did.
+
+### Fixed
+- `pyweb check` printed the file and line twice for compile errors.
+- Components drawn as a kit button (`DialogClose`) were flagged by the
+  editor for `variant="default"`, which they support.
+- `pyweb test` with no path ran `pytest tests/`, which new apps don't have
+  (their test is `test_app.py` next to `app.pyweb`), so it failed in every
+  new project. It now runs the current folder, and accepts the app's
+  `.pyweb` file as well as a test file or folder.
+- The `pyweb_test` MCP tool given the app's `.pyweb` file (as every other
+  tool takes) found no tests; it now tests that file's folder.
+- `pyweb upgrade` says to apply pending migrations before creating the
+  `auth_sessions` one (on a fresh checkout `pyweb db diff` refused to run),
+  and notes that 0.6's `pyweb check` reports accessibility problems, which
+  `--strict` treats as failures.
+
 ## [0.6.0]
 
 Teams, installable and desktop apps, a UI kit and motion, and security by

{pyweb_stack-0.6.0/pyweb_stack.egg-info → pyweb_stack-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyweb-stack
-Version: 0.6.0
+Version: 0.6.1
 Summary: Full-stack web apps in one Python file: server-rendered pages, reactive browser UI, typed RPC.
 Author-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>
 Maintainer-email: MaanavKrishna <67054795+MaanavKrishna@users.noreply.github.com>
@@ -478,7 +478,7 @@ The [architecture overview](ARCHITECTURE.md) goes through each stage.
 
 ## Build it with AI
 
-PyWeb ships an MCP server with 29 tools, so AI assistants can do what
+PyWeb ships an MCP server with 30 tools, so AI assistants can do what
 you'd do: scaffold an app, search the docs, check each edit (errors come
 back as line numbers with fix hints), build with the UI kit and a theme,
 render pages and call server functions as any signed-in member, look at
@@ -566,7 +566,7 @@ Upgrade with `pip install -U pyweb-stack`.
 
 | Version | Highlights |
 |---|---|
-| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server |
+| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server; 0.6.1: error messages with code frames and suggestions, `pyweb doctor`, dev reloads that keep page state, 4× faster reloads and tests |
 | 0.5 | Models with migrations, forms, auth kit with passkeys, OAuth and an admin, row-level live updates over WebSockets on PyWeb's own server, durable jobs and schedules, `pyweb deploy` for docker, compose, k8s, fly, render and railway, logs, metrics, tracing and a dev toolbar, data-aware editor and MCP tools, the `saas` template, `pyweb upgrade` |
 | 0.4 | npm packages without Node, layouts and client-side navigation, streaming server functions and `<Markdown>` for AI apps, live queries, page head tags, `.pyweb` error pages; 0.4.1: richer MCP tools; 0.4.2: VS Code run, new-app and MCP commands; 0.4.3: fixes, security hardening, gzip and caching; 0.4.4: key rotation, session revocation, typed arguments, Redis-shared limits, `check --production` |
 | 0.3 | Hydration, live updates (SSE), multi-file apps, language server + VS Code extension, browser playground, faster rendering, screenshot/test MCP tools |

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/README.md

@@ -404,7 +404,7 @@ The [architecture overview](ARCHITECTURE.md) goes through each stage.
 
 ## Build it with AI
 
-PyWeb ships an MCP server with 29 tools, so AI assistants can do what
+PyWeb ships an MCP server with 30 tools, so AI assistants can do what
 you'd do: scaffold an app, search the docs, check each edit (errors come
 back as line numbers with fix hints), build with the UI kit and a theme,
 render pages and call server functions as any signed-in member, look at
@@ -492,7 +492,7 @@ Upgrade with `pip install -U pyweb-stack`.
 
 | Version | Highlights |
 |---|---|
-| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server |
+| 0.6 | Teams with roles, invitations and tenant-scoped Models (Postgres row-level security), API tokens and OpenAPI, webhooks, installable apps with Web Push, desktop windows and installers, a UI kit with themes and motion, Trusted Types, encrypted fields and a threat model, about 2.5× faster serving, Python 3.15 and free-threaded builds, a much richer MCP server; 0.6.1: error messages with code frames and suggestions, `pyweb doctor`, dev reloads that keep page state, 4× faster reloads and tests |
 | 0.5 | Models with migrations, forms, auth kit with passkeys, OAuth and an admin, row-level live updates over WebSockets on PyWeb's own server, durable jobs and schedules, `pyweb deploy` for docker, compose, k8s, fly, render and railway, logs, metrics, tracing and a dev toolbar, data-aware editor and MCP tools, the `saas` template, `pyweb upgrade` |
 | 0.4 | npm packages without Node, layouts and client-side navigation, streaming server functions and `<Markdown>` for AI apps, live queries, page head tags, `.pyweb` error pages; 0.4.1: richer MCP tools; 0.4.2: VS Code run, new-app and MCP commands; 0.4.3: fixes, security hardening, gzip and caching; 0.4.4: key rotation, session revocation, typed arguments, Redis-shared limits, `check --production` |
 | 0.3 | Hydration, live updates (SSE), multi-file apps, language server + VS Code extension, browser playground, faster rendering, screenshot/test MCP tools |

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/02-quickstart.md

@@ -88,6 +88,12 @@ pyweb serve dist                               # production server with /healthz
 `dist/` contains your app source, static assets and a `Dockerfile`; see
 [Deployment](12-deployment.md).
 
+If something doesn't work and the error isn't clear, `pyweb doctor`
+checks the project and your machine (Python, the app, optional packages,
+the database and migrations, the port, your editor) and prints a fix for
+each problem; `pyweb doctor --production` also checks the production
+settings.
+
 ## Next
 
 The [tutorial](03-tutorial.md) builds a notes app with a database,

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/14-cli.md

@@ -5,13 +5,20 @@ pyweb new NAME [--template T]        create NAME/ with app.pyweb, test_app.py, A
                                      T = blank | counter (default) | todo | blog | saas | auth | chat | ai-chat | desktop
                                      (apps with a database also get migrations/0001_initial.py and a README)
 pyweb dev FILE [--port 8000] [--host 127.0.0.1] [--no-reload]
-                                     development server: recompile on save, live reload, error overlay,
+                                     development server: recompile on save, live reload that keeps the
+                                     page's variables, form fields, scroll and focus (add ?fresh to
+                                     the URL to start over), error overlay,
                                      the dev toolbar (requests, SQL, jobs, emails, theme and motion
                                      editors), and background jobs in the same process; writes
                                      .pyweb/dev.json so `pyweb mcp` can see its errors and logs
 pyweb check FILE [--production] [--strict]
                                      compile, security and accessibility checks; --production also checks
                                      the environment; --strict fails on warnings too
+pyweb doctor [FILE] [--production] [--json] [--port 8000]
+                                     is the project ready? Python, the app compiles, optional packages,
+                                     database and migrations, Redis, secrets in the source, upgrade
+                                     changes, a stale dev server link, tests, the port, the editor; a fix
+                                     for each problem (exit 1 on any failure; --json for CI)
 pyweb upgrade [FILE] [--fix]         what to change for this PyWeb version (file and line); --fix applies
                                      the safe rewrites
 pyweb inspect FILE [--security]      where every name runs and why; RPC table; findings
@@ -66,13 +73,39 @@ pyweb dts FILE.d.ts                  Python dataclasses from TypeScript declarat
 pyweb mcp                            MCP server over stdio for AI assistants (see AI assistants & MCP)
 pyweb mcp --http [--port 8765] [--token T]   the same over Streamable HTTP (127.0.0.1 only without a token)
 pyweb lsp                            language server over stdio for editors (see below)
-pyweb test [PATH]                    run pytest
+pyweb test [PATH]                    run pytest on PATH (a test file, a folder or app.pyweb's folder;
+                                     default: the current folder, where new apps keep test_app.py)
 pyweb fmt [PATH] / pyweb lint [PATH] run ruff format / ruff check (if installed)
 pyweb --version
 ```
 
 `python -m pyweb.cli ...` is equivalent to `pyweb ...`.
 
+## Error messages
+
+A compile error names the file and line, shows the line with a caret under
+the problem, suggests the name you probably meant, and links the docs page
+that explains it:
+
+```text
+error: app.pyweb:17: <Greeting> has no prop 'nme'; did you mean 'name'?
+
+  16 |         <h1>{count}</h1>
+> 17 |         <Greeting nme="x" />
+     |                   ^
+  18 |     </main>
+
+hint: Use one of the component's parameter names as the attribute.
+docs: https://maanavkrishna.github.io/PyWeb/language.html
+```
+
+The first line keeps the `file:line: message` shape, so editors and CI
+logs can jump to it. `pyweb check` also warns about kit props and motion
+values that won't work (`<Button variant="outlin">`). The `pyweb dev`
+overlay shows the same, and when page code raises, its error page starts
+with the frames in your own files and their source lines, before the full
+traceback.
+
 ## Exit codes
 
 `check` and `build` exit `1` on compile or security errors and `2` on

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/16-limitations-roadmap.md

@@ -11,8 +11,9 @@ can decide up front whether they matter for your app.
 - **npm packages must ship ES modules.** CommonJS-only packages and
   packages built on Node.js modules can't run in the browser; see
   [npm packages](18-npm-packages.md).
-- **Dev reload is a full page reload.** State is not preserved across
-  edits.
+- **Dev reload keeps page variables, not component state.** After a save,
+  `pyweb dev` reloads the page with its variables, form fields, scroll
+  and focus as they were; state inside components starts over.
 - **SQLite is for one machine.** Several processes on one host share it
   fine, but more than one server needs Postgres or MySQL;
   `pyweb check --production` and `pyweb deploy` say so.
@@ -33,7 +34,9 @@ can decide up front whether they matter for your app.
   with Web Push, desktop windows and installers, a UI kit with themes and
   motion, Trusted Types, encrypted fields and a threat model, about 2.5×
   faster serving, Python 3.15 and free-threaded builds, and a much richer
-  MCP server.
+  MCP server. 0.6.1 added error messages with code frames and
+  suggestions, `pyweb doctor`, dev reloads that keep page state, and 4×
+  faster reloads and tests.
 - **0.5**: production apps. Models with relations and migrations, forms
   checked in the browser and on the server, an auth kit (passwords,
   passkeys, emailed links, OAuth, two-step sign-in, an admin), row-level
@@ -64,7 +67,8 @@ Planned, roughly in order. Nothing here is promised for a date.
 1. **1.0**: the API, RPC protocol and CLI frozen under semantic versioning,
    after 0.6 has been used in production for a while.
 2. **File uploads from the playground and the admin.**
-3. **State-preserving hot reload** while developing.
+3. **Hot reload without a page reload** while developing (0.6.1 already
+   keeps the page's variables, fields, scroll and focus across reloads).
 
 Ideas, bug reports and pull requests are welcome; see
 [CONTRIBUTING.md](https://github.com/MaanavKrishna/PyWeb/blob/main/CONTRIBUTING.md).

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/17-ai-assistants.md

@@ -70,7 +70,7 @@ tool runs. Slow tools (tests, screenshots, profiling) report progress.
 | `pyweb_guide` | The rules for writing `.pyweb` apps (or one section): what runs where, state, markup, components, server functions, the browser Python subset, and every common error with its fix. |
 | `pyweb_docs` | Searches the documentation (every page, the guide and the threat model) and returns the matching sections, or one whole page. For any "how do I..." question. |
 | `pyweb_new_app` | Creates an app from a template (`blank`, `counter`, `todo`, `blog`, `saas`, `auth`, `chat`, `ai-chat`, `desktop`) with `AGENTS.md`, `CLAUDE.md`, tests and a stylesheet; apps with a database also get their first migration. `saas` (teams, accounts, tenant Models, forms, live pages, jobs, webhooks, admin) is the best start for a product; `desktop` is a notes app for `pyweb desktop`. |
-| `pyweb_check` | Compiles the app and runs the security and accessibility checks. Returns `ok`, errors with `line`, `message` and a fix `hint`, plus pages (with their layouts, live-data variables and npm packages), signals, what's sent to the browser, JS size and the server functions. |
+| `pyweb_check` | Compiles the app and runs the security and accessibility checks. Returns `ok`, errors with `line`, `message`, a fix `hint`, a code `frame` and a `docs` link, plus pages (with their layouts, live-data variables and npm packages), signals, what's sent to the browser, JS size and the server functions. |
 | `pyweb_explain` | What your editor shows for a line: for each name, where it runs and why (or its signature or npm type), the problems on that line and, with `complete`, the completions at a column. |
 | `pyweb_inspect` | For every name: does it run in the browser or on the server, and why. |
 | `pyweb_compiled` | The JavaScript generated for a page, and its server-rendered HTML. |
@@ -106,6 +106,7 @@ tool runs. Slow tools (tests, screenshots, profiling) report progress.
 | Tool | What it does |
 |---|---|
 | `pyweb_dev` | Whether `pyweb dev` is running for this app: its URL, whether the app compiles right now (with the error and traceback), its pages and recent 500 errors. |
+| `pyweb_doctor` | Project health, as `pyweb doctor`: each check with `status` (ok, warn, fail), `detail` and a `fix`; `production=true` adds the production settings. |
 | `pyweb_logs` | The dev server's log lines (warnings, errors with tracebacks, slow queries, job failures); `since` returns only newer ones. |
 
 When `pyweb dev` starts, it writes `.pyweb/dev.json` next to the app: its

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/27-upgrading.md

@@ -19,6 +19,7 @@ pytest
 Apps that call `app.use_auth()` need the new `auth_sessions` table:
 
 ```bash
+pyweb db upgrade                        # apply any migrations still pending
 pyweb db diff --name auth_sessions
 pyweb db upgrade
 ```

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/docs/29-performance.md

@@ -107,12 +107,22 @@ you use it in a browser.
 Profile against a copy of your real data. A page that's fast with ten
 rows can be slow with ten thousand.
 
+## Fast reloads and tests
+
+The UI kit is compiled once per process, and each `.pyweb` file's Python
+code is reused until the file changes. On the saas example that took a
+reload in `pyweb dev` from about 255 to 60 ms and creating a
+`TestClient` from about 255 to 55 ms; the dev server also notices a save
+within a tenth of a second. Compiled output is byte-for-byte what a fresh
+compile gives, and a test checks that.
+
 ## Benchmarks in CI
 
 `python -m pyweb.bench` reports compile time, shipped JavaScript and
 render time per page. `--system` measures the whole stack: requests per
 second over real sockets, a signed-in page with a database, start-up
-time, and live query hashing.
+time, live query hashing, and how long loading an app again takes (what
+`pyweb dev` does after a save, and what each `TestClient` does).
 
 PyWeb's CI runs `--compare` on every push and pull request. It checks out
 the commit before the change next to the new one and runs both five

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyweb-stack"
-version = "0.6.0"
+version = "0.6.1"
 description = "Full-stack web apps in one Python file: server-rendered pages, reactive browser UI, typed RPC."
 readme = "README.md"
 license = "MIT"
@@ -66,7 +66,7 @@ pyweb = "pyweb.cli:main"
 include = ["pyweb*"]
 
 [tool.setuptools.package-data]
-pyweb = ["runtime/browser/*.js", "runtime/browser/ui/*.js", "ui/kit/*.pyweb", "ui/static/*", "py.typed", "ai/*.md", "templates/*.pyweb", "templates/*.css", "templates/*/*.pyweb", "templates/*/*.py", "templates/*/*.md"]
+pyweb = ["runtime/browser/*.js", "runtime/browser/ui/*.js", "runtime/browser/dev/*.js", "ui/kit/*.pyweb", "ui/static/*", "py.typed", "ai/*.md", "templates/*.pyweb", "templates/*.css", "templates/*/*.pyweb", "templates/*/*.py", "templates/*/*.md"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/pyweb/app_loader.py

@@ -30,10 +30,10 @@ def _state_function(fn):
     Markup placeholders are dropped; an explicit ``return`` (e.g.
     ``return redirect("/login")``) still returns early.
     """
-    new = copy.deepcopy(fn)
+    new = copy.copy(fn)                           # only the kept statements need copies, not the markup
     new.name = STATE_PREFIX + fn.name
     new.decorator_list = []
-    body = [s for s in new.body if not is_ui_stmt(s)]
+    body = [copy.deepcopy(s) for s in fn.body if not is_ui_stmt(s)]
     ret = ast.Return(value=ast.Call(func=ast.Name(id="locals", ctx=ast.Load()), args=[], keywords=[]))
     body.append(ret)
     new.body = body
@@ -41,6 +41,28 @@ def _state_function(fn):
     return new
 
 
+_CODE: dict = {}                  # (file, source hash, page/component names) -> code object
+
+
+def _module_code(source, filename, infos):
+    """The Python code for a ``.pyweb`` module: its Python part plus a state function per page and
+    component. Cached by source, so reloading an app (or loading it again in tests) skips re-parsing
+    the files that didn't change, the UI kit's above all."""
+    import hashlib
+    key = (filename, hashlib.sha256(source.encode()).hexdigest(), tuple(getattr(i, "name", "") for i in infos))
+    code = _CODE.get(key)
+    if code is None:
+        py_source, _ui = P.split_sources(source)
+        tree = ast.parse(py_source, filename=filename)
+        for info in infos:
+            tree.body.append(_state_function(info.node))
+        code = compile(tree, filename, "exec")
+        if len(_CODE) > 256:
+            _CODE.clear()
+        _CODE[key] = code
+    return code
+
+
 def _kit_markup(path):
     """Whether a component file is kit markup (a component copied with ``pyweb ui add``)."""
     try:
@@ -169,10 +191,7 @@ class LoadedApp:
 
     # ----------------------------------------------------------- module
     def _exec(self, source, filename, infos, module_name=None):
-        py_source, _ui = P.split_sources(source)
-        tree = ast.parse(py_source, filename=filename)
-        for info in infos:
-            tree.body.append(_state_function(info.node))
+        code = _module_code(source, filename, infos)
         stem = os.path.splitext(os.path.basename(filename))[0] or "app"
         mod = types.ModuleType(module_name or f"pyweb_app_{stem}")
         mod.__file__ = os.path.abspath(filename) if self.path else filename
@@ -191,7 +210,7 @@ class LoadedApp:
         if app_dir and app_dir not in sys.path:
             sys.path.insert(0, app_dir)
         sys.modules[mod.__name__] = mod
-        exec(compile(tree, filename, "exec"), mod.__dict__)  # noqa: S102 - the app itself
+        exec(code, mod.__dict__)  # noqa: S102 - the app itself
         return mod
 
     # -------------------------------------------------------- rendering

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/pyweb/bench.py

@@ -112,6 +112,8 @@ SYSTEM = {
     "import_ms": (False, 5.0),
     "cli_version_ms": (False, 8.0),
     "live_10k_ms": (False, 2.0),
+    "reload_ms": (False, 15.0),
+    "test_client_ms": (False, 15.0),
 }
 
 
@@ -225,6 +227,38 @@ def startup_ms(rounds=7):
             round(max(0.0, wall(["-m", "pyweb.cli", "--version"]) - floor), 1))
 
 
+def reload_ms(rounds=5):
+    """Loading the saas app again in a warm process (what ``pyweb dev`` does after a save) and creating a
+    ``TestClient`` for it, in milliseconds."""
+    import os
+    import shutil
+    import tempfile
+    from pyweb.hosting import Site
+    from pyweb.testing import TestClient
+    old = os.getcwd()
+    fixed = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "bench", "apps", "saas")
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            if os.path.isdir(fixed):
+                shutil.copytree(fixed, os.path.join(tmp, "team"))
+            else:
+                from pyweb.mcp import scaffold
+                scaffold(os.path.join(tmp, "team"), template="saas")
+            os.chdir(os.path.join(tmp, "team"))
+            Site("app.pyweb")                                   # the first load fills the caches
+            reloads, clients = [], []
+            for _ in range(rounds):
+                t0 = time.perf_counter()
+                Site("app.pyweb")
+                reloads.append((time.perf_counter() - t0) * 1000)
+                t0 = time.perf_counter()
+                TestClient("app.pyweb")
+                clients.append((time.perf_counter() - t0) * 1000)
+            return round(_median(reloads), 1), round(_median(clients), 1)
+        finally:
+            os.chdir(old)
+
+
 def live_10k_ms():
     """Version hash plus row diff for a 10,000-row live query, in milliseconds."""
     from pyweb.livedata import _version, diff
@@ -244,8 +278,9 @@ def system():
     import os
     os.environ.setdefault("PYWEB_WORKER", "0")
     imp, cli = startup_ms()
+    reload, client = reload_ms()
     return {"network_rps": network_rps(), "saas_page_us": saas_page_us(), "import_ms": imp,
-            "cli_version_ms": cli, "live_10k_ms": live_10k_ms()}
+            "cli_version_ms": cli, "live_10k_ms": live_10k_ms(), "reload_ms": reload, "test_client_ms": client}
 
 
 def regressions(base, head, *, tolerance=0.15):

{pyweb_stack-0.6.0 → pyweb_stack-0.6.1}/pyweb/cli/__init__.py

@@ -14,6 +14,17 @@ def _load(path):
         return fh.read()
 
 
+def _pretty_error(exc, path=None):
+    """A compile error as terminal text: where, the code frame, a hint and a docs link."""
+    from pyweb.compiler.errors import pretty
+    path = getattr(exc, "filename", None) or path
+    try:
+        source = _load(path) if path else None
+    except OSError:
+        source = None
+    return pretty(exc, source, path)
+
+
 def cmd_inspect(args):
     from pyweb.compiler import compile_source
     src = _load(args.file)
@@ -41,6 +52,12 @@ def cmd_inspect(args):
             print(f"{finding['kind']} {args.file}:{finding['line']}: {finding['message']}")
 
 
+def cmd_doctor(args):
+    """Is this project and this machine ready? One line per check, with a fix for each problem."""
+    from pyweb import doctor
+    raise SystemExit(doctor.main(args.file, production=args.production, as_json=args.json, port=args.port))
+
+
 def cmd_check(args):
     from pyweb.compiler import compile_source
     from pyweb.security import check_source
@@ -48,17 +65,22 @@ def cmd_check(args):
     src = _load(args.file)
     findings = check_source(src, args.file)
     findings += scan_app(args.file)
-    from pyweb import a11y
-    findings += a11y.check(src, args.file)
+    from pyweb import a11y, lsp_ui
+    findings += a11y.check(src, args.file) + lsp_ui.check(src, args.file)
     try:
         out = compile_source(src, filename=args.file)
         n_sig = sum(len(p["signals"]) for p in out["pages"].values())
         print(f"ok: {len(out['pages'])} page(s), {n_sig} signal(s), {len(out['rpc'])} rpc(s)")
     except Exception as exc:  # noqa: BLE001
-        findings.append({"kind": "compile-error", "line": getattr(exc, "lineno", None) or getattr(exc, "line", None) or 0,
-                         "message": getattr(exc, "pyweb_msg", None) or str(exc)})
+        from pyweb.compiler.errors import describe
+        rec = describe(exc, src, args.file)
+        findings.append({"kind": "compile-error", "line": rec.get("line") or 0, "message": rec["message"],
+                         "detail": "\n".join(x for x in (rec.get("frame"), rec.get("hint") and "hint: " + rec["hint"],
+                                                           rec.get("docs") and "docs: " + rec["docs"]) if x)})
     for f in findings:
         print(f"{f['kind']} {f.get('file') or args.file}:{f['line']}: {f['message']}")
+        if f.get("detail"):
+            print("    " + f["detail"].replace("\n", "\n    "))
     problems = production_problems(src, os.path.dirname(os.path.abspath(args.file))) \
         if getattr(args, "production", False) else []
     for p in problems:
@@ -230,32 +252,44 @@ def cmd_build(args):
         raise SystemExit(2)
 
 
-DEV_RELOAD_JS = """<script>(()=>{let v=null;async function t(){try{const r=await fetch('/__pyweb/dev/version');const n=await r.text();if(v!==null&&n!==v)location.reload();v=n}catch{}setTimeout(t,600)}t()})()</script>"""
+def _dev_reload_js():
+    path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "runtime", "browser", "dev",
+                        "reload.js")
+    with open(path, encoding="utf-8") as fh:
+        return "<script>" + fh.read().replace("</", "<\\/") + "</script>"
+
+
+DEV_RELOAD_JS = _dev_reload_js()
 
 
 def _error_overlay(exc, path):
     """HTML page shown in the browser while the app has a compile error."""
     import html as _h
-    lineno = getattr(exc, "lineno", None)
-    snippet = ""
+    from pyweb.compiler.errors import describe
     try:
-        lines = _load(path).splitlines()
-        if lineno:
-            lo, hi = max(0, lineno - 4), min(len(lines), lineno + 3)
-            rows = []
-            for i in range(lo, hi):
-                mark = "&gt;" if i + 1 == lineno else "&nbsp;"
-                rows.append(f"{mark} {i + 1:4d} | {_h.escape(lines[i])}")
-            snippet = "<pre class=code>" + "\n".join(rows) + "</pre>"
+        source = _load(getattr(exc, "filename", None) or path)
     except OSError:
-        pass
+        source = None
+    rec = describe(exc, source, path)
+    where = rec.get("file") or path
+    if rec.get("line"):
+        where += f":{rec['line']}"
+    parts = [f"<h1>{_h.escape(type(exc).__name__)}</h1>",
+             f"<p class=where>{_h.escape(where)}</p><pre>{_h.escape(rec['message'])}</pre>"]
+    if rec.get("frame"):
+        parts.append(f"<pre class=code>{_h.escape(rec['frame'])}</pre>")
+    if rec.get("hint"):
+        parts.append(f"<p class=hint><b>Hint:</b> {_h.escape(rec['hint'])}</p>")
+    if rec.get("docs"):
+        parts.append(f'<p><a href="{_h.escape(rec["docs"])}" target=_blank rel=noopener>Read the docs</a></p>')
     return ("<!doctype html><meta charset=utf-8><title>PyWeb error</title>"
             "<style>body{font:15px/1.5 system-ui;margin:0;background:#1b1b1f;color:#eee}"
             "main{max-width:880px;margin:8vh auto;padding:0 24px}h1{color:#ff6b6b;font-size:20px}"
             "pre{background:#0f0f12;padding:16px;border-radius:8px;overflow:auto;font-size:13px}"
-            ".code{border-left:3px solid #ff6b6b}</style><main>"
-            f"<h1>{_h.escape(type(exc).__name__)}</h1><pre>{_h.escape(str(exc))}</pre>{snippet}"
-            "<p>Fix the file and save: this page reloads automatically.</p></main>" + DEV_RELOAD_JS)
+            ".code{border-left:3px solid #ff6b6b}.where{color:#aaa;margin:0}a{color:#8ab4ff}"
+            ".hint{background:#26262c;padding:10px 14px;border-radius:8px}</style><main>"
+            + "".join(parts)
+            + "<p>Fix the file and save: this page reloads automatically.</p></main>" + DEV_RELOAD_JS)
 
 
 class _DevState:
@@ -346,7 +380,7 @@ def cmd_dev(args):
     link = Link(state)
     _dev_load(state, Site)
     if state.error is not None:
-        print(f"error: {state.error}", file=sys.stderr)
+        print("error: " + _pretty_error(state.error, state.path), file=sys.stderr)
     host = getattr(args, "host", "127.0.0.1") or "127.0.0.1"
 
     def ready(port):
@@ -395,14 +429,14 @@ def _watch_and_reload(state, Site):
     def poll():
         last = snapshot()
         while True:
-            time.sleep(0.4)
+            time.sleep(0.1)
             now = snapshot()
             if now != last:
                 last = now
                 purge_local_modules()
                 _dev_load(state, Site)
                 if state.error is not None:
-                    print(f"error: {state.error}", flush=True)
+                    print("error: " + _pretty_error(state.error, state.path), flush=True)
                 else:
                     print(f"reloaded {state.path}", flush=True)
 
@@ -495,13 +529,25 @@ def cmd_serve(args):
     _net.run(make_site, host=args.host, port=args.port, workers=workers, logger=logger, ready=ready)
 
 
+def tests_path(path=None):
+    """Where ``pyweb test`` runs pytest: the given file or folder, the folder of a ``.pyweb`` file,
+    or the current folder (templates keep ``test_app.py`` next to ``app.pyweb``)."""
+    target = os.path.abspath(path or ".")
+    if target.endswith(".pyweb"):
+        target = os.path.dirname(target)
+    return target
+
+
 def cmd_test(args):
+    import importlib.util
     import subprocess
     import sys as _sys
-    cmd = [_sys.executable, "-m", "pytest", "tests/", "-q"]
-    if getattr(args, "path", None):
-        cmd = [_sys.executable, "-m", "pytest", args.path, "-q"]
-    raise SystemExit(subprocess.call(cmd))
+    if importlib.util.find_spec("pytest") is None:
+        raise SystemExit("pyweb test runs pytest, which isn't installed: pip install pytest")
+    target = tests_path(getattr(args, "path", None))
+    if not os.path.exists(target):
+        raise SystemExit(f"pyweb test: no such file or folder: {args.path}")
+    raise SystemExit(subprocess.call([_sys.executable, "-m", "pytest", target, "-q"]))
 
 
 def cmd_fmt(args):
@@ -983,6 +1029,12 @@ def main(argv=None):
     p.add_argument("--token", default=None, help="--http: require Authorization: Bearer TOKEN (or PYWEB_MCP_TOKEN)")
     p.set_defaults(fn=cmd_mcp)
     p = sub.add_parser("lsp", help="run the language server (stdio) for editors"); p.set_defaults(fn=cmd_lsp)
+    p = sub.add_parser("doctor", help="check the project and the machine, with a fix for each problem")
+    p.add_argument("file", nargs="?", default="app.pyweb")
+    p.add_argument("--production", action="store_true", help="also check the environment for production")
+    p.add_argument("--json", action="store_true", help="print the checks as JSON")
+    p.add_argument("--port", type=int, default=8000, help="the port pyweb dev will use (default 8000)")
+    p.set_defaults(fn=cmd_doctor)
     p = sub.add_parser("check"); p.add_argument("file"); p.add_argument("--strict", action="store_true", help="exit 1 on any finding (security warnings too)")
     p.add_argument("--production", action="store_true", help="also check the environment is ready for production")
     p.set_defaults(fn=cmd_check)
@@ -1036,12 +1088,7 @@ def main(argv=None):
         print(f"error: {exc}", file=sys.stderr)
         raise SystemExit(1)
     except (CompileError, SyntaxError) as exc:
-        if isinstance(exc, SyntaxError) and not isinstance(exc, CompileError):
-            where = f"{exc.filename or getattr(args, 'file', '')}:{exc.lineno}" if exc.lineno else ""
-            msg = getattr(exc, "pyweb_msg", None) or exc.msg
-            print(f"error: {where}: {msg}" if where else f"error: {msg}", file=sys.stderr)
-        else:
-            print(f"error: {exc}", file=sys.stderr)
+        print("error: " + _pretty_error(exc, getattr(args, "file", None)), file=sys.stderr)
         raise SystemExit(1)