ventilatepro-cli 0.5.2__tar.gz → 0.7.0__tar.gz

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ventilatepro-cli
-Version: 0.5.2
+Version: 0.7.0
 Summary: VentilatePro CLI
 Project-URL: Homepage, https://ventilatepro.com/exam/cli/
 Project-URL: Documentation, https://ventilatepro.com/exam/cli/
@@ -12,11 +12,18 @@ Requires-Dist: requests>=2.32.0
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: platformdirs>=4.3.0
 Requires-Dist: mcp<2.0.0,>=1.23.0
+Requires-Dist: PsychroLib==2.5.0
+Requires-Dist: CoolProp==8.0.0
 
 # VentilatePro CLI
 
 VentilatePro CLI is a local command-line client for authenticating to VentilatePro, recording project notes and meeting minutes, and running scoped engineering workflows.
 
+It also includes offline HVAC calculations for PsychroLib-based psychrometrics,
+sensible and total air loads, complete air-process balances, hydronics,
+IAPWS-IF97 saturated steam through CoolProp 8.0.0, fan and pump power, duct sizing, and LMTD. Local
+calculations require no login and are also available as typed MCP tools.
+
 ## Install
 
 Published releases install from PyPI:
@@ -55,6 +62,10 @@ ventilatepro ahus list --project 1
 ventilatepro systems hierarchy --project 1
 ventilatepro calc status --project 1
 ventilatepro calc ahu-properties --ahu 1
+ventilatepro calc psychrometrics --dry-bulb 75 --relative-humidity 50 --json
+ventilatepro calc air-process --cfm 5000 --entering-dry-bulb 80 --entering-rh 50 --leaving-dry-bulb 55 --leaving-rh 95 --json
+ventilatepro calc steam --pressure 15 --pressure-units psig --load 1000000 --json
+ventilatepro calc fan-power --cfm 20000 --static-pressure 4 --fan-efficiency 0.68 --motor-efficiency 0.92
 ventilatepro design-day context --project 1
 ventilatepro notes create --project 1 --body "Captured from terminal"
 ventilatepro notes sync
@@ -74,6 +85,10 @@ ventilatepro-mcp
 and other MCP clients. It uses the same saved base URL and CLI token created by
 `ventilatepro auth login`.
 
+Local HVAC tools (`vp_calculate_psychrometrics`,
+`vp_calculate_air_process`, `vp_calculate_steam`, and the rest of the catalog)
+do not use that login or make network requests.
+
 For meeting capture, Codex first reads `meetings context` to resolve names to
 stable project-member IDs, interprets the PM's prose into a structured JSON
 payload, and calls `meetings record`. The server atomically creates the meeting,
@@ -154,4 +169,8 @@ or pipe the token through stdin:
 printf '%s' "$VPCLI_TOKEN" | ventilatepro auth login --token-stdin
 ```
 
-See the hosted install guide at `https://ventilatepro.com/exam/cli/`, plus [docs/commands.md](./docs/commands.md), [docs/auth.md](./docs/auth.md), [docs/api.md](./docs/api.md), and [docs/releasing.md](./docs/releasing.md) in this repo.
+See the hosted install guide at `https://ventilatepro.com/exam/cli/`, the HVAC
+calculation reference at `https://ventilatepro.com/exam/cli/calculations/`, the
+machine-readable index at `https://ventilatepro.com/llms.txt`, plus
+[docs/commands.md](./docs/commands.md), [docs/auth.md](./docs/auth.md),
+[docs/api.md](./docs/api.md), and [docs/releasing.md](./docs/releasing.md) in this repo.

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/README.md

@@ -2,6 +2,11 @@
 
 VentilatePro CLI is a local command-line client for authenticating to VentilatePro, recording project notes and meeting minutes, and running scoped engineering workflows.
 
+It also includes offline HVAC calculations for PsychroLib-based psychrometrics,
+sensible and total air loads, complete air-process balances, hydronics,
+IAPWS-IF97 saturated steam through CoolProp 8.0.0, fan and pump power, duct sizing, and LMTD. Local
+calculations require no login and are also available as typed MCP tools.
+
 ## Install
 
 Published releases install from PyPI:
@@ -40,6 +45,10 @@ ventilatepro ahus list --project 1
 ventilatepro systems hierarchy --project 1
 ventilatepro calc status --project 1
 ventilatepro calc ahu-properties --ahu 1
