pyhttp-app 2.0.2__tar.gz → 2.0.3__tar.gz

{pyhttp_app-2.0.2/pyhttp_app.egg-info → pyhttp_app-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyhttp-app
-Version: 2.0.2
+Version: 2.0.3
 Summary: Local API client and alternative to Postman: collection runner, Postman-compatible scripts, mock servers and an MCP server
 Author-email: pyhttp Dev Team <dev@pyhttp.com>
 License: # pyhttp Free License 1.1
@@ -171,7 +171,10 @@ only on `127.0.0.1`.
 - **Named bodies**: a request can hold many bodies, each with its own name
   (for example `valid user`, `missing email`). Search bodies by name or content,
   and tick the ones to send. **Send** hits the request once per checked body and
-  saves every output to a run folder, with the body name in the file names.
+  saves every output to a run folder, with the body name in the file names. The
+  ➤ next to a body sends just that body, without touching the checkboxes
+  (Ctrl/Cmd+Shift+Enter does the same for the body in the editor); its ⋯ menu
+  duplicates, reorders or deletes a body without opening it.
 - **Search** across name, description, URL, tags and body names; filter by tag chips.
 - **Monitors** (topbar → Monitors): picked requests are sent again every N
   minutes while the app is open. A check fails when a request errors, answers
@@ -283,6 +286,28 @@ only on `127.0.0.1`.
 - No Node, no Electron, no build step to run it. Python 3.10+ only (the editor is a
   prebuilt CodeMirror bundle checked into the repo).
 
+## Projects
+
+A project is a separate workspace: its own requests, folders, environments, variables,
+history, cookies, run outputs, mocks and monitors. Click the project name in the top bar to
+switch, create, rename or delete one. Everything you had before projects existed is the
+*Default* project and stays where it was; each new project lives in its own folder under
+the data directory (`projects/<id>/pyhttp.db` and `projects/<id>/outputs`). App settings
+(theme, proxy, fonts…) are copied into a new project so it does not start bare. The CLI
+runner uses the active project, or `pyhttp run --project "Shop API" …` for another one;
+`pyhttp mcp --project …` serves one project to an MCP client.
+
+From a terminal: `pyhttp projects` lists them, `pyhttp projects create NAME [--use]`,
+`use NAME`, `rename OLD NEW` and `delete NAME` manage them. `pyhttp doctor` checks every
+project's database (integrity, row counts), reports run output sizes and orphan folders,
+and `pyhttp doctor --clean-outputs 30` deletes run folders older than 30 days.
+
+**Export ▾ → pyhttp JSON** writes the whole project (collection, environments, variables,
+mocks, monitors) to one file that imports into another project or machine; monitors and
+"send this request first" links are kept. **Export ▾ → Documentation** writes the
+collection as Markdown: folders, requests, parameters, headers (credential-looking values
+masked), auth, example bodies and tests.
+
 ## Mock servers
 
 An API you need does not exist yet, or you want it to fail on demand. Open

{pyhttp_app-2.0.2 → pyhttp_app-2.0.3}/README.md

@@ -22,7 +22,10 @@ only on `127.0.0.1`.
 - **Named bodies**: a request can hold many bodies, each with its own name
   (for example `valid user`, `missing email`). Search bodies by name or content,
   and tick the ones to send. **Send** hits the request once per checked body and
-  saves every output to a run folder, with the body name in the file names.
+  saves every output to a run folder, with the body name in the file names. The
+  ➤ next to a body sends just that body, without touching the checkboxes
+  (Ctrl/Cmd+Shift+Enter does the same for the body in the editor); its ⋯ menu
+  duplicates, reorders or deletes a body without opening it.
 - **Search** across name, description, URL, tags and body names; filter by tag chips.
 - **Monitors** (topbar → Monitors): picked requests are sent again every N
   minutes while the app is open. A check fails when a request errors, answers
@@ -134,6 +137,28 @@ only on `127.0.0.1`.
 - No Node, no Electron, no build step to run it. Python 3.10+ only (the editor is a
   prebuilt CodeMirror bundle checked into the repo).
 
+## Projects
+
+A project is a separate workspace: its own requests, folders, environments, variables,
+history, cookies, run outputs, mocks and monitors. Click the project name in the top bar to
+switch, create, rename or delete one. Everything you had before projects existed is the
+*Default* project and stays where it was; each new project lives in its own folder under
+the data directory (`projects/<id>/pyhttp.db` and `projects/<id>/outputs`). App settings
+(theme, proxy, fonts…) are copied into a new project so it does not start bare. The CLI
+runner uses the active project, or `pyhttp run --project "Shop API" …` for another one;
+`pyhttp mcp --project …` serves one project to an MCP client.
+
+From a terminal: `pyhttp projects` lists them, `pyhttp projects create NAME [--use]`,
+`use NAME`, `rename OLD NEW` and `delete NAME` manage them. `pyhttp doctor` checks every
+project's database (integrity, row counts), reports run output sizes and orphan folders,
+and `pyhttp doctor --clean-outputs 30` deletes run folders older than 30 days.
+
+**Export ▾ → pyhttp JSON** writes the whole project (collection, environments, variables,
+mocks, monitors) to one file that imports into another project or machine; monitors and
+"send this request first" links are kept. **Export ▾ → Documentation** writes the
+collection as Markdown: folders, requests, parameters, headers (credential-looking values
+masked), auth, example bodies and tests.
+
 ## Mock servers
 
 An API you need does not exist yet, or you want it to fail on demand. Open

{pyhttp_app-2.0.2 → pyhttp_app-2.0.3}/pyhttp/__init__.py

@@ -1,6 +1,6 @@
 """pyhttp - a local API client and alternative to Postman, with a collection runner."""
 
-__version__ = "2.0.2"
+__version__ = "2.0.3"
 # sent with every request unless the user sets their own in Settings; the convention is "product/version (+url)"
 USER_AGENT = f"pyhttp/{__version__}"
 __license__ = "pyhttp Free License 1.0 (free for everyone; source not distributed)"

{pyhttp_app-2.0.2 → pyhttp_app-2.0.3}/pyhttp/__main__.py

@@ -189,8 +189,12 @@ def main() -> None:
         from . import mcp
         mcp.main(sys.argv[2:], DEFAULT_DATA_DIR)
         return
+    if len(sys.argv) > 1 and sys.argv[1] in ("projects", "doctor"):
+        from . import tools
+        fn = tools.projects_main if sys.argv[1] == "projects" else tools.doctor_main
+        sys.exit(fn(sys.argv[2:], DEFAULT_DATA_DIR))
     parser = argparse.ArgumentParser(prog="pyhttp", description="Local API client (alternative to Postman)",
-                                     epilog="Headless runs for CI: pyhttp run --help")
+                                     epilog="Headless runs for CI: pyhttp run --help · workspaces: pyhttp projects --help · checks: pyhttp doctor")
     mode = parser.add_mutually_exclusive_group()
     mode.add_argument("--browser", action="store_true", help="open the UI in your web browser")
     mode.add_argument("--server", action="store_true", help="run the API server only, no UI")

