zeno-local 0.1.3__tar.gz

zeno_local-0.1.3/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

zeno_local-0.1.3/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: zeno-local
+Version: 0.1.3
+Summary: Local companion daemon that exposes your installed humex to the zeno cloud UI (zeno's ?mode=local).
+Author: The Zeroth Law
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://zerothlaw.io
+Keywords: zeno,humex,autonomous-vehicle,scenario,metrics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: humex>=0.2.2
+Requires-Dist: click>=8
+Dynamic: license-file
+
+# zeno-local
+
+A small local companion daemon for the **zeno** cloud UI. It imports the
+**humex** library you've installed and exposes it over a loopback HTTP server
+(the Zeno Compute Protocol) so the cloud-hosted zeno SPA can run
+simulate / evaluate / import / export against *your* local humex — including any
+custom monitors, operators, or converters you've installed.
+
+`humex` stays a pure library (it does not serve). `zeno-local` is the process
+that owns the server.
+
+## Install
+
+```bash
+pip install zeno-local      # installs into the same env as your humex
+```
+
+`humex` is a dependency, so it comes along — but if you want to use *your own*
+(modified / customized) humex, install it in the same environment first, or
+`pip install -e` your humex checkout there.
+
+## Run
+
+Quick start from a checkout (sets up a venv, installs zeno-local + humex, runs):
+
+```bash
+scripts/start.sh                 # http://127.0.0.1:8900
+PORT=9100 scripts/start.sh       # different port
+VENV=../zeno/.venv scripts/start.sh   # reuse an existing venv (and its converters)
+```
+
+Or run the installed CLI directly:
+
+```bash
+zeno-local                                   # http://127.0.0.1:8900
+zeno-local --port 9100 --cors-origin https://zeno.dev.zerothlaw.io
+```
+
+Then open zeno with `?mode=local` (and `?localUrl=` if you changed the
+host/port). zeno's "compute source" selector will route everything through this
+server instead of the in-browser Pyodide runtime.
+
+## Browser support
+
+An HTTPS-deployed zeno reaching `http://localhost` works in **Chrome** and
+**Firefox** (loopback mixed-content exemption + Chrome Private Network Access
+headers are handled). **Safari blocks it** — use Chrome/Firefox, or run zeno over
+`http://localhost` too.
+
+## Endpoints (Zeno Compute Protocol, v1)
+
+`GET /health` · `POST /parse-yaml` · `POST /test-dag` · `POST /import-package`
+(raw `.hpkg` bytes) · `POST /run-simulation` · `POST /evaluate-metrics` ·
+`POST /build-hpkg`. Per-tab state is keyed by the `X-Humex-Session` header.
+
+> Roadmap: filesystem endpoints (`/fs/*`) and converter endpoints
+> (`/converters`, `/convert`) so the UI can browse local dataset directories,
+> run native converters, and write outputs back to disk — the capabilities the
+> in-browser runtime fundamentally can't provide.

zeno_local-0.1.3/README.md

@@ -0,0 +1,59 @@
+# zeno-local
+
+A small local companion daemon for the **zeno** cloud UI. It imports the
+**humex** library you've installed and exposes it over a loopback HTTP server
+(the Zeno Compute Protocol) so the cloud-hosted zeno SPA can run
+simulate / evaluate / import / export against *your* local humex — including any
+custom monitors, operators, or converters you've installed.
+
+`humex` stays a pure library (it does not serve). `zeno-local` is the process
+that owns the server.
+
+## Install
+
+```bash
+pip install zeno-local      # installs into the same env as your humex
+```
+
+`humex` is a dependency, so it comes along — but if you want to use *your own*
+(modified / customized) humex, install it in the same environment first, or
+`pip install -e` your humex checkout there.
+
+## Run
+
+Quick start from a checkout (sets up a venv, installs zeno-local + humex, runs):
+
+```bash
+scripts/start.sh                 # http://127.0.0.1:8900
+PORT=9100 scripts/start.sh       # different port
+VENV=../zeno/.venv scripts/start.sh   # reuse an existing venv (and its converters)
+```
+
+Or run the installed CLI directly:
+
+```bash
+zeno-local                                   # http://127.0.0.1:8900
+zeno-local --port 9100 --cors-origin https://zeno.dev.zerothlaw.io
+```
+
+Then open zeno with `?mode=local` (and `?localUrl=` if you changed the
+host/port). zeno's "compute source" selector will route everything through this
+server instead of the in-browser Pyodide runtime.
+
+## Browser support
+
+An HTTPS-deployed zeno reaching `http://localhost` works in **Chrome** and
+**Firefox** (loopback mixed-content exemption + Chrome Private Network Access
+headers are handled). **Safari blocks it** — use Chrome/Firefox, or run zeno over
+`http://localhost` too.
+
+## Endpoints (Zeno Compute Protocol, v1)
+
+`GET /health` · `POST /parse-yaml` · `POST /test-dag` · `POST /import-package`
+(raw `.hpkg` bytes) · `POST /run-simulation` · `POST /evaluate-metrics` ·
+`POST /build-hpkg`. Per-tab state is keyed by the `X-Humex-Session` header.
+
+> Roadmap: filesystem endpoints (`/fs/*`) and converter endpoints
+> (`/converters`, `/convert`) so the UI can browse local dataset directories,
+> run native converters, and write outputs back to disk — the capabilities the
+> in-browser runtime fundamentally can't provide.

zeno_local-0.1.3/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=80", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zeno-local"
+version = "0.1.3"
+description = "Local companion daemon that exposes your installed humex to the zeno cloud UI (zeno's ?mode=local)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "The Zeroth Law" }]
+keywords = ["zeno", "humex", "autonomous-vehicle", "scenario", "metrics"]
+
+# humex is a hard dependency: zeno-local imports the user's installed humex and
+# exposes it. Pin the floor to the release that ships the .hpkg pack/unpack API
+# (humex.converters.hpkg) this server relies on.
+dependencies = [
+    "humex>=0.2.2",
+    "click>=8",
+]
+
+[project.scripts]
+zeno-local = "zeno_local.cli:main"
+
+[project.urls]
+Homepage = "https://zerothlaw.io"
+
+[tool.setuptools.packages.find]
+where = ["src"]

zeno_local-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zeno_local-0.1.3/src/zeno_local/__init__.py

@@ -0,0 +1,16 @@
+"""zeno-local — a thin local companion daemon for the zeno cloud UI.
+
+It imports the user's installed ``humex`` library and exposes it over a loopback
+HTTP server (the Zeno Compute Protocol) so the cloud-hosted zeno SPA can run
+simulate / evaluate / convert against the user's *local* humex — including any
+custom monitors, operators, or converters they've installed.
+
+humex stays a pure library (it does not serve); zeno-local is the process that
+owns the server. Point zeno at it with ``?mode=local``.
+"""
+
+__version__ = "0.1.0"
+
+from .app import DEFAULT_HOST, DEFAULT_PORT, run_server
+
+__all__ = ["run_server", "DEFAULT_HOST", "DEFAULT_PORT", "__version__"]

zeno_local-0.1.3/src/zeno_local/app.py

@@ -0,0 +1,245 @@
+"""Loopback HTTP server for zeno's ``local`` runtime mode (Zeno Compute Protocol).
+
+A dependency-light (stdlib :mod:`http.server`) JSON API that lets the zeno
+frontend — including one deployed over HTTPS (e.g. zeno.dev.zerothlaw.io) — run
+``simulate`` / ``evaluate`` / ``import`` / ``export`` against the user's *local*
+``humex`` install. humex is imported as a plain library; this server owns all the
+HTTP concerns so humex never has to.
+
+Cross-origin notes (why this server is careful about headers):
+  * An HTTPS page fetching ``http://localhost`` is normally blocked as mixed
+    content, but Chrome/Firefox exempt loopback. Safari does NOT — Safari users
+    on an HTTPS site can't reach a plain-HTTP local server.
+  * Chrome's Private Network Access sends a CORS *preflight* for requests from a
+    public site to a loopback address and requires
+    ``Access-Control-Allow-Private-Network: true`` on the response.
+Both are handled below.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Dict, Optional
+from urllib.parse import urlparse
+
+import humex
+
+from .operations import Session
+
+__all__ = ["run_server", "DEFAULT_PORT", "DEFAULT_HOST"]
+
+DEFAULT_PORT = 8900
+DEFAULT_HOST = "127.0.0.1"
+
+_SESSION_HEADER = "X-Humex-Session"
+_DEFAULT_SESSION = "_default"
+
+# humex APIs reachable through this server (capability handshake).
+_AVAILABLE_APIS = ["ComputeDagMetricsAPI", "RunSimulationAPI", "TestDagMetricsAPI"]
+
+
+def _server_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("zeno-local")
+    except Exception:  # noqa: BLE001 — running from source / not installed
+        return "0.0.0+dev"
+
+
+class _SessionRegistry:
+    """Thread-safe map of session-id -> :class:`Session`."""
+
+    def __init__(self) -> None:
+        self._sessions: Dict[str, Session] = {}
+        self._lock = threading.Lock()
+
+    def get(self, sid: Optional[str]) -> Session:
+        key = sid or _DEFAULT_SESSION
+        with self._lock:
+            sess = self._sessions.get(key)
+            if sess is None:
+                sess = Session()
+                self._sessions[key] = sess
+            return sess
+
+
+def _make_handler(allow_origin: str) -> type:
+    registry = _SessionRegistry()
+    zl_version = _server_version()
+
+    class Handler(BaseHTTPRequestHandler):
+        server_version = f"zeno-local/{zl_version}"
+
+        # -- low-level helpers --------------------------------------------
+        def _cors_headers(self) -> None:
+            origin = self.headers.get("Origin")
+            if allow_origin == "*":
+                self.send_header("Access-Control-Allow-Origin", origin or "*")
+                self.send_header("Vary", "Origin")
+            else:
+                self.send_header("Access-Control-Allow-Origin", allow_origin)
+                self.send_header("Vary", "Origin")
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            self.send_header(
+                "Access-Control-Allow-Headers",
+                f"Content-Type, {_SESSION_HEADER}",
+            )
+            # Chrome Private Network Access: required when a public/secure origin
+            # calls a loopback address.
+            self.send_header("Access-Control-Allow-Private-Network", "true")
+            self.send_header("Access-Control-Max-Age", "600")
+
+        def _send_json(self, status: int, payload: dict) -> None:
+            body = json.dumps(payload).encode("utf-8")
+            self.send_response(status)
+            self._cors_headers()
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _send_bytes(self, status: int, data: bytes, content_type: str) -> None:
+            self.send_response(status)
+            self._cors_headers()
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+        def _read_json(self) -> dict:
+            length = int(self.headers.get("Content-Length", 0))
+            if length == 0:
+                return {}
+            return json.loads(self.rfile.read(length).decode("utf-8"))
+
+        def _read_bytes(self) -> bytes:
+            length = int(self.headers.get("Content-Length", 0))
+            return self.rfile.read(length) if length else b""
+
+        def _session(self) -> Session:
+            return registry.get(self.headers.get(_SESSION_HEADER))
+
+        # quieter logs — one line per request, no stderr noise.
+        def log_message(self, fmt: str, *args) -> None:  # noqa: A002
+            print(f"zeno-local: {self.address_string()} - {fmt % args}")
+
+        # -- HTTP verbs ----------------------------------------------------
+        def do_OPTIONS(self) -> None:  # noqa: N802
+            self.send_response(204)
+            self._cors_headers()
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+
+        def do_GET(self) -> None:  # noqa: N802
+            path = urlparse(self.path).path
+            if path in ("/health", "/"):
+                self._send_json(
+                    200,
+                    {
+                        "status": "ok",
+                        "server": "zeno-local",
+                        "zeno_local_version": zl_version,
+                        "humex_version": humex.__version__,
+                        "available_apis": _AVAILABLE_APIS,
+                        "cold_start_seconds": 0,
+                    },
+                )
+                return
+            if path == "/converters":
+                self._send_json(200, self._session().list_converters())
+                return
+            self._send_json(404, {"success": False, "error": f"not found: {path}"})
+
+        def do_POST(self) -> None:  # noqa: N802
+            path = urlparse(self.path).path
+            try:
+                self._route_post(path)
+            except Exception as exc:  # noqa: BLE001 — never 500 silently
+                self._send_json(500, {"success": False, "error": str(exc)})
+
+        def _route_post(self, path: str) -> None:
+            session = self._session()
+
+            if path == "/parse-yaml":
+                body = self._read_json()
+                self._send_json(200, session.parse_yaml(body.get("yaml_text", "")))
+                return
+            if path == "/test-dag":
+                body = self._read_json()
+                self._send_json(200, session.test_dag(body.get("dag_yaml", "")))
+                return
+            if path == "/import-package":
+                # Raw .hpkg bytes in the request body (Content-Type ignored).
+                result = session.import_package(self._read_bytes())
+                self._send_json(200, {"success": True, **result})
+                return
+            if path == "/run-simulation":
+                body = self._read_json()
+                self._send_json(200, session.run_simulation(body.get("config_json", {})))
+                return
+            if path == "/evaluate-metrics":
+                body = self._read_json()
+                self._send_json(
+                    200,
+                    session.evaluate_metrics(body.get("metric_yaml_content", "")),
+                )
+                return
+            if path == "/convert":
+                body = self._read_json()
+                self._send_json(
+                    200,
+                    session.convert(
+                        converter_name=body.get("converter") or "",
+                        input_bytes=base64.b64decode(body.get("input_base64") or ""),
+                        input_filename=body.get("filename") or "input",
+                        options=body.get("options") or {},
+                        ego_id=body.get("ego_id"),
+                        frequency=body.get("frequency"),
+                    ),
+                )
+                return
+            if path == "/build-hpkg":
+                body = self._read_json()
+                data = session.build_hpkg(
+                    name=body.get("name") or "scenario",
+                    config_json=body.get("config_json"),
+                    metric_yaml=body.get("metric_yaml_content"),
+                    have_scenario=bool(body.get("have_scenario")),
+                )
+                self._send_bytes(200, data, "application/octet-stream")
+                return
+
+            self._send_json(404, {"success": False, "error": f"not found: {path}"})
+
+    return Handler
+
+
+def run_server(
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    allow_origin: str = "*",
+) -> None:
+    """Start the blocking local server. Ctrl-C to stop."""
+    handler = _make_handler(allow_origin)
+    httpd = ThreadingHTTPServer((host, port), handler)
+    origin_note = "any origin" if allow_origin == "*" else allow_origin
+    print(f"zeno-local {_server_version()} (humex {humex.__version__})", flush=True)
+    print(f"  listening on http://{host}:{port}", flush=True)
+    print(f"  CORS origin: {origin_note}", flush=True)
+    print(
+        "  endpoints: /health /converters /parse-yaml /test-dag /import-package "
+        "/run-simulation /evaluate-metrics /convert /build-hpkg",
+        flush=True,
+    )
+    print("  point zeno at this server with ?mode=local", flush=True)
+    print("  press Ctrl-C to stop", flush=True)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\nzeno-local: shutting down")
+    finally:
+        httpd.server_close()

zeno_local-0.1.3/src/zeno_local/cli.py

@@ -0,0 +1,46 @@
+"""``zeno-local`` CLI — serve the user's local humex to a zeno frontend."""
+
+import click
+
+from .app import DEFAULT_HOST, DEFAULT_PORT, run_server
+
+
+@click.command()
+@click.option(
+    "--host",
+    default=DEFAULT_HOST,
+    show_default=True,
+    help="Interface to bind. Keep the loopback default unless you know why "
+    "you're exposing it on the network.",
+)
+@click.option(
+    "--port",
+    default=DEFAULT_PORT,
+    show_default=True,
+    type=int,
+    help="Port to listen on.",
+)
+@click.option(
+    "--cors-origin",
+    default="*",
+    show_default=True,
+    help="Allowed browser origin (e.g. https://zeno.dev.zerothlaw.io). "
+    "Default '*' echoes the request origin — convenient for local dev.",
+)
+def main(host: str, port: int, cors_origin: str) -> None:
+    """Expose your local humex to the zeno cloud UI.
+
+    Point zeno at this server with ``?mode=local`` (and ``?localUrl=`` if you
+    changed host/port). Works from an HTTPS-deployed zeno in Chrome and Firefox
+    via the loopback mixed-content exemption; Safari blocks it.
+
+    \b
+    Example:
+        zeno-local
+        zeno-local --port 9100 --cors-origin https://zeno.dev.zerothlaw.io
+    """
+    run_server(host=host, port=port, allow_origin=cors_origin)
+
+
+if __name__ == "__main__":
+    main()

zeno_local-0.1.3/src/zeno_local/operations.py

@@ -0,0 +1,488 @@
+"""Stateful humex operations for the local ``humex serve`` HTTP server.
+
+Each browser tab gets its own :class:`Session`. A session owns a temp
+directory that holds the currently-loaded ``scenario.pb`` / ``map.pb`` so a
+follow-up evaluate / simulate / export operates on the held bytes — exactly
+the stash model zeno's Pyodide worker implements in MEMFS
+(see zeno ``frontend/public/workers/pyodide.worker.js``).
+
+This module contains zero HTTP concerns; it only turns request payloads into
+JSON-serializable dicts whose shapes match the worker's replies so the zeno
+``LocalServerRuntime`` and ``BrowserRuntime`` are interchangeable.
+"""
+
+from __future__ import annotations
+
+import base64
+import contextlib
+import io
+import json
+import logging
+import os
+import shutil
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional
+
+import yaml
+from google.protobuf.json_format import MessageToDict
+
+from humex.proto import (
+    map_pb2,
+    metric_result_pb2,
+    scenario_pb2,
+    signal_pb2,
+)
+
+__all__ = ["Session"]
+
+
+@contextlib.contextmanager
+def _capture_into(sink: List[str]) -> Iterator[None]:
+    """Collect humex's output into ``sink`` while the block runs.
+
+    humex emits progress two ways: the stdlib :mod:`logging` (the converter
+    plugins, the enhance/lane_map/role pipeline) and plain ``print`` / rich
+    Console (the CLI helpers). We grab both — a logging handler appends records
+    live, and stdout/stderr are redirected and flushed in afterward — so the
+    zeno Logs panel shows exactly what ``humex convert`` would print."""
+
+    class _Handler(logging.Handler):
+        def emit(self, record: logging.LogRecord) -> None:
+            try:
+                sink.append(f"[{record.levelname.lower()}] {record.getMessage()}")
+            except Exception:  # noqa: BLE001 — logging must never raise
+                pass
+
+    handler = _Handler()
+    root = logging.getLogger()
+    prev_level = root.level
+    root.addHandler(handler)
+    if prev_level == logging.NOTSET or prev_level > logging.INFO:
+        root.setLevel(logging.INFO)
+
+    out = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(out), contextlib.redirect_stderr(out):
+            yield
+    finally:
+        root.removeHandler(handler)
+        root.setLevel(prev_level)
+        for line in out.getvalue().splitlines():
+            if line.strip():
+                sink.append(line)
+
+
+def _decode(data: Optional[bytes], msg_cls) -> Optional[dict]:
+    """Raw protobuf bytes -> JSON dict (no field renaming; the TS transformers
+    own zeno-shape conversion). Returns ``None`` for absent pieces."""
+    if data is None:
+        return None
+    msg = msg_cls()
+    msg.ParseFromString(data)
+    return MessageToDict(msg, preserving_proto_field_name=True)
+
+
+class Session:
+    """One client tab's runtime state.
+
+    Holds a temp dir with the loaded scenario/map bytes. Methods mirror the
+    worker commands one-for-one (``parseHpkg`` → :meth:`import_package`, etc.).
+    """
+
+    def __init__(self) -> None:
+        self._dir = tempfile.mkdtemp(prefix="humex-serve-")
+
+    # -- paths -------------------------------------------------------------
+    @property
+    def _scenario_path(self) -> str:
+        return os.path.join(self._dir, "scenario.pb")
+
+    @property
+    def _map_path(self) -> str:
+        return os.path.join(self._dir, "map.pb")
+
+    def _has_scenario(self) -> bool:
+        return os.path.exists(self._scenario_path)
+
+    def _has_map(self) -> bool:
+        return os.path.exists(self._map_path)
+
+    def close(self) -> None:
+        shutil.rmtree(self._dir, ignore_errors=True)
+
+    # -- stateless ops -----------------------------------------------------
+    def parse_yaml(self, yaml_text: str) -> Dict[str, Any]:
+        try:
+            return {"success": True, "config": yaml.safe_load(yaml_text or "")}
+        except Exception as exc:  # noqa: BLE001 — surfaced to the UI verbatim
+            return {"success": False, "error": str(exc)}
+
+    def test_dag(self, dag_yaml: str) -> Dict[str, Any]:
+        """Quick-Test a DAG against inline ``mock_monitors`` (no scenario/map)."""
+        from humex.api.metrics_api import TestDagMetricsAPI
+
+        out_dir = os.path.join(self._dir, "testdag_out")
+        dag_path = os.path.join(self._dir, "testdag.yaml")
+        with open(dag_path, "w") as f:
+            f.write(dag_yaml or "")
+        try:
+            parsed = yaml.safe_load(dag_yaml or "") or {}
+            raw = parsed.get("mock_monitors", [])
+            mocks: Dict[str, Any] = {}
+            if isinstance(raw, list):
+                for m in raw:
+                    mocks[m.get("name", "")] = {k: v for k, v in m.items() if k != "name"}
+            elif isinstance(raw, dict):
+                mocks = raw
+
+            res = TestDagMetricsAPI().compute(
+                dag_yaml_path=dag_path,
+                mock_monitors=mocks or None,
+                output_dir=out_dir,
+            )
+            path = res.get("metric_result_path")
+            if not path or not os.path.exists(path):
+                return {"success": False, "error": "test-dag produced no result"}
+            with open(path, "rb") as f:
+                mr = metric_result_pb2.MetricResult()
+                mr.ParseFromString(f.read())
+            return {
+                "success": True,
+                "metric_result_pb": MessageToDict(mr, preserving_proto_field_name=True),
+                "logs": res.get("logs", []),
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {"success": False, "error": str(exc)}
+
+    # -- stateful ops ------------------------------------------------------
+    def import_package(self, pkg_bytes: bytes) -> Dict[str, Any]:
+        """Unpack a ``.hpkg``; stash scenario/map; return proto-shape dicts.
+
+        Mirrors the worker's ``parseHpkg``: the archive layout is owned by
+        ``humex.converters.hpkg``; we only decode the bytes and compute
+        lane-boundary ``map_segments`` (opaque polylines to the TS side).
+        """
+        from humex.converters.hpkg import unpack_hpkg
+        from humex.hmap.road_map_loader import RoadMapLoader
+
+        c = unpack_hpkg(pkg_bytes)
+
+        # Stash scenario.pb so a later evaluate/export reads it without a
+        # re-upload; drop any stale scenario when this package has none.
+        if c.scenario_pb is not None:
+            with open(self._scenario_path, "wb") as f:
+                f.write(c.scenario_pb)
+        elif self._has_scenario():
+            os.remove(self._scenario_path)
+        if c.map_pb is not None:
+            with open(self._map_path, "wb") as f:
+                f.write(c.map_pb)
+
+        map_segments: List[List[List[float]]] = []
+        if c.map_pb is not None:
+            try:
+                road_map = RoadMapLoader.create_road_map(
+                    self._map_path, map_name="hpkg_upload"
+                )
+                for seg in road_map.get_segments(centerline=False):
+                    pts = []
+                    for p in seg:
+                        if isinstance(p, tuple):
+                            pts.append([float(p[0]), float(p[1])])
+                        else:
+                            pts.append([float(p.x), float(p.y)])
+                    map_segments.append(pts)
+            except Exception as exc:  # noqa: BLE001 — non-fatal, log + continue
+                print(f"humex serve: get_segments failed: {exc}")
+
+        return {
+            "manifest": c.manifest,
+            "scenario_pb": _decode(c.scenario_pb, scenario_pb2.ScenarioData),
+            "map_pb": _decode(c.map_pb, map_pb2.Map),
+            "signal_pb": _decode(c.signal_pb, signal_pb2.SignalData),
+            "metric_result_pb": _decode(
+                c.metric_result_pb, metric_result_pb2.MetricResult
+            ),
+            "metric_config_yaml": c.metric_yaml,
+            "config_json": c.config_json,
+            "map_segments": map_segments,
+        }
+
+    def run_simulation(self, config_json: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate from an AVA config against the stashed map; promote the
+        result to the scenario stash so Evaluate/Export use it next."""
+        from humex.api.simulation_api import RunSimulationAPI
+
+        if not self._has_map():
+            return {
+                "success": False,
+                "error": 'No map loaded — use "Create from Map" before simulating.',
+            }
+        cfg_path = os.path.join(self._dir, "sim_config.json")
+        with open(cfg_path, "w") as f:
+            json.dump(config_json or {}, f)
+        try:
+            t0 = time.perf_counter()
+            result = RunSimulationAPI().run(
+                config_path=cfg_path,
+                map_path=self._map_path,
+                output_dir=os.path.join(self._dir, "sim_out"),
+                output_name="sim",
+            )
+            shutil.copyfile(result["scenario_proto_path"], self._scenario_path)
+            with open(self._scenario_path, "rb") as f:
+                msg = scenario_pb2.ScenarioData()
+                msg.ParseFromString(f.read())
+            return {
+                "success": True,
+                "scenario_pb": MessageToDict(msg, preserving_proto_field_name=True),
+                "simulation_time_seconds": result.get(
+                    "simulation_time_seconds", time.perf_counter() - t0
+                ),
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {"success": False, "error": str(exc)}
+
+    def evaluate_metrics(self, metric_yaml_content: str) -> Dict[str, Any]:
+        """Evaluate a DAG against the stashed scenario+map (with humex logs)."""
+        from humex.api.metrics_api import ComputeDagMetricsAPI
+
+        logs: List[str] = []
+        if not self._has_scenario() or not self._has_map():
+            return {
+                "success": False,
+                "error": "scenario or map not loaded (import a package first)",
+                "logs": ["[error] no scenario/map loaded — import a package first"],
+            }
+        yaml_path = os.path.join(self._dir, "metric.yaml")
+        with open(yaml_path, "w") as f:
+            f.write(metric_yaml_content or "")
+        logs.append("[humex] evaluate-metrics: computing DAG against stashed scenario")
+        result: Any = None
+        error: Optional[str] = None
+        with _capture_into(logs):
+            try:
+                result = ComputeDagMetricsAPI().compute(
+                    dag_yaml_path=yaml_path,
+                    scenario_file_path=self._scenario_path,
+                    map_file_path=self._map_path,
+                    save_metrics_result=False,
+                )
+            except Exception as exc:  # noqa: BLE001
+                error = str(exc)
+                logs.append(f"[error] {type(exc).__name__}: {exc}")
+        if error is not None:
+            return {"success": False, "error": error, "logs": logs}
+        mr = result.get("metric_result") if isinstance(result, dict) else None
+        metric_dict = (
+            MessageToDict(mr, preserving_proto_field_name=True)
+            if mr is not None
+            else None
+        )
+        meta = result.get("evaluation_metadata", {}) if isinstance(result, dict) else {}
+        logs.append("[humex] evaluate-metrics: done")
+        return {
+            "success": True,
+            "metric_result_pb": metric_dict,
+            "evaluation_metadata": meta,
+            "logs": logs,
+        }
+
+    def convert(
+        self,
+        converter_name: str,
+        input_bytes: bytes,
+        input_filename: str,
+        options: Optional[Dict[str, Any]] = None,
+        ego_id: Optional[int] = None,
+        frequency: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Run a named converter over uploaded raw bytes → ``.hpkg``.
+
+        Mirrors ``humex convert`` (registry lookup → ``converter.convert`` →
+        enhance/lane_map/role pipeline → ``package_as_hpkg``) but stays in a
+        per-call temp dir and returns the archive as base64 plus the humex log
+        lines, so the zeno UI can show output and stash the result."""
+        from humex.converters.registry import converters as _registry
+
+        cls = _registry().get(converter_name)
+        if cls is None:
+            installed = ", ".join(sorted(_registry())) or "(none)"
+            return {
+                "success": False,
+                "error": f"converter '{converter_name}' not installed",
+                "logs": [
+                    f"[error] converter '{converter_name}' is not installed in this "
+                    f"humex (installed: {installed})"
+                ],
+            }
+
+        from humex.convert import run_pipeline
+        from humex.converters.hpkg_packager import (
+            load_meta_for_manifest,
+            package_as_hpkg,
+        )
+
+        work = Path(tempfile.mkdtemp(prefix="zl-convert-", dir=self._dir))
+        in_name = os.path.basename(input_filename) or "input"
+        in_path = work / in_name
+        in_path.write_bytes(input_bytes)
+        out_dir = work / "out"
+
+        logs: List[str] = [f"[humex] convert {in_name} → {converter_name}"]
+        hpkg_bytes: Optional[bytes] = None
+        error: Optional[str] = None
+
+        # Enhancement: ego_id is a converter-stage option — pass it only to
+        # converters whose convert() accepts it (e.g. Waymo), else note + skip.
+        conv_opts = dict(options or {})
+        if ego_id is not None:
+            import inspect
+
+            params = inspect.signature(cls.convert).parameters
+            if "ego_id" in params or any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+            ):
+                conv_opts["ego_id"] = int(ego_id)
+            else:
+                logs.append(
+                    f"[warning] converter '{converter_name}' has no ego_id option "
+                    f"— ignoring ego id {ego_id}"
+                )
+
+        with _capture_into(logs):
+            try:
+                result = cls(str(in_path)).convert(output_dir=str(out_dir), **conv_opts)
+                episode_dir = (
+                    Path(result.scenario_path).parent if result.scenario_path else None
+                )
+                if episode_dir is None:
+                    raise RuntimeError("converter produced no scenario")
+                # Stages 2-4 (enhance / lane_map / role) — best-effort, as in the CLI.
+                try:
+                    pipeline_result = run_pipeline(episode_dir, force=True)
+                    for line in pipeline_result.summary_lines():
+                        logs.append(f"[humex] {line}")
+                except Exception as exc:  # noqa: BLE001
+                    logs.append(f"[warning] enhance/lane_map/role pipeline failed: {exc}")
+
+                # Enhancement: resample to the requested frequency (Hz). humex's
+                # ScenarioAPI does linear-interp resample + re-enhance; write the
+                # result back to scenario.pb so the packaged .hpkg uses it.
+                if frequency:
+                    try:
+                        from humex.api import ScenarioAPI
+
+                        scen_path = Path(result.scenario_path)
+                        api = ScenarioAPI()
+                        scen = api.load_from_proto_files(
+                            str(scen_path),
+                            str(episode_dir / "map.pb"),
+                            enhance=True,
+                            frequency=float(frequency),
+                        )
+                        scen_path.write_bytes(
+                            api.scenario_to_proto(scen).SerializeToString()
+                        )
+                        logs.append(f"[humex] resampled to {frequency} Hz")
+                    except Exception as exc:  # noqa: BLE001
+                        logs.append(f"[warning] resample to {frequency} Hz failed: {exc}")
+                hpkg_path = work / f"{episode_dir.name}.hpkg"
+                package_as_hpkg(
+                    episode_dir,
+                    hpkg_path,
+                    name=episode_dir.name,
+                    source={"converter": converter_name, "input_file": in_name},
+                    scenario_metadata=load_meta_for_manifest(episode_dir),
+                )
+                hpkg_bytes = hpkg_path.read_bytes()
+            except Exception as exc:  # noqa: BLE001
+                error = f"{type(exc).__name__}: {exc}"
+                logs.append(f"[error] {error}")
+
+        if hpkg_bytes is None:
+            return {"success": False, "error": error or "conversion failed", "logs": logs}
+
+        stem = in_name.rsplit(".", 1)[0] if "." in in_name else in_name
+        logs.append(f"[humex] packed {stem}.hpkg ({len(hpkg_bytes)} bytes)")
+        return {
+            "success": True,
+            "name": f"{stem}.hpkg",
+            # On-disk locations on the machine running zeno-local: the packed
+            # .hpkg and the converter's output folder. The zeno UI shows these
+            # in the Details panel. (Browser/cloud conversions have no path.)
+            "path": str(hpkg_path),
+            "folder": str(episode_dir),
+            "hpkg_base64": base64.b64encode(hpkg_bytes).decode("ascii"),
+            "logs": logs,
+        }
+
+    def build_hpkg(
+        self,
+        name: str,
+        config_json: Optional[dict],
+        metric_yaml: Optional[str],
+        have_scenario: bool,
+    ) -> bytes:
+        """Pack a ``.hpkg`` from the stashed map (+ optional scenario/config/
+        metric yaml). Raises if no map is loaded."""
+        from humex.converters.hpkg import pack_hpkg
+
+        if not self._has_map():
+            raise RuntimeError(
+                "No map is loaded — re-import a package before exporting."
+            )
+        with open(self._map_path, "rb") as f:
+            map_pb = f.read()
+        scenario_pb = None
+        if have_scenario and self._has_scenario():
+            with open(self._scenario_path, "rb") as f:
+                scenario_pb = f.read()
+        return pack_hpkg(
+            name=name or "scenario",
+            scenario_pb=scenario_pb,
+            map_pb=map_pb,
+            config_json=config_json,
+            metric_yaml=metric_yaml,
+            source="zeno",
+        )
+
+    # -- discovery (stateless) --------------------------------------------
+    def list_converters(self) -> Dict[str, Any]:
+        """Enumerate the converter plugins installed in *this* humex env.
+
+        Mirrors ``humex plugins``: walks the ``humex.converters`` entry-point
+        registry and pairs each with its distribution + declared extensions, so
+        the zeno Compute UI can list the user's local converters (including any
+        custom ones they've pip-installed alongside their humex)."""
+        from importlib.metadata import distributions
+
+        from humex.converters.registry import ENTRY_POINT_GROUP, converters
+
+        pkg_index: Dict[str, tuple] = {}
+        for dist in distributions():
+            try:
+                eps = dist.entry_points
+            except Exception:  # noqa: BLE001
+                continue
+            for ep in eps:
+                if ep.group == ENTRY_POINT_GROUP:
+                    pkg_index[ep.name] = (dist.name or "?", dist.version or "?")
+
+        out: List[Dict[str, Any]] = []
+        for name, cls in converters().items():
+            pkg, ver = pkg_index.get(name, ("?", "?"))
+            doc = (cls.__doc__ or "").strip().splitlines()
+            out.append(
+                {
+                    "name": name,
+                    "class_name": f"{cls.__module__}.{cls.__qualname__}",
+                    "package": pkg,
+                    "version": ver,
+                    "extensions": list(getattr(cls, "EXTENSIONS", ()) or ()),
+                    "description": doc[0].strip() if doc else "",
+                }
+            )
+        return {"converters": out}

zeno_local-0.1.3/src/zeno_local.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: zeno-local
+Version: 0.1.3
+Summary: Local companion daemon that exposes your installed humex to the zeno cloud UI (zeno's ?mode=local).
+Author: The Zeroth Law
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://zerothlaw.io
+Keywords: zeno,humex,autonomous-vehicle,scenario,metrics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: humex>=0.2.2
+Requires-Dist: click>=8
+Dynamic: license-file
+
+# zeno-local
+
+A small local companion daemon for the **zeno** cloud UI. It imports the
+**humex** library you've installed and exposes it over a loopback HTTP server
+(the Zeno Compute Protocol) so the cloud-hosted zeno SPA can run
+simulate / evaluate / import / export against *your* local humex — including any
+custom monitors, operators, or converters you've installed.
+
+`humex` stays a pure library (it does not serve). `zeno-local` is the process
+that owns the server.
+
+## Install
+
+```bash
+pip install zeno-local      # installs into the same env as your humex
+```
+
+`humex` is a dependency, so it comes along — but if you want to use *your own*
+(modified / customized) humex, install it in the same environment first, or
+`pip install -e` your humex checkout there.
+
+## Run
+
+Quick start from a checkout (sets up a venv, installs zeno-local + humex, runs):
+
+```bash
+scripts/start.sh                 # http://127.0.0.1:8900
+PORT=9100 scripts/start.sh       # different port
+VENV=../zeno/.venv scripts/start.sh   # reuse an existing venv (and its converters)
+```
+
+Or run the installed CLI directly:
+
+```bash
+zeno-local                                   # http://127.0.0.1:8900
+zeno-local --port 9100 --cors-origin https://zeno.dev.zerothlaw.io
+```
+
+Then open zeno with `?mode=local` (and `?localUrl=` if you changed the
+host/port). zeno's "compute source" selector will route everything through this
+server instead of the in-browser Pyodide runtime.
+
+## Browser support
+
+An HTTPS-deployed zeno reaching `http://localhost` works in **Chrome** and
+**Firefox** (loopback mixed-content exemption + Chrome Private Network Access
+headers are handled). **Safari blocks it** — use Chrome/Firefox, or run zeno over
+`http://localhost` too.
+
+## Endpoints (Zeno Compute Protocol, v1)
+
+`GET /health` · `POST /parse-yaml` · `POST /test-dag` · `POST /import-package`
+(raw `.hpkg` bytes) · `POST /run-simulation` · `POST /evaluate-metrics` ·
+`POST /build-hpkg`. Per-tab state is keyed by the `X-Humex-Session` header.
+
+> Roadmap: filesystem endpoints (`/fs/*`) and converter endpoints
+> (`/converters`, `/convert`) so the UI can browse local dataset directories,
+> run native converters, and write outputs back to disk — the capabilities the
+> in-browser runtime fundamentally can't provide.

zeno_local-0.1.3/src/zeno_local.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/zeno_local/__init__.py
+src/zeno_local/app.py
+src/zeno_local/cli.py
+src/zeno_local/operations.py
+src/zeno_local.egg-info/PKG-INFO
+src/zeno_local.egg-info/SOURCES.txt
+src/zeno_local.egg-info/dependency_links.txt
+src/zeno_local.egg-info/entry_points.txt
+src/zeno_local.egg-info/requires.txt
+src/zeno_local.egg-info/top_level.txt

zeno_local-0.1.3/src/zeno_local.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zeno_local-0.1.3/src/zeno_local.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zeno-local = zeno_local.cli:main

zeno_local-0.1.3/src/zeno_local.egg-info/requires.txt

@@ -0,0 +1,2 @@
+humex>=0.2.2
+click>=8

zeno_local-0.1.3/src/zeno_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+zeno_local