+ventilatepro calc psychrometrics --dry-bulb 75 --relative-humidity 50 --json
+ventilatepro calc air-process --cfm 5000 --entering-dry-bulb 80 --entering-rh 50 --leaving-dry-bulb 55 --leaving-rh 95 --json
+ventilatepro calc steam --pressure 15 --pressure-units psig --load 1000000 --json
+ventilatepro calc fan-power --cfm 20000 --static-pressure 4 --fan-efficiency 0.68 --motor-efficiency 0.92
 ventilatepro design-day context --project 1
 ventilatepro notes create --project 1 --body "Captured from terminal"
 ventilatepro notes sync
@@ -59,6 +68,10 @@ ventilatepro-mcp
 and other MCP clients. It uses the same saved base URL and CLI token created by
 `ventilatepro auth login`.
 
+Local HVAC tools (`vp_calculate_psychrometrics`,
+`vp_calculate_air_process`, `vp_calculate_steam`, and the rest of the catalog)
+do not use that login or make network requests.
+
 For meeting capture, Codex first reads `meetings context` to resolve names to
 stable project-member IDs, interprets the PM's prose into a structured JSON
 payload, and calls `meetings record`. The server atomically creates the meeting,
@@ -139,4 +152,8 @@ or pipe the token through stdin:
 printf '%s' "$VPCLI_TOKEN" | ventilatepro auth login --token-stdin
 ```
 
-See the hosted install guide at `https://ventilatepro.com/exam/cli/`, plus [docs/commands.md](./docs/commands.md), [docs/auth.md](./docs/auth.md), [docs/api.md](./docs/api.md), and [docs/releasing.md](./docs/releasing.md) in this repo.
+See the hosted install guide at `https://ventilatepro.com/exam/cli/`, the HVAC
+calculation reference at `https://ventilatepro.com/exam/cli/calculations/`, the
+machine-readable index at `https://ventilatepro.com/llms.txt`, plus
+[docs/commands.md](./docs/commands.md), [docs/auth.md](./docs/auth.md),
+[docs/api.md](./docs/api.md), and [docs/releasing.md](./docs/releasing.md) in this repo.

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/pyproject.toml

@@ -14,6 +14,8 @@ dependencies = [
   "keyring>=25.6.0",
   "platformdirs>=4.3.0",
   "mcp>=1.23.0,<2.0.0",
+  "PsychroLib==2.5.0",
+  "CoolProp==8.0.0",
 ]
 
 [project.urls]

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/tests/test_cli.py

@@ -6,7 +6,7 @@ from unittest import mock
 
 from typer.testing import CliRunner
 
-from ventilatepro import auth, config
+from ventilatepro import __version__, auth, config
 from ventilatepro.api_client import ApiClient, ApiError, NetworkError
 from ventilatepro.cli import app
 from ventilatepro.categorization import _classification_group_key
@@ -18,6 +18,12 @@ class CliTests(unittest.TestCase):
     def setUp(self):
         self.runner = CliRunner()
 
