ventilatepro-cli 0.1.1__tar.gz → 0.2.0__tar.gz

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -42,6 +42,13 @@ pip install -e .
 ```bash
 ventilatepro auth login --url http://localhost:8000
 ventilatepro projects list
+ventilatepro projects show 1
+ventilatepro rooms list --project 1
+ventilatepro ahus list --project 1
+ventilatepro systems hierarchy --project 1
+ventilatepro calc status --project 1
+ventilatepro calc ahu-properties --ahu 1
+ventilatepro design-day context --project 1
 ventilatepro notes create --project 1 --body "Captured from terminal"
 ventilatepro notes sync
 ```

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/README.md

@@ -28,6 +28,13 @@ pip install -e .
 ```bash
 ventilatepro auth login --url http://localhost:8000
 ventilatepro projects list
+ventilatepro projects show 1
+ventilatepro rooms list --project 1
+ventilatepro ahus list --project 1
+ventilatepro systems hierarchy --project 1
+ventilatepro calc status --project 1
+ventilatepro calc ahu-properties --ahu 1
+ventilatepro design-day context --project 1
 ventilatepro notes create --project 1 --body "Captured from terminal"
 ventilatepro notes sync
 ```

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/tests/test_cli.py

@@ -286,3 +286,119 @@ class CliTests(unittest.TestCase):
             tags=["field", "urgent"],
             query="terminal",
         )