{pyhttp_app-2.0.2 → pyhttp_app-2.0.3}/pyhttp/app.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import csv
 import io
 import json
@@ -19,8 +20,8 @@ from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, Streamin
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
 
-from . import (USER_AGENT, __version__, console, curl, db, mock, monitors, oauth2, openapi, postman, runner,
-               templating, updater)
+from . import (USER_AGENT, __version__, console, curl, db, docs, mock, monitors, oauth2, openapi, postman, projects,
+               runner, templating, updater)
 from .templating import build_context, render
 
 STATIC_DIR = Path(__file__).parent / "static"
@@ -215,6 +216,8 @@ class ImportIn(BaseModel):
     environments: list[EnvIn] = Field(default_factory=list)
     requests: list[RequestIn] = Field(default_factory=list)
     variables: dict[str, str] = Field(default_factory=dict)
+    mocks: list[dict[str, Any]] = Field(default_factory=list)
+    monitors: list[dict[str, Any]] = Field(default_factory=list)
     replace: bool = False
 
 
@@ -317,8 +320,11 @@ def _version_tuple(v: str) -> tuple[int, ...]:
 
 
 def import_collection(folders: list[dict[str, Any]], requests: list[dict[str, Any]], environments: list[dict[str, Any]],
-                      variables: dict[str, str], replace: bool) -> dict[str, Any]:
-    """Create folders (parents first), requests and environments; optionally replace everything."""
+                      variables: dict[str, str], replace: bool, mocks: list[dict[str, Any]] | None = None,
+                      monitors: list[dict[str, Any]] | None = None) -> dict[str, Any]:
+    """Create folders (parents first), requests and environments; optionally replace everything.
+    A full export also carries mocks and monitors. Requests that come with their old ``id`` are
+    remapped, so monitors and "depends on" links between requests survive the round trip."""
     if replace:
         for r in db.list_requests():
             db.delete_request(r["id"])