+    def test_version_option_reports_installed_package_version(self):
+        result = self.runner.invoke(app, ["--version"])
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        self.assertEqual(result.stdout.strip(), __version__)
+
     def test_auth_login_reads_token_from_stdin(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             os.environ[config.CONFIG_ENV_VAR] = tmpdir
@@ -163,6 +169,76 @@ class CliTests(unittest.TestCase):
         self.assertEqual(result.exit_code, 1)
         self.assertIn("FAIL saved_login", result.output)
 
+    def test_equipment_create_routes_supported_type_through_cli_proxy(self):
+        fake_client = mock.Mock()
+        fake_client.cli_proxy.return_value = {"id": 81, "project": 7, "tag": "EF-CLI-1"}
+
+        with mock.patch.object(
+            auth,
+            "get_authenticated_client",
+            return_value=(fake_client, "http://localhost:8000"),
+        ):
+            result = self.runner.invoke(
+                app,
+                [
+                    "equipment",
+                    "create",
+                    "exhaust-fans",
+                    "--data",
+                    '{"project":7,"tag":"EF-CLI-1"}',
+                    "--json",
+                ],
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        fake_client.cli_proxy.assert_called_once_with(
+            "POST",
+            "exhaust-fans/",
+            json_payload={"project": 7, "tag": "EF-CLI-1"},
+        )
+
+    def test_esp_commands_create_every_path_shape_and_components(self):
+        fake_client = mock.Mock()
+        fake_client.cli_proxy.side_effect = [
+            {"id": 91, "fan_type": "SUPPLY", "ahu": 12},
+            {"id": 92, "fan_type": "RETURN", "ahu": 12},
+            {"id": 93, "fan_type": "EXHAUST", "exhaust_fan": 18},
+            {"id": 94, "fan_type": "STANDALONE", "project": 7},
+            {"id": 101, "calculation": 91, "component_type": "FILTER_MERV13"},
+        ]
+        payloads = [
+            {"project": 7, "ahu": 12, "fan_type": "SUPPLY", "name": "Supply path"},
+            {"project": 7, "ahu": 12, "fan_type": "RETURN", "name": "Return path"},
+            {"project": 7, "exhaust_fan": 18, "fan_type": "EXHAUST", "name": "Exhaust path"},
+            {"project": 7, "fan_type": "STANDALONE", "name": "Standalone path"},
+        ]
+
+        with mock.patch.object(
+            auth,
+            "get_authenticated_client",
+            return_value=(fake_client, "http://localhost:8000"),
+        ):
+            for payload in payloads:
+                result = self.runner.invoke(
+                    app,
+                    ["esp", "create", "--data", json.dumps(payload), "--json"],
+                )
+                self.assertEqual(result.exit_code, 0, result.output)
+            component = {
+                "calculation": 91,
+                "component_type": "FILTER_MERV13",
+                "description": "Final filter",
+                "pressure_drop_iwc": 0.5,
+            }
+            result = self.runner.invoke(
+                app,
+                ["esp", "add-component", "--data", json.dumps(component), "--json"],
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        paths = [call.args[1] for call in fake_client.cli_proxy.call_args_list]
+        self.assertEqual(paths, ["esp-calculations/"] * 4 + ["esp-components/"])
+
     def test_notes_create_queues_on_network_error(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             os.environ[config.CONFIG_ENV_VAR] = tmpdir

ventilatepro_cli-0.7.0/tests/test_hvac_calculations.py

@@ -0,0 +1,220 @@
+import json
+import math
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+
+from typer.testing import CliRunner
+
+from ventilatepro.cli import app
+from ventilatepro.hvac_calculations import (
+    calculate_air_process,
+    calculate_duct_size,
+    calculate_fan_power,
+    calculate_hydronic_flow,
+    calculate_hydronic_load,
+    calculate_lmtd,
+    calculate_psychrometrics,
+    calculate_pump_power,
+    calculate_saturated_steam,
+    calculate_sensible_load,
+    calculate_total_load,
+)
+
+
+class HvacCalculationTests(unittest.TestCase):
+    def test_psychrometrics_matches_published_psychrolib_example(self):
+        result = calculate_psychrometrics(
+            dry_bulb=25.0,
+            relative_humidity=80.0,
+            pressure=101325.0,
+            units="si",
+        )
+
+        self.assertAlmostEqual(result["values"]["dew_point"], 21.309397, places=5)
+        self.assertAlmostEqual(result["values"]["relative_humidity"], 80.0, places=7)
+        self.assertEqual(result["units"]["enthalpy"], "J/kg_dry_air")
+
+    def test_psychrometrics_accepts_each_supported_input_pair(self):
+        base = calculate_psychrometrics(dry_bulb=75, relative_humidity=50, units="ip")
+        values = base["values"]
+
+        for keyword, value in (
+            ("wet_bulb", values["wet_bulb"]),
+            ("dew_point", values["dew_point"]),
+            ("humidity_ratio", values["humidity_ratio"]),
+        ):
+            resolved = calculate_psychrometrics(dry_bulb=75, units="ip", **{keyword: value})
+            # PsychroLib's wet-bulb inverse solver uses its documented
+            # convergence tolerance, so a round trip can differ by a few
+            # thousandths of a percentage point.
+            self.assertAlmostEqual(resolved["values"]["relative_humidity"], 50.0, delta=0.01)
+            self.assertAlmostEqual(resolved["values"]["enthalpy"], values["enthalpy"], delta=0.001)
+
+    def test_psychrometrics_rejects_ambiguous_inputs(self):
+        with self.assertRaisesRegex(ValueError, "exactly one"):
+            calculate_psychrometrics(
+                dry_bulb=75,
+                relative_humidity=50,
+                wet_bulb=62,
+            )
+
+    def test_psychrometrics_accepts_dry_air_and_is_thread_safe_across_units(self):
+        dry_air = calculate_psychrometrics(
+            dry_bulb=75,
+            relative_humidity=0,
+            units="ip",
+        )
+        self.assertAlmostEqual(dry_air["values"]["relative_humidity"], 0.0)
+
+        def calculate(index):
+            if index % 2:
+                return calculate_psychrometrics(
+                    dry_bulb=25,
+                    relative_humidity=80,
+                    pressure=101325,
+                    units="si",
+                )
+            return calculate_psychrometrics(
+                dry_bulb=77,
+                relative_humidity=80,
+                pressure=14.6959488,
+                units="ip",
+            )
+
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            results = list(executor.map(calculate, range(40)))
+
+        for index, result in enumerate(results):
+            expected_units = "si" if index % 2 else "ip"
+            self.assertEqual(result["unit_system"], expected_units)
+            self.assertAlmostEqual(result["values"]["relative_humidity"], 80.0, places=5)
+
+    def test_standard_air_load_formulas(self):
+        sensible = calculate_sensible_load(
+            airflow_cfm=1000,
+            entering_dry_bulb_f=80,
+            leaving_dry_bulb_f=60,
+        )
+        total = calculate_total_load(
+            airflow_cfm=1000,
+            entering_enthalpy_btu_per_lb=35,
+            leaving_enthalpy_btu_per_lb=25,
+        )
+
+        self.assertAlmostEqual(sensible["values"]["sensible_load_btu_per_hr"], 21600)
+        self.assertAlmostEqual(total["values"]["total_load_btu_per_hr"], 45000)
+
+    def test_air_process_reconciles_sensible_latent_and_total(self):
+        result = calculate_air_process(
+            airflow_cfm=5000,
+            entering_dry_bulb_f=80,
+            entering_relative_humidity=50,
+            leaving_dry_bulb_f=55,
+            leaving_relative_humidity=95,
+        )
+        values = result["values"]
+
+        self.assertAlmostEqual(
+            values["sensible_load_btu_per_hr"] + values["latent_load_btu_per_hr"],
+            values["total_load_btu_per_hr"],
+            places=6,
+        )
+        self.assertGreater(values["dry_air_mass_flow_lb_per_hr"], 0)
+        self.assertGreaterEqual(values["condensate_gpm"], 0)
+
+    def test_hydronic_load_and_inverse_flow_reconcile(self):
+        load = calculate_hydronic_load(flow_gpm=10, delta_t_f=20)
+        flow = calculate_hydronic_flow(
+            load_btu_per_hr=load["values"]["load_btu_per_hr"],
+            delta_t_f=20,
+        )
+
+        self.assertAlmostEqual(load["values"]["load_btu_per_hr"], 99960)
+        self.assertAlmostEqual(flow["values"]["flow_gpm"], 10)
+
+    def test_saturated_steam_matches_boiling_point_at_zero_psig(self):
+        result = calculate_saturated_steam(
+            pressure=0,
+            pressure_units="psig",
+            quality=1,
+            load_btu_per_hr=970_000,
+        )
+        values = result["values"]
+
+        self.assertAlmostEqual(values["saturation_temperature_f"], 212.0, delta=0.08)
+        self.assertAlmostEqual(values["latent_heat_btu_per_lb"], 970.3, delta=1.0)
+        self.assertAlmostEqual(values["required_steam_lb_per_hr"], 1000, delta=2.0)
+
+    def test_fan_pump_duct_and_lmtd_calculations(self):
+        fan = calculate_fan_power(
+            airflow_cfm=10_000,
+            static_pressure_in_wg=3,
+            fan_efficiency=0.65,
+            motor_efficiency=0.9,
+        )
+        pump = calculate_pump_power(
+            flow_gpm=500,
+            head_ft=60,
+            pump_efficiency=0.75,
+            motor_efficiency=0.9,
+        )
+        duct = calculate_duct_size(airflow_cfm=1200, velocity_fpm=1000, aspect_ratio=2)
+        lmtd = calculate_lmtd(
+            hot_in_f=200,
+            hot_out_f=150,
+            cold_in_f=80,
+            cold_out_f=120,
+            arrangement="counterflow",
+        )
+
+        self.assertGreater(fan["values"]["input_kw"], 0)
+        self.assertGreater(pump["values"]["input_kw"], 0)
+        self.assertAlmostEqual(duct["values"]["area_sq_ft"], 1.2)
+        self.assertAlmostEqual(duct["values"]["round_diameter_in"], math.sqrt(4.8 / math.pi) * 12)
+        self.assertAlmostEqual(lmtd["values"]["lmtd_f"], (80 - 70) / math.log(80 / 70))
+
+
+class HvacCalculationCliTests(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    def test_psychrometrics_command_runs_offline_and_emits_json(self):
+        result = self.runner.invoke(
+            app,
+            [
+                "calc",
+                "psychrometrics",
+                "--dry-bulb",
+                "75",
+                "--relative-humidity",
+                "50",
+                "--json",
+            ],
+        )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        payload = json.loads(result.output)
+        self.assertEqual(payload["calculation"], "psychrometrics")
+        self.assertAlmostEqual(payload["values"]["relative_humidity"], 50.0, places=5)
+
+    def test_invalid_psychrometric_pair_exits_nonzero(self):
+        result = self.runner.invoke(
+            app,
+            [
+                "calc",
+                "psychrometrics",
+                "--dry-bulb",
+                "75",
+                "--relative-humidity",
+                "50",
+                "--wet-bulb",
+                "62",
+            ],
+        )
+
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("exactly one", result.output)
+
+
+if __name__ == "__main__":
+    unittest.main()

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/tests/test_mcp_server.py

@@ -107,8 +107,22 @@ class McpServerTests(unittest.TestCase):
             tools = await server.list_tools()
             names = {tool.name for tool in tools}
             self.assertIn("vp_whoami", names)
+            self.assertIn("vp_list_hvac_calculations", names)
+            self.assertIn("vp_calculate_psychrometrics", names)
+            self.assertIn("vp_calculate_sensible_load", names)
+            self.assertIn("vp_calculate_total_load", names)
+            self.assertIn("vp_calculate_air_process", names)
+            self.assertIn("vp_calculate_hydronic", names)
+            self.assertIn("vp_calculate_steam", names)
+            self.assertIn("vp_calculate_fan_power", names)
+            self.assertIn("vp_calculate_pump_power", names)
+            self.assertIn("vp_calculate_duct_size", names)
+            self.assertIn("vp_calculate_lmtd", names)
             self.assertIn("vp_api_request", names)
             self.assertIn("vp_list_entities", names)
+            self.assertIn("vp_create_equipment", names)
+            self.assertIn("vp_create_esp_calculation", names)
+            self.assertIn("vp_create_esp_component", names)
             self.assertIn("vp_run_workflow", names)
             self.assertIn("vp_get_categorization_review", names)
             self.assertIn("vp_apply_categorization", names)
@@ -128,6 +142,73 @@ class McpServerTests(unittest.TestCase):
 
         asyncio.run(run())
 
+    def test_local_psychrometric_tool_does_not_require_authentication(self):
+        async def run():
+            server = build_server()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                side_effect=AssertionError("local calculations must not authenticate"),
+            ):
+                _content, structured = await server.call_tool(
+                    "vp_calculate_psychrometrics",
+                    {"dry_bulb": 75, "relative_humidity": 50, "units": "ip"},
+                )
+
+            result = structured["result"]
+            self.assertEqual(result["calculation"], "psychrometrics")
+            self.assertAlmostEqual(result["values"]["relative_humidity"], 50.0, places=5)
+
+        asyncio.run(run())
+
+    def test_typed_equipment_and_esp_tools_route_to_supported_entities(self):
+        async def run():
+            server = build_server()
+            fake_client = FakeClient()
+            with mock.patch(
+                "ventilatepro.mcp_server.auth.get_authenticated_client",
+                return_value=(fake_client, "http://localhost:8000"),
+            ):
+                await server.call_tool(
+                    "vp_create_equipment",
+                    {
+                        "equipment_type": "condensing-units",
+                        "payload": {"project": 7, "name": "CU-1"},
+                    },
+                )
+                await server.call_tool(
+                    "vp_create_esp_calculation",
+                    {
+                        "payload": {
+                            "project": 7,
+                            "ahu": 12,
+                            "fan_type": "SUPPLY",
+                            "name": "Longest supply path",
+                        },
+                    },
+                )
+                await server.call_tool(
+                    "vp_create_esp_component",
+                    {
+                        "payload": {
+                            "calculation": 91,
+                            "component_type": "FILTER_MERV13",
+                            "description": "Final filter",
+                            "pressure_drop_iwc": 0.5,
+                        },
+                    },
+                )
+
+            self.assertEqual(
+                [call[:2] for call in fake_client.calls],
+                [
+                    ("POST", "condensing-units/"),
+                    ("POST", "esp-calculations/"),
+                    ("POST", "esp-components/"),
+                ],
+            )
+
+        asyncio.run(run())
+
     def test_record_meeting_tool_saves_without_confirmation(self):
         async def run():
             server = build_server()

{ventilatepro_cli-0.5.2 → ventilatepro_cli-0.7.0}/ventilatepro/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.5.2"
+__version__ = "0.7.0"