+
+    def test_projects_list_json_outputs_paginated_payload(self):
+        fake_client = mock.Mock()
+        fake_client.projects_list.return_value = {
+            "count": 1,
+            "limit": 20,
+            "offset": 0,
+            "results": [
+                {
+                    "id": 1,
+                    "name": "CLI Project",
+                }
+            ],
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(app, ["projects", "list", "--json"])
+
+        self.assertEqual(result.exit_code, 0)
+        payload = json.loads(result.stdout)
+        self.assertEqual(payload["results"][0]["name"], "CLI Project")
+        fake_client.projects_list.assert_called_once_with(limit=20, offset=0, query=None)
+
+    def test_projects_show_calls_api_client(self):
+        fake_client = mock.Mock()
+        fake_client.project_show.return_value = {
+            "id": 7,
+            "name": "Hospital South Wing",
+            "counts": {"rooms": 3, "zones": 2, "ahus": 1},
+            "location": "Los Angeles",
+            "time_zone": "America/Los_Angeles",
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(app, ["projects", "show", "7"])
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Hospital South Wing", result.stdout)
+        fake_client.project_show.assert_called_once_with(7)
+
+    def test_rooms_list_passes_filters_to_api_client(self):
+        fake_client = mock.Mock()
+        fake_client.list_rooms.return_value = {
+            "project_id": 1,
+            "count": 0,
+            "limit": 5,
+            "offset": 10,
+            "results": [],
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                [
+                    "rooms",
+                    "list",
+                    "--project",
+                    "1",
+                    "--limit",
+                    "5",
+                    "--offset",
+                    "10",
+                    "--query",
+                    "operating",
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        fake_client.list_rooms.assert_called_once_with(1, limit=5, offset=10, query="operating")
+
+    def test_calc_recalculate_stale_passes_mode_scope_and_force(self):
+        fake_client = mock.Mock()
+        fake_client.calc_recalculate_stale.return_value = {
+            "message": "Queued stale recalculation.",
+        }
+
+        with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+            result = self.runner.invoke(
+                app,
+                [
+                    "calc",
+                    "recalculate-stale",
+                    "--project",
+                    "1",
+                    "--scope",
+                    "zones",
+                    "--mode",
+                    "sync",
+                    "--force",
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        fake_client.calc_recalculate_stale.assert_called_once_with(1, scope="zones", mode="sync", force=True)
+
+    def test_design_day_run_reads_json_payload_from_file(self):
+        fake_client = mock.Mock()
+        fake_client.design_day_run.return_value = {
+            "id": 42,
+            "state": "QUEUED",
+        }
+
+        with tempfile.NamedTemporaryFile("w+", encoding="utf-8") as handle:
+            json.dump({"zones": [{"zone_id": 1}]}, handle)
+            handle.flush()
+
+            with mock.patch.object(auth, "get_authenticated_client", return_value=(fake_client, "http://localhost:8000")):
+                result = self.runner.invoke(
+                    app,
+                    ["design-day", "run", "--project", "1", "--input", handle.name, "--json"],
+                )
+
+        self.assertEqual(result.exit_code, 0)
+        fake_client.design_day_run.assert_called_once_with(1, {"zones": [{"zone_id": 1}]})

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/ventilatepro/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

ventilatepro_cli-0.2.0/ventilatepro/api_client.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import requests
+
+
+class ApiError(Exception):
+    def __init__(self, status_code: int, message: str, payload: Any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.payload = payload
+
+
+class NetworkError(Exception):
+    pass
+
+
+def extract_error_message(payload: Any, fallback: str) -> str:
+    if isinstance(payload, dict):
+        if isinstance(payload.get("detail"), str):
+            return payload["detail"]
+        error = payload.get("error")
+        if isinstance(error, dict) and isinstance(error.get("message"), str):
+            return error["message"]
+        return " ".join(str(value) for value in payload.values() if value)
+    if isinstance(payload, str) and payload.strip():
+        return payload
+    return fallback
+
+
+class ApiClient:
+    def __init__(self, base_url: str, token: Optional[str] = None, timeout: int = 15):
+        self.base_url = (base_url or "").rstrip("/")
+        self.token = token
+        self.timeout = timeout
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_payload: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ):
+        final_headers = {
+            "Accept": "application/json",
+        }
+        if headers:
+            final_headers.update(headers)
+        if self.token:
+            final_headers["Authorization"] = f"Bearer {self.token}"
+        try:
+            response = requests.request(
+                method=method,
+                url=f"{self.base_url}{path}",
+                json=json_payload,
+                headers=final_headers,
+                params=params,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise NetworkError(str(exc)) from exc
+
+        payload: Any = None
+        if response.content:
+            try:
+                payload = response.json()
+            except ValueError:
+                payload = response.text
+
+        if not response.ok:
+            raise ApiError(
+                status_code=response.status_code,
+                message=extract_error_message(payload, f"Request failed with status {response.status_code}."),
+                payload=payload,
+            )
+        return payload if payload is not None else {}
+
+    def auth_me(self):
+        return self.request("GET", "/api/cli/auth/me/")
+
+    def projects_list(self, *, limit: int = 20, offset: int = 0, query: Optional[str] = None):
+        params: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if query:
+            params["q"] = query
+        return self.request("GET", "/api/cli/projects/", params=params)
+
+    def project_show(self, project_id: int):
+        return self.request("GET", f"/api/cli/projects/{project_id}/")
+
+    def _list_project_entities(
+        self,
+        entity_name: str,
+        project: int,
+        *,
+        limit: int = 20,
+        offset: int = 0,
+        query: Optional[str] = None,
+    ):
+        params: Dict[str, Any] = {"project": project, "limit": limit, "offset": offset}
+        if query:
+            params["q"] = query
+        return self.request("GET", f"/api/cli/{entity_name}/", params=params)
+
+    def _show_entity(self, entity_name: str, entity_id: int):
+        return self.request("GET", f"/api/cli/{entity_name}/{entity_id}/")
+
+    def list_rooms(self, project: int, *, limit: int = 20, offset: int = 0, query: Optional[str] = None):
+        return self._list_project_entities("rooms", project, limit=limit, offset=offset, query=query)
+
+    def show_room(self, room_id: int):
+        return self._show_entity("rooms", room_id)
+
+    def list_zones(self, project: int, *, limit: int = 20, offset: int = 0, query: Optional[str] = None):
+        return self._list_project_entities("zones", project, limit=limit, offset=offset, query=query)
+
+    def show_zone(self, zone_id: int):
+        return self._show_entity("zones", zone_id)
+
+    def list_ahus(self, project: int, *, limit: int = 20, offset: int = 0, query: Optional[str] = None):
+        return self._list_project_entities("ahus", project, limit=limit, offset=offset, query=query)
+
+    def show_ahu(self, ahu_id: int):
+        return self._show_entity("ahus", ahu_id)
+
+    def list_plants(self, project: int, *, limit: int = 20, offset: int = 0, query: Optional[str] = None):
+        return self._list_project_entities("plants", project, limit=limit, offset=offset, query=query)
+
+    def show_plant(self, plant_ref: str):
+        return self.request("GET", f"/api/cli/plants/{plant_ref}/")
+
+    def system_hierarchy(self, project_id: int, *, include_envelope: bool = True):
+        return self.request(
+            "GET",
+            f"/api/cli/projects/{project_id}/systems/hierarchy/",
+            params={"include_envelope": str(bool(include_envelope)).lower()},
+        )
+
+    def system_graph(self, project_id: int):
+        return self.request("GET", f"/api/cli/projects/{project_id}/systems/graph/")
+
+    def system_topology(self, project_id: int):
+        return self.request("GET", f"/api/cli/projects/{project_id}/systems/topology/")
+
+    def calc_status(self, project_id: int):
+        return self.request("GET", f"/api/cli/projects/{project_id}/calc/status/")
+
+    def calc_ventilation(self, ahu_id: int):
+        return self.request("GET", f"/api/cli/ahus/{ahu_id}/calc/ventilation/")
+
+    def calc_ahu_steps(self, ahu_id: int):
+        return self.request("GET", f"/api/cli/ahus/{ahu_id}/calc/steps/")
+
+    def calc_ahu_properties(self, ahu_id: int, *, procedure: Optional[str] = None):
+        params = {"procedure": procedure} if procedure else None
+        return self.request("GET", f"/api/cli/ahus/{ahu_id}/calc/properties/", params=params)
+
+    def calc_recalculate_airflows(self, project_id: int):
+        return self.request("POST", f"/api/cli/projects/{project_id}/calc/recalculate-airflows/")
+
+    def calc_recalculate_stale(self, project_id: int, *, scope: str, mode: str, force: bool):
+        return self.request(
+            "POST",
+            f"/api/cli/projects/{project_id}/calc/recalculate-stale/",
+            json_payload={
+                "scope": scope,
+                "mode": mode,
+                "force": force,
+            },
+        )
+
+    def calc_cav(self, ahu_id: int):
+        return self.request("GET", f"/api/cli/ahus/{ahu_id}/calc/cav/")
+
+    def design_day_context(self, project_id: int):
+        return self.request("GET", f"/api/cli/projects/{project_id}/design-day/context/")
+
+    def design_day_run(self, project_id: int, payload: Dict[str, Any]):
+        return self.request("POST", f"/api/cli/projects/{project_id}/design-day/run/", json_payload=payload)
+
+    def design_day_results(self, job_id: int):
+        return self.request("GET", f"/api/cli/design-day/jobs/{job_id}/results/")
+
+    def create_note(self, payload: Dict[str, Any], *, idempotency_key: str):
+        return self.request(
+            "POST",
+            "/api/cli/notes/",
+            json_payload=payload,
+            headers={"Idempotency-Key": idempotency_key},
+        )
+
+    def list_notes(
+        self,
+        project: int,
+        *,
+        limit: int = 20,
+        offset: int = 0,
+        note_type: Optional[str] = None,
+        source: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+        query: Optional[str] = None,
+    ):
+        params: Dict[str, Any] = {
+            "project": project,
+            "limit": limit,
+            "offset": offset,
+        }
+        if note_type:
+            params["type"] = note_type
+        if source:
+            params["source"] = source
+        if tags:
+            params["tag"] = tags
+        if query:
+            params["q"] = query
+        return self.request("GET", "/api/cli/notes/", params=params)
+
+    def show_note(self, note_ref: str, *, project: int):
+        return self.request("GET", f"/api/cli/notes/{note_ref}/", params={"project": project})

ventilatepro_cli-0.2.0/ventilatepro/calc.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error
+
+app = typer.Typer(help="Calculation commands")
+
+
+@app.command("status")
+def calc_status(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_status(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    summary = payload.get("summary") or {}
+    zone_summary = summary.get("zones") or {}
+    ahu_summary = summary.get("ahus") or {}
+    lines = [
+        f"Project: {payload.get('project_name')}",
+        f"Zones: total={zone_summary.get('total', 0)} stale={zone_summary.get('stale', 0)} failed={zone_summary.get('failed', 0)}",
+        f"AHUs: total={ahu_summary.get('total', 0)} stale={ahu_summary.get('stale', 0)} failed={ahu_summary.get('failed', 0)}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("ventilation")
+def calc_ventilation(
+    ahu: int = typer.Option(..., "--ahu", help="AHU ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_ventilation(ahu)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [
+        f"AHU: {payload.get('ahu_name') or ahu}",
+        f"OA CFM: {payload.get('final_outside_air_cfm') or payload.get('outside_air_cfm') or 'N/A'}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("ahu-steps")
+def calc_ahu_steps(
+    ahu: int = typer.Option(..., "--ahu", help="AHU ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_ahu_steps(ahu)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [f"Returned AHU calculation steps for AHU {ahu}."]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("ahu-properties")
+def calc_ahu_properties(
+    ahu: int = typer.Option(..., "--ahu", help="AHU ID"),
+    procedure: str = typer.Option(None, "--procedure", help="Optional AHU calculation procedure"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_ahu_properties(ahu, procedure=procedure)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [f"Calculated AHU properties for AHU {ahu}."]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("recalculate-airflows")
+def calc_recalculate_airflows(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_recalculate_airflows(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [payload.get("message") or "Recalculated room airflows."]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("recalculate-stale")
+def calc_recalculate_stale(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    scope: str = typer.Option("all", "--scope", help="all, ahus, or zones"),
+    mode: str = typer.Option("async", "--mode", help="async or sync"),
+    force: bool = typer.Option(False, "--force", help="Force recalculation"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_recalculate_stale(project, scope=scope, mode=mode, force=force)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    message = payload.get("message") or payload.get("detail") or "Requested stale recalculation."
+    emit(payload, json_output=json_output, lines=[message])
+
+
+@app.command("cav")
+def calc_cav(
+    ahu: int = typer.Option(..., "--ahu", help="AHU ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.calc_cav(ahu)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    analysis = payload.get("analysis") or {}
+    critical_room = analysis.get("critical_room") or {}
+    lines = [
+        f"AHU: {payload.get('ahu_name') or ahu}",
+        f"Status: {payload.get('status') or 'N/A'}",
+        f"Critical Room: {critical_room.get('room_number') or '-'} {critical_room.get('room_name') or ''}".strip(),
+        f"Required AHU OSA Fraction: {analysis.get('required_ahu_osa_fraction')}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/ventilatepro/cli.py

@@ -1,20 +1,30 @@
 from __future__ import annotations
 
-import json
-
 import typer
 
 from . import auth, notes
 from .api_client import ApiError, NetworkError
+from .calc import app as calc_app
+from .design_day import app as design_day_app
+from .entities import ahus_app, plants_app, rooms_app, zones_app
+from .output import emit, emit_error
+from .projects import app as projects_app
 from .queue import QueueStore
+from .systems import app as systems_app
 
 app = typer.Typer(help="VentilatePro CLI")
 auth_app = typer.Typer(help="Authentication commands")
-projects_app = typer.Typer(help="Project commands")
 notes_app = typer.Typer(help="Notes commands")
 
 app.add_typer(auth_app, name="auth")
 app.add_typer(projects_app, name="projects")
+app.add_typer(rooms_app, name="rooms")
+app.add_typer(zones_app, name="zones")
+app.add_typer(ahus_app, name="ahus")
+app.add_typer(plants_app, name="plants")
+app.add_typer(systems_app, name="systems")
+app.add_typer(calc_app, name="calc")
+app.add_typer(design_day_app, name="design-day")
 app.add_typer(notes_app, name="notes")
 
 
@@ -22,21 +32,6 @@ def main():
     app()
 
 
-def emit(payload, *, json_output: bool, lines: list[str]):
-    if json_output:
-        typer.echo(json.dumps(payload, indent=2, default=str))
-        return
-    for line in lines:
-        typer.echo(line)
-
-
-def emit_error(message: str, *, json_output: bool):
-    if json_output:
-        typer.echo(json.dumps({"error": message}))
-    else:
-        typer.echo(f"Error: {message}", err=True)
-
-
 @auth_app.command("login")
 def auth_login(
     url: str = typer.Option(None, "--url", help="VentilatePro base URL"),
@@ -108,23 +103,6 @@ def auth_logout(
     emit(result, json_output=json_output, lines=["Removed local credentials."])
 
 
-@projects_app.command("list")
-def projects_list(
-    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
-):
-    try:
-        client, _ = auth.get_authenticated_client()
-        result = client.projects_list()
-    except (ValueError, ApiError, NetworkError) as exc:
-        emit_error(str(exc), json_output=json_output)
-        raise typer.Exit(1)
-
-    lines = [f"{project['id']}\t{project['name']}" for project in result]
-    if not lines:
-        lines = ["No accessible projects found."]
-    emit(result, json_output=json_output, lines=lines)
-
-
 @notes_app.command("create")
 def notes_create(
     project: int = typer.Option(..., "--project", help="Target project ID"),

ventilatepro_cli-0.2.0/ventilatepro/design_day.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error
+
+app = typer.Typer(help="Design-day commands")
+
+
+def _load_json_payload(input_path: str | None, use_stdin: bool):
+    if input_path and use_stdin:
+        raise ValueError("Use either --input or --stdin, not both.")
+    if use_stdin:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return {}
+        return json.loads(raw)
+    if input_path:
+        raw = Path(input_path).read_text(encoding="utf-8")
+        if not raw.strip():
+            return {}
+        return json.loads(raw)
+    return {}
+
+
+@app.command("context")
+def design_day_context(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.design_day_context(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    readiness = payload.get("readiness") or {}
+    lines = [
+        f"Project: {payload.get('project', {}).get('name')}",
+        f"Zones: {len(payload.get('zones') or [])}",
+        f"Ready: {not bool(readiness.get('missing_required'))}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("run")
+def design_day_run(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    input_path: str = typer.Option(None, "--input", help="Path to a JSON request payload"),
+    use_stdin: bool = typer.Option(False, "--stdin", help="Read a JSON request payload from stdin"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        payload_in = _load_json_payload(input_path, use_stdin)
+        client, _ = auth.get_authenticated_client()
+        payload = client.design_day_run(project, payload_in)
+    except json.JSONDecodeError as exc:
+        emit_error(f"Invalid JSON input: {exc}", json_output=json_output)
+        raise typer.Exit(1)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [
+        f"Submitted design-day job {payload.get('id')}.",
+        f"State: {payload.get('state') or 'queued'}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("results")
+def design_day_results(
+    job: int = typer.Option(..., "--job", help="Design-day job ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.design_day_results(job)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    lines = [
+        f"Status: {payload.get('status') or 'unknown'}",
+        f"Method: {payload.get('method') or 'N/A'}",
+        f"Generated At: {payload.get('generated_at') or 'N/A'}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)

ventilatepro_cli-0.2.0/ventilatepro/entities.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error, extract_results
+
+rooms_app = typer.Typer(help="Room commands")
+zones_app = typer.Typer(help="Zone commands")
+ahus_app = typer.Typer(help="AHU commands")
+plants_app = typer.Typer(help="Plant commands")
+
+
+def _handle_list(payload, *, json_output: bool, line_builder, empty_message: str):
+    results = extract_results(payload)
+    lines = [line_builder(item) for item in results]
+    if not lines:
+        lines = [empty_message]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@rooms_app.command("list")
+def rooms_list(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    limit: int = typer.Option(20, "--limit", help="Maximum rooms to return"),
+    offset: int = typer.Option(0, "--offset", help="Starting offset"),
+    query: str = typer.Option(None, "--query", help="Filter by room name or number"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.list_rooms(project, limit=limit, offset=offset, query=query)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    _handle_list(
+        payload,
+        json_output=json_output,
+        line_builder=lambda item: f"{item['id']}\t{item.get('number') or '-'}\t{item['name']}",
+        empty_message="No rooms found for the current filters.",
+    )
+
+
+@rooms_app.command("show")
+def rooms_show(
+    room_id: int = typer.Argument(..., help="Room ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.show_room(room_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    airflows = payload.get("airflows") or {}
+    lines = [
+        f"Room: {payload.get('number') or '-'} {payload.get('name')}",
+        f"Project: {payload.get('project_id')}",
+        f"Area: {payload.get('area')}",
+        f"Supply: {airflows.get('supply_airflow')}",
+        f"Return: {airflows.get('return_airflow')}",
+        f"Exhaust: {airflows.get('exhaust_airflow')}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@zones_app.command("list")
+def zones_list(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    limit: int = typer.Option(20, "--limit", help="Maximum zones to return"),
+    offset: int = typer.Option(0, "--offset", help="Starting offset"),
+    query: str = typer.Option(None, "--query", help="Filter by zone name"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.list_zones(project, limit=limit, offset=offset, query=query)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    _handle_list(
+        payload,
+        json_output=json_output,
+        line_builder=lambda item: f"{item['id']}\t{item['name']}\trooms={len(item.get('rooms') or [])}\tahus={len(item.get('ahus') or [])}",
+        empty_message="No zones found for the current filters.",
+    )
+
+
+@zones_app.command("show")
+def zones_show(
+    zone_id: int = typer.Argument(..., help="Zone ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.show_zone(zone_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    airflows = payload.get("airflows") or {}
+    calc = payload.get("calc") or {}
+    lines = [
+        f"Zone: {payload.get('name')}",
+        f"Project: {payload.get('project_id')}",
+        f"Max CFM: {airflows.get('maximum_airflow_cfm')}",
+        f"Min CFM: {airflows.get('minimum_airflow_cfm')}",
+        f"Heating CFM: {airflows.get('heating_airflow_cfm')}",
+        f"Calc Status: {calc.get('calc_status') or 'N/A'}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@ahus_app.command("list")
+def ahus_list(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    limit: int = typer.Option(20, "--limit", help="Maximum AHUs to return"),
+    offset: int = typer.Option(0, "--offset", help="Starting offset"),
+    query: str = typer.Option(None, "--query", help="Filter by AHU name"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.list_ahus(project, limit=limit, offset=offset, query=query)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    _handle_list(
+        payload,
+        json_output=json_output,
+        line_builder=lambda item: f"{item['id']}\t{item['name']}\t{item.get('system_type') or '-'}",
+        empty_message="No AHUs found for the current filters.",
+    )
+
+
+@ahus_app.command("show")
+def ahus_show(
+    ahu_id: int = typer.Argument(..., help="AHU ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.show_ahu(ahu_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    airflows = payload.get("airflows") or {}
+    calc = payload.get("calc") or {}
+    lines = [
+        f"AHU: {payload.get('name')}",
+        f"System Type: {payload.get('system_type') or '-'}",
+        f"Supply CFM: {airflows.get('total_supply_air_cfm')}",
+        f"Return CFM: {airflows.get('total_return_air_cfm')}",
+        f"OA CFM: {airflows.get('final_outside_air_cfm')}",
+        f"Calc Status: {calc.get('calc_status') or 'N/A'}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@plants_app.command("list")
+def plants_list(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    limit: int = typer.Option(20, "--limit", help="Maximum plants to return"),
+    offset: int = typer.Option(0, "--offset", help="Starting offset"),
+    query: str = typer.Option(None, "--query", help="Filter by plant name or type"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.list_plants(project, limit=limit, offset=offset, query=query)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    _handle_list(
+        payload,
+        json_output=json_output,
+        line_builder=lambda item: f"{item['plant_ref']}\t{item['name']}\t{item['type_label']}",
+        empty_message="No plants found for the current filters.",
+    )
+
+
+@plants_app.command("show")
+def plants_show(
+    plant_ref: str = typer.Argument(..., help="Typed plant reference, such as chilled-water:12"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.show_plant(plant_ref)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    metrics = payload.get("metrics") or {}
+    lines = [
+        f"Plant: {payload.get('name')}",
+        f"Ref: {payload.get('plant_ref')}",
+        f"Type: {payload.get('type_label')}",
+        f"Project: {payload.get('project_id')}",
+        f"Design Supply Temp: {metrics.get('design_supply_temp_f')}",
+        f"Design Return Temp: {metrics.get('design_return_temp_f')}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)

ventilatepro_cli-0.2.0/ventilatepro/output.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import typer
+
+
+def emit(payload: Any, *, json_output: bool, lines: list[str]):
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+    for line in lines:
+        typer.echo(line)
+
+
+def emit_error(message: str, *, json_output: bool):
+    if json_output:
+        typer.echo(json.dumps({"error": message}))
+    else:
+        typer.echo(f"Error: {message}", err=True)
+
+
+def extract_results(payload: Any):
+    if isinstance(payload, list):
+        return payload
+    if isinstance(payload, dict):
+        results = payload.get("results")
+        if isinstance(results, list):
+            return results
+    return []

ventilatepro_cli-0.2.0/ventilatepro/projects.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error, extract_results
+
+app = typer.Typer(help="Project commands")
+
+
+@app.command("list")
+def projects_list(
+    limit: int = typer.Option(20, "--limit", help="Maximum projects to return"),
+    offset: int = typer.Option(0, "--offset", help="Starting offset"),
+    query: str = typer.Option(None, "--query", help="Filter by project name or metadata"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.projects_list(limit=limit, offset=offset, query=query)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    results = extract_results(payload)
+    lines = [f"{project['id']}\t{project['name']}" for project in results]
+    if not lines:
+        lines = ["No accessible projects found."]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("show")
+def projects_show(
+    project_id: int = typer.Argument(..., help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.project_show(project_id)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    counts = payload.get("counts") or {}
+    lines = [
+        f"Project: {payload.get('name')}",
+        f"ID: {payload.get('id')}",
+        f"Location: {payload.get('location') or 'N/A'}",
+        f"Time Zone: {payload.get('time_zone') or 'N/A'}",
+        f"Rooms: {counts.get('rooms', 0)}",
+        f"Zones: {counts.get('zones', 0)}",
+        f"AHUs: {counts.get('ahus', 0)}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)

ventilatepro_cli-0.2.0/ventilatepro/systems.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import typer
+
+from . import auth
+from .api_client import ApiError, NetworkError
+from .output import emit, emit_error
+
+app = typer.Typer(help="System graph and hierarchy commands")
+
+
+@app.command("hierarchy")
+def system_hierarchy(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    include_envelope: bool = typer.Option(True, "--include-envelope/--no-include-envelope", help="Include envelope data"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.system_hierarchy(project, include_envelope=include_envelope)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    hierarchy = payload.get("hierarchy") or {}
+    lines = [
+        f"Project: {payload.get('project', {}).get('name')}",
+        f"Chilled Water Plants: {len(hierarchy.get('chilled_water_plants') or [])}",
+        f"Heating Plants: {len(hierarchy.get('heating_plants') or [])}",
+        f"AHUs Without Plants: {len(hierarchy.get('ahus_without_plants') or [])}",
+        f"Zones Without AHUs: {len(hierarchy.get('zones_without_ahus') or [])}",
+        f"Rooms Without Zones: {len(hierarchy.get('rooms_without_zones') or [])}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("graph")
+def system_graph(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.system_graph(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    counts = payload.get("graph", {}).get("counts") or {}
+    lines = [
+        f"Project: {payload.get('project', {}).get('name')}",
+        f"Nodes: {counts.get('nodes', 0)}",
+        f"Edges: {counts.get('edges', 0)}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)
+
+
+@app.command("topology")
+def system_topology(
+    project: int = typer.Option(..., "--project", help="Project ID"),
+    json_output: bool = typer.Option(False, "--json", help="Return JSON output"),
+):
+    try:
+        client, _ = auth.get_authenticated_client()
+        payload = client.system_topology(project)
+    except (ValueError, ApiError, NetworkError) as exc:
+        emit_error(str(exc), json_output=json_output)
+        raise typer.Exit(1)
+
+    topology = payload.get("topology") or {}
+    lines = [
+        f"Project: {payload.get('project', {}).get('name')}",
+        f"Nodes: {len(topology.get('nodes') or [])}",
+        f"Links: {len(topology.get('links') or [])}",
+    ]
+    emit(payload, json_output=json_output, lines=lines)

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/ventilatepro_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -42,6 +42,13 @@ pip install -e .
 ```bash
 ventilatepro auth login --url http://localhost:8000
 ventilatepro projects list
+ventilatepro projects show 1
+ventilatepro rooms list --project 1
+ventilatepro ahus list --project 1
+ventilatepro systems hierarchy --project 1
+ventilatepro calc status --project 1
+ventilatepro calc ahu-properties --ahu 1
+ventilatepro design-day context --project 1
 ventilatepro notes create --project 1 --body "Captured from terminal"
 ventilatepro notes sync
 ```

{ventilatepro_cli-0.1.1 → ventilatepro_cli-0.2.0}/ventilatepro_cli.egg-info/SOURCES.txt

@@ -6,10 +6,16 @@ ventilatepro/__init__.py
 ventilatepro/__main__.py
 ventilatepro/api_client.py
 ventilatepro/auth.py
+ventilatepro/calc.py
 ventilatepro/cli.py
 ventilatepro/config.py
+ventilatepro/design_day.py
+ventilatepro/entities.py
 ventilatepro/notes.py
+ventilatepro/output.py
+ventilatepro/projects.py
 ventilatepro/queue.py
+ventilatepro/systems.py
 ventilatepro_cli.egg-info/PKG-INFO
 ventilatepro_cli.egg-info/SOURCES.txt
 ventilatepro_cli.egg-info/dependency_links.txt

ventilatepro_cli-0.1.1/ventilatepro/api_client.py

@@ -1,122 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-import requests
-
-
-class ApiError(Exception):
-    def __init__(self, status_code: int, message: str, payload: Any = None):
-        super().__init__(message)
-        self.status_code = status_code
-        self.payload = payload
-
-
-class NetworkError(Exception):
-    pass
-
-
-def extract_error_message(payload: Any, fallback: str) -> str:
-    if isinstance(payload, dict):
-        if isinstance(payload.get("detail"), str):
-            return payload["detail"]
-        error = payload.get("error")
-        if isinstance(error, dict) and isinstance(error.get("message"), str):
-            return error["message"]
-        return " ".join(str(value) for value in payload.values() if value)
-    if isinstance(payload, str) and payload.strip():
-        return payload
-    return fallback
-
-
-class ApiClient:
-    def __init__(self, base_url: str, token: Optional[str] = None, timeout: int = 15):
-        self.base_url = (base_url or "").rstrip("/")
-        self.token = token
-        self.timeout = timeout
-
-    def request(
-        self,
-        method: str,
-        path: str,
-        *,
-        json_payload: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ):
-        final_headers = {
-            "Accept": "application/json",
-        }
-        if headers:
-            final_headers.update(headers)
-        if self.token:
-            final_headers["Authorization"] = f"Bearer {self.token}"
-        try:
-            response = requests.request(
-                method=method,
-                url=f"{self.base_url}{path}",
-                json=json_payload,
-                headers=final_headers,
-                params=params,
-                timeout=self.timeout,
-            )
-        except requests.RequestException as exc:
-            raise NetworkError(str(exc)) from exc
-
-        payload: Any = None
-        if response.content:
-            try:
-                payload = response.json()
-            except ValueError:
-                payload = response.text
-
-        if not response.ok:
-            raise ApiError(
-                status_code=response.status_code,
-                message=extract_error_message(payload, f"Request failed with status {response.status_code}."),
-                payload=payload,
-            )
-        return payload if payload is not None else {}
-
-    def auth_me(self):
-        return self.request("GET", "/api/cli/auth/me/")
-
-    def projects_list(self):
-        return self.request("GET", "/api/cli/projects/")
-
-    def create_note(self, payload: Dict[str, Any], *, idempotency_key: str):
-        return self.request(
-            "POST",
-            "/api/cli/notes/",
-            json_payload=payload,
-            headers={"Idempotency-Key": idempotency_key},
-        )
-
-    def list_notes(
-        self,
-        project: int,
-        *,
-        limit: int = 20,
-        offset: int = 0,
-        note_type: Optional[str] = None,
-        source: Optional[str] = None,
-        tags: Optional[list[str]] = None,
-        query: Optional[str] = None,
-    ):
-        params: Dict[str, Any] = {
-            "project": project,
-            "limit": limit,
-            "offset": offset,
-        }
-        if note_type:
-            params["type"] = note_type
-        if source:
-            params["source"] = source
-        if tags:
-            params["tag"] = tags
-        if query:
-            params["q"] = query
-        return self.request("GET", "/api/cli/notes/", params=params)
-
-    def show_note(self, note_ref: str, *, project: int):
-        return self.request("GET", f"/api/cli/notes/{note_ref}/", params={"project": project})