@@ -327,6 +333,12 @@ def import_collection(folders: list[dict[str, Any]], requests: list[dict[str, An
                 db.delete_folder(f["id"])
         for e in db.list_environments():
             db.delete_environment(e["id"])
+        if mocks:
+            for m in db.list_mocks(with_routes=False):
+                db.delete_mock(m["id"])
+        if monitors:
+            for m in db.list_monitors():
+                db.delete_monitor(m["id"])
     # folders: create parents before children, remapping ids
     id_map: dict[str, str] = {}
     pending = list(folders)
@@ -346,17 +358,45 @@ def import_collection(folders: list[dict[str, Any]], requests: list[dict[str, An
                 id_map[f["id"]] = db.create_folder(f["name"])["id"]
             break
     created = []
+    req_map: dict[str, str] = {}   # id in the file -> id in this database
     for r in requests:
         data = dict(r)
         data["folder_id"] = id_map.get(r.get("folder_id") or "")
-        created.append(db.create_request(data))
+        new_r = db.create_request(data)
+        created.append(new_r)
+        if r.get("id"):
+            req_map[str(r["id"])] = new_r["id"]
+    # "send this request first" links point at ids from the file: point them at the new rows
+    for old_r, new_r in zip(requests, created):
+        dep = ((old_r.get("options") or {}).get("depends") or {}) if isinstance(old_r.get("options"), dict) else {}
+        target = req_map.get(str(dep.get("request_id") or ""))
+        if target:
+            opts = dict(new_r.get("options") or {})
+            opts["depends"] = {**dep, "request_id": target}
+            db.update_request(new_r["id"], {**new_r, "options": opts})
     for e in environments:
         db.create_environment(e["name"], e.get("variables") or [])
     if variables:
         merged = {} if replace else db.get_variables()
         merged.update(variables)
         db.set_variables(merged)
-    return {"imported": len(created), "folders": len(id_map), "environments": len(environments)}
+    n_mocks = 0
+    for m in mocks or []:
+        if isinstance(m, dict):
+            db.create_mock({k: v for k, v in m.items() if k not in ("id", "created_at", "hits")})
+            n_mocks += 1
+    n_monitors = 0
+    for m in monitors or []:
+        if not isinstance(m, dict):
+            continue
+        ids = [req_map.get(str(i), "") for i in (m.get("request_ids") or [])]
+        ids = [i for i in ids if i]
+        if ids:   # a monitor without requests to send is pointless
+            db.create_monitor({**{k: v for k, v in m.items() if k not in ("id", "created_at", "last_run_at", "last_status")},
+                               "request_ids": ids})
+            n_monitors += 1
+    return {"imported": len(created), "folders": len(id_map), "environments": len(environments),
+            "mocks": n_mocks, "monitors": n_monitors}
 
 
 def _own_origin(request: Request) -> str:
@@ -385,35 +425,117 @@ def _mock_route_payload(data: dict[str, Any]) -> dict[str, Any]:
     return data
 
 
-def create_app(data_dir: Path) -> FastAPI:
+def create_app(data_dir: Path, project: str | None = None) -> FastAPI:
+    """``project`` (an id or a name) opens that project instead of the active one, without changing
+    which one is active — the CLI uses it for ``--project``."""
     data_dir = data_dir.resolve()
     data_dir.mkdir(parents=True, exist_ok=True)
-    output_dir = data_dir / "outputs"
+    registry = projects.Registry(data_dir)
+    if project:
+        found = registry.find(project)
+        if found is None:
+            raise ValueError(f"No project called “{project}” (projects: {', '.join(p['name'] for p in registry.list())})")
+        project_id = found["id"]
+    else:
+        project_id = registry.active()
+    db_path, output_dir = registry.paths(project_id)
     output_dir.mkdir(parents=True, exist_ok=True)
-    db.init(data_dir / "pyhttp.db")
+    db.init(db_path)
     db.mark_interrupted_runs()
     manager = runner.RunManager(output_dir)
     scheduler = monitors.MonitorScheduler()
     update_cache: dict[str, Any] = {}
     self_updater = updater.Updater(data_dir)
+    current = {"id": project_id}   # the project this app instance has open
 
-    app = FastAPI(title="pyhttp", version=__version__, docs_url="/api/docs", redoc_url=None)
-
-    @app.on_event("startup")
-    async def _start_monitors() -> None:
+    @contextlib.asynccontextmanager
+    async def lifespan(_app: FastAPI):
         scheduler.start()
+        try:
+            yield
+        finally:
+            scheduler.stop()
 
-    @app.on_event("shutdown")
-    async def _stop_monitors() -> None:
-        scheduler.stop()
+    app = FastAPI(title="pyhttp", version=__version__, docs_url="/api/docs", redoc_url=None, lifespan=lifespan)
+
+    def current_project() -> dict[str, Any]:
+        return registry.get(current["id"]) or {"id": current["id"], "name": current["id"]}
+
+    def open_project(pid: str) -> None:
+        """Switch this app to another project's database and output folder."""
+        new_db, new_out = registry.paths(pid)
+        new_out.mkdir(parents=True, exist_ok=True)
+        db.switch(new_db)
+        db.mark_interrupted_runs()
+        manager.output_root = new_out
+        oauth2.forget()   # tokens belong to the project they were fetched in
+        current["id"] = pid
 
     # ------------------------------------------------------------------ meta
     @app.get("/api/meta")
     def meta() -> dict[str, Any]:
-        return {"version": __version__, "data_dir": str(data_dir), "output_dir": str(output_dir),
+        return {"version": __version__, "data_dir": str(data_dir), "output_dir": str(manager.output_root),
+                "project": current_project(),
                 "github_repo": github_repo(), "frozen": bool(getattr(sys, "frozen", False)), "platform": sys.platform,
                 "install": updater.info(), "user_agent": USER_AGENT, "python": sys.executable}
 
+    # -------------------------------------------------------------- projects
+    # A project is a separate workspace (its own database and output folder, see projects.py).
+    # Switching reopens the database under this process, so the UI reloads afterwards.
+    def projects_payload() -> dict[str, Any]:
+        return {"current": current["id"], "active": registry.active(), "projects": registry.list()}
+
+    @app.get("/api/projects")
+    def list_projects() -> dict[str, Any]:
+        return projects_payload()
+
+    @app.post("/api/projects")
+    def create_project(body: dict[str, Any]) -> dict[str, Any]:
+        """Create a project (app settings are copied in so it does not start bare) and switch to it,
+        unless ``switch`` is false."""
+        try:
+            p = registry.create(str(body.get("name") or ""))
+        except ValueError as exc:
+            raise HTTPException(400, str(exc)) from exc
+        settings = db.app_settings_rows() if body.get("copy_settings", True) else None
+        db.seed_database(registry.paths(p["id"])[0], settings)
+        if body.get("switch", True):
+            return activate_project(p["id"])
+        return {**projects_payload(), "created": p}
+
+    @app.post("/api/projects/{pid}/activate")
+    def activate_project(pid: str) -> dict[str, Any]:
+        if registry.get(pid) is None:
+            raise HTTPException(404, "Project not found")
+        if manager.any_active():
+            raise HTTPException(409, "A run is still going. Wait for it to finish or cancel it, then switch.")
+        if pid != current["id"]:
+            open_project(pid)
+        registry.set_active(pid)
+        return projects_payload()
+
+    @app.patch("/api/projects/{pid}")
+    def rename_project(pid: str, body: dict[str, Any]) -> dict[str, Any]:
+        try:
+            registry.rename(pid, str(body.get("name") or ""))
+        except KeyError as exc:
+            raise HTTPException(404, "Project not found") from exc
+        except ValueError as exc:
+            raise HTTPException(400, str(exc)) from exc
+        return projects_payload()
+
+    @app.delete("/api/projects/{pid}")
+    def delete_project(pid: str) -> dict[str, Any]:
+        if pid == current["id"]:
+            raise HTTPException(409, "Switch to another project before deleting this one")
+        try:
+            registry.delete(pid)
+        except KeyError as exc:
+            raise HTTPException(404, "Project not found") from exc
+        except ValueError as exc:
+            raise HTTPException(409, str(exc)) from exc
+        return projects_payload()
+
     @app.get("/api/update-check")
     async def update_check(force: bool = Query(False)) -> dict[str, Any]:
         """Latest GitHub release, compared with the running version (cached for an hour)."""
@@ -459,8 +581,16 @@ def create_app(data_dir: Path) -> FastAPI:
 
     # -------------------------------------------------------------- requests
     @app.get("/api/requests")
-    def list_requests(q: str = Query(""), tag: str = Query("")) -> list[dict[str, Any]]:
-        return db.list_requests(q, tag)
+    def list_requests(q: str = Query(""), tag: str = Query(""), fields: str = Query("")) -> list[dict[str, Any]]:
+        """``fields=list`` returns what the sidebar needs (no body text, scripts, headers…): a few
+        hundred requests with big bodies would otherwise be shipped on every autosave."""
+        items = db.list_requests(q, tag)
+        if fields != "list":
+            return items
+        return [{"id": r["id"], "name": r["name"], "method": r["method"], "url": r["url"], "tags": r["tags"],
+                 "folder_id": r.get("folder_id"), "position": r.get("position", 0), "body_type": r["body_type"],
+                 "bodies": [{"id": b["id"], "name": b["name"], "enabled": b["enabled"]} for b in r["bodies"]],
+                 "updated_at": r.get("updated_at")} for r in items]
 
     @app.post("/api/requests", status_code=201)
     def create_request(body: RequestIn) -> dict[str, Any]:
@@ -836,8 +966,10 @@ def create_app(data_dir: Path) -> FastAPI:
 
     # --------------------------------------------------------------- history
     @app.get("/api/history")
-    def history(q: str = Query(""), limit: int = Query(300), status: str = Query("")) -> list[dict[str, Any]]:
-        return db.list_history(limit=min(max(limit, 1), 1000), q=q, status=status)
+    def history(q: str = Query(""), limit: int = Query(300), status: str = Query(""),
+                before: float | None = Query(None)) -> list[dict[str, Any]]:
+        """Newest first. ``before`` (a timestamp from the last row shown) pages further back."""
+        return db.list_history(limit=min(max(limit, 1), 1000), q=q, status=status, before=before)
 
     @app.post("/api/history/{hid}/resend")
     async def history_resend(hid: str) -> dict[str, Any]:
@@ -938,8 +1070,9 @@ def create_app(data_dir: Path) -> FastAPI:
         return sample_data_file(requests, "json" if format == "json" else "csv")
 
     @app.get("/api/runs")
-    def list_runs() -> list[dict[str, Any]]:
-        return db.list_runs()
+    def list_runs(limit: int = Query(200), before: float | None = Query(None)) -> list[dict[str, Any]]:
+        """Newest first; ``before`` (started_at of the last row shown) pages further back."""
+        return db.list_runs(limit=min(max(limit, 1), 1000), before=before)
 
     @app.get("/api/runs/{run_id}")
     def get_run(run_id: str) -> dict[str, Any]:
@@ -1183,17 +1316,41 @@ def create_app(data_dir: Path) -> FastAPI:
 
     # --------------------------------------------------------- import/export
     def _export_payload() -> dict[str, Any]:
+        """Everything in the project: collection, environments, variables, mocks and monitors.
+        Request ids are kept so monitors and "depends on" links can be remapped on import."""
         reqs = []
         for r in db.list_requests():
-            reqs.append({k: v for k, v in r.items() if k not in ("id", "created_at", "updated_at")})
+            reqs.append({k: v for k, v in r.items() if k not in ("created_at", "updated_at")})
         envs = [{"name": e["name"], "variables": e["variables"]} for e in db.list_environments()]
-        return {"pyhttp_version": __version__, "folders": db.list_folders(), "environments": envs,
-                "requests": reqs, "variables": db.get_variables()}
+        mocks = []
+        for m in db.list_mocks():
+            routes = [{k: v for k, v in rt.items() if k not in ("id", "server_id", "hits", "position")} for rt in m.get("routes") or []]
+            mocks.append({**{k: v for k, v in m.items() if k not in ("id", "created_at", "hits", "routes")}, "routes": routes})
+        mons = [{k: v for k, v in m.items() if k not in ("id", "created_at", "last_run_at", "last_status")} for m in db.list_monitors()]
+        return {"pyhttp_version": __version__, "project": current_project()["name"], "folders": db.list_folders(),
+                "environments": envs, "requests": reqs, "variables": db.get_variables(), "mocks": mocks, "monitors": mons}
 
     @app.get("/api/export")
     def export_all() -> dict[str, Any]:
         return _export_payload()
 
+    @app.get("/api/export/docs")
+    def export_docs(folder_id: str = Query(""), name: str = Query("")) -> dict[str, Any]:
+        """The collection (or one folder) as Markdown documentation."""
+        folders = db.list_folders()
+        requests = db.list_requests()
+        title = name or current_project()["name"] or "API"
+        if folder_id:
+            keep = db.folder_descendants(folder_id)
+            root = db.get_folder(folder_id)
+            title = name or (root["name"] if root else title)
+            folders = [{**f, "parent_id": None} if f.get("parent_id") == folder_id else f
+                       for f in folders if f["id"] in keep and f["id"] != folder_id]
+            requests = [{**r, "folder_id": None} if r.get("folder_id") == folder_id else r
+                        for r in requests if r.get("folder_id") in keep]
+        md = docs.to_markdown(title, folders, requests, db.get_variables(), db.list_environments())
+        return {"filename": re.sub(r"[^\w.-]+", "_", title).strip("_") + ".md", "markdown": md}
+
     @app.get("/api/export/postman")
     def export_postman(folder_id: str = Query(""), name: str = Query("")) -> dict[str, Any]:
         """A Postman v2.1 collection (optionally just one folder) plus environments."""
@@ -1215,7 +1372,8 @@ def create_app(data_dir: Path) -> FastAPI:
     @app.post("/api/import")
     def import_all(body: ImportIn) -> dict[str, Any]:
         return import_collection([f.model_dump() for f in body.folders], [r.model_dump() for r in body.requests],
-                          [e.model_dump() for e in body.environments], body.variables, body.replace)
+                                 [e.model_dump() for e in body.environments], body.variables, body.replace,
+                                 mocks=body.mocks, monitors=body.monitors)
 
     @app.post("/api/import/detect")
     def import_detect(body: dict[str, Any]) -> dict[str, Any]:
@@ -1238,7 +1396,8 @@ def create_app(data_dir: Path) -> FastAPI:
                     "folders": len(conv["folders"]), "entries": len(data["log"]["entries"])}
         if isinstance(data, dict) and ("requests" in data or "folders" in data):
             return {"kind": "pyhttp", "requests": len(data.get("requests") or []), "folders": len(data.get("folders") or []),
-                    "environments": len(data.get("environments") or [])}
+                    "environments": len(data.get("environments") or []), "mocks": len(data.get("mocks") or []),
+                    "monitors": len(data.get("monitors") or []), "project": data.get("project") or ""}
         if isinstance(data, list):
             return {"kind": "pyhttp", "requests": len(data), "folders": 0, "environments": 0}
         return {"kind": "unknown"}
@@ -1318,13 +1477,20 @@ def create_app(data_dir: Path) -> FastAPI:
             response.headers["Cache-Control"] = "no-store"
         return response
 
+    index_cache: dict[str, Any] = {}
+
     @app.get("/", include_in_schema=False)
     def index() -> HTMLResponse:
-        # script/style URLs get ?v=<version> so every release loads fresh files
-        html = (STATIC_DIR / "index.html").read_text(encoding="utf-8")
-        html = re.sub(r'((?:src|href)="/static/[^"?]+)"', rf'\1?v={__version__}"', html)
-        html = html.replace("<html lang=\"en\">", f"<html lang=\"en\" data-version=\"{__version__}\">", 1)
-        return HTMLResponse(html)
+        # script/style URLs get ?v=<version> so every release loads fresh files; the rewritten page is
+        # cached per file mtime (every reload hits this route, and the regex pass is not free)
+        src = STATIC_DIR / "index.html"
+        mtime = src.stat().st_mtime
+        if index_cache.get("mtime") != mtime:
+            html = src.read_text(encoding="utf-8")
+            html = re.sub(r'((?:src|href)="/static/[^"?]+)"', rf'\1?v={__version__}"', html)
+            html = html.replace("<html lang=\"en\">", f"<html lang=\"en\" data-version=\"{__version__}\">", 1)
+            index_cache.update({"mtime": mtime, "html": html})
+        return HTMLResponse(index_cache["html"])
 
     @app.exception_handler(ValueError)
     def value_error(_request: Any, exc: ValueError) -> JSONResponse:

{pyhttp_app-2.0.2 → pyhttp_app-2.0.3}/pyhttp/cli.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from typing import Any
 from xml.etree import ElementTree as ET
 
-from . import __version__, db, openapi, postman, runner
+from . import __version__, db, openapi, postman, projects, runner
 
 
 def _color(enabled: bool):
@@ -34,6 +34,7 @@ def build_parser(default_data_dir: Path) -> argparse.ArgumentParser:
     p.add_argument("targets", nargs="*", help="folder names or paths (A/B), request names or ids, or a collection "
                                                "file (Postman v2.1, pyhttp export, OpenAPI). Default: everything")
     p.add_argument("--data-dir", type=Path, default=default_data_dir, help=f"pyhttp data folder (default: {default_data_dir})")
+    p.add_argument("--project", help="project (workspace) to run from, by name or id; default: the active one")
     p.add_argument("-e", "--env", help="environment to use (name); default: the active one")
     p.add_argument("--env-file", type=Path, help="Postman environment file to use instead of a saved environment")
     p.add_argument("--var", action="append", default=[], metavar="KEY=VALUE", help="set a global variable (repeatable)")
@@ -219,18 +220,30 @@ def main(argv: list[str], default_data_dir: Path) -> int:
         data_dir = args.data_dir.resolve()
         targets = list(args.targets)
         args.targets_from_files = False
-        if not (data_dir / "pyhttp.db").exists():
-            print(f"No pyhttp data in {data_dir} (use --data-dir, or pass a collection file)", file=sys.stderr)
+        registry = projects.Registry(data_dir)
+        if args.project:
+            found = registry.find(args.project)
+            if found is None:
+                print(f"No project called {args.project!r} (projects: {', '.join(p['name'] for p in registry.list())})", file=sys.stderr)
+                return 2
+            project_id = found["id"]
+        else:
+            project_id = registry.active()
+        db_path, out_root = registry.paths(project_id)
+        if not db_path.exists():
+            print(f"No pyhttp data in {db_path.parent} (use --data-dir / --project, or pass a collection file)", file=sys.stderr)
             return 2
+    if files:
+        db_path, out_root = data_dir / "pyhttp.db", data_dir / "outputs"
     try:
-        db.init(data_dir / "pyhttp.db")
+        db.init(db_path)
         if files:
             from .app import import_collection
             for f in files:
                 conv = load_file(f)
                 import_collection(conv["folders"], conv["requests"], conv.get("environments") or [],
                                   conv.get("variables") or {}, False)
-        return _run(args, targets, data_dir, paint)
+        return _run(args, targets, out_root, paint)
     except ValueError as exc:
         print(f"pyhttp run: {exc}", file=sys.stderr)
         return 2
@@ -240,7 +253,7 @@ def main(argv: list[str], default_data_dir: Path) -> int:
             tmp.cleanup()
 
 
-def _run(args: argparse.Namespace, targets: list[str], data_dir: Path, paint) -> int:
+def _run(args: argparse.Namespace, targets: list[str], out_root: Path, paint) -> int:
     # environment, variables and settings for this run (restored afterwards when using the user's data)
     restore: dict[str, Any] = {"active_env": db.get_setting("active_env"), "settings": db.app_settings(),
                                "variables": db.get_variables()}
@@ -297,7 +310,7 @@ def _run(args: argparse.Namespace, targets: list[str], data_dir: Path, paint) ->
         if not args.quiet:
             print(paint("1", f"pyhttp {__version__} · {name}") + paint("2", f" · {len(chosen)} request(s)"
                   + (f" · environment {env['name']}" if env else "") + (f" · {max(1, args.iterations) if not data_rows else len(data_rows)} iterations" if (args.iterations > 1 or data_rows) else "")))
-        run = asyncio.run(_execute(chosen, options, data_dir, args.quiet, paint))
+        run = asyncio.run(_execute(chosen, options, out_root, args.quiet, paint))
     finally:
         if temp_env_id:
             db.delete_environment(temp_env_id)
@@ -336,8 +349,7 @@ def _run(args: argparse.Namespace, targets: list[str], data_dir: Path, paint) ->
     return 1 if failed or run["status"] not in ("completed",) else 0
 
 
-async def _execute(chosen: list[dict[str, Any]], options: dict[str, Any], data_dir: Path, quiet: bool, paint) -> dict[str, Any]:
-    out_root = data_dir / "outputs"
+async def _execute(chosen: list[dict[str, Any]], options: dict[str, Any], out_root: Path, quiet: bool, paint) -> dict[str, Any]:
     out_root.mkdir(parents=True, exist_ok=True)
     manager = runner.RunManager(out_root)
     run = await manager.start_saved([r["id"] for r in chosen], options)