vantagekit 0.6.1__py3-none-any.whl

vantagekit/kit/overlay.py

@@ -0,0 +1,95 @@
+"""A small badge over the viewport, top left, naming the camera view.
+
+Drawn into the active viewport window's own overlay frame (ViewportWindow.get_frame),
+so it moves and resizes with the viewport. The frame gets a build function (the pattern
+Kit's own overlays use), so Kit can rebuild it at any time, including after an extension
+reload hands the same named frame to a new instance. Every element lets mouse events
+through, so the badge never blocks picking or navigation.
+"""
+
+from __future__ import annotations
+
+import carb
+import omni.ui as ui
+
+# ABGR colors
+COLORS = {
+    "free": 0xFFBBBBBB,
+    "chase": 0xFF40D0FF,
+    "pov": 0xFF60FF90,
+    "orbit": 0xFFFFB050,
+}
+NAMES = {"free": "FREE", "chase": "CHASE", "pov": "POINT OF VIEW", "orbit": "ORBIT"}
+BACKGROUND = 0x5A000000  # about 35 percent black: the scene shows through
+
+
+class ViewOverlay:
+    def __init__(self, name: str = "vantagekit.view"):
+        self._frame = None
+        self._label = None
+        self._hint = None
+        self._state = ("free", "", "")
+        try:
+            from omni.kit.viewport.utility import get_active_viewport_window
+
+            win = get_active_viewport_window()
+            self._frame = win.get_frame(name) if win is not None else None
+        except Exception as e:
+            carb.log_warn(f"[vantagekit] no viewport overlay: {e}")
+        if self._frame is None:
+            return
+        self._frame.set_build_fn(self._build)
+        self._frame.rebuild()
+
+    @property
+    def ready(self) -> bool:
+        return self._frame is not None
+
+    def _build(self) -> None:
+        mode, title, hint = self._state
+        with ui.VStack(opaque_for_mouse_events=False):
+            ui.Spacer(height=36, opaque_for_mouse_events=False)
+            with ui.HStack(height=0, opaque_for_mouse_events=False):
+                ui.Spacer(width=16, opaque_for_mouse_events=False)
+                with ui.ZStack(width=0, height=0, opaque_for_mouse_events=False):
+                    ui.Rectangle(style={"background_color": BACKGROUND, "border_radius": 4})
+                    with ui.VStack(width=0, height=0, opaque_for_mouse_events=False):
+                        with ui.HStack(height=0, opaque_for_mouse_events=False):
+                            ui.Spacer(width=10, opaque_for_mouse_events=False)
+                            self._label = ui.Label(title, width=0, style=self._title_style(mode))
+                            ui.Spacer(width=10, opaque_for_mouse_events=False)
+                        with ui.HStack(height=0, opaque_for_mouse_events=False):
+                            ui.Spacer(width=10, opaque_for_mouse_events=False)
+                            self._hint = ui.Label(
+                                hint, width=0, visible=bool(hint), style={"font_size": 13, "color": 0xFFCCCCCC}
+                            )
+                            ui.Spacer(width=10, opaque_for_mouse_events=False)
+                        ui.Spacer(height=4, opaque_for_mouse_events=False)
+                ui.Spacer(opaque_for_mouse_events=False)
+            ui.Spacer(opaque_for_mouse_events=False)
+
+    @staticmethod
+    def _title_style(mode: str) -> dict:
+        return {"font_size": 22, "color": COLORS.get(mode, 0xFFFFFFFF)}
+
+    def show(self, mode: str, title: str, hint: str = "") -> None:
+        """Update the badge; cheap to call every frame (it only changes on a new value)."""
+        state = (mode, title, hint)
+        if state == self._state and self._label is not None:
+            return
+        self._state = state
+        if self._label is None or self._hint is None:
+            if self._frame is not None:
+                self._frame.rebuild()
+            return
+        self._label.text = title
+        self._label.style = self._title_style(mode)
+        self._hint.text = hint
+        self._hint.visible = bool(hint)
+
+    def destroy(self) -> None:
+        if self._frame is not None:
+            # detach our build function so a later rebuild cannot call into this instance
+            self._frame.set_build_fn(lambda: None)
+            self._frame.clear()
+        self._frame = self._label = self._hint = None

vantagekit/kit/rig.py

@@ -0,0 +1,346 @@
+"""CameraRig: drives one USD camera in free, chase, point-of-view and orbit modes.
+
+The rig reads the stage up axis and meters per unit, so the same settings (meters and
+seconds) work on Y-up and Z-up stages in any unit. In free mode it writes nothing and Kit's
+native navigation moves the camera; in the attached modes it writes one cached
+xformOp:transform per frame and the camera is locked against native navigation
+(NativeNavigation). Mode changes are the only time settings or op order change.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Sequence, Tuple
+
+import carb
+import omni.usd
+from pxr import Gf, Usd, UsdGeom
+
+from ..core.frame import UpFrame, Vec3, add, scale
+from ..core.rig_math import (
+    chase_orbit_view,
+    chase_perspective,
+    look_at_matrix,
+    orbit_eye,
+    orbit_from_eye,
+    pov_view,
+)
+from ..core.smoothing import Smoothed3, SmoothedAngle, wrap_angle
+from ..core.targets import TargetCycler
+from .native_nav import NativeNavigation
+
+MODES = ("free", "chase", "pov", "orbit")
+
+
+@dataclass
+class RigSettings:
+    views: Tuple[str, ...] = ("chase", "pov", "orbit")
+    body_forward: Optional[Sequence[float]] = None  # target's forward axis; None: +Z (Y up), +X (Z up)
+    # chase: the default perspective, behind and above, horizon level. The camera looks
+    # at the pivot chase_look_up_m above the target; orbit turns around the same pivot,
+    # and leaving orbit for chase keeps the perspective set there.
+    chase_back_m: float = 12.5
+    chase_up_m: float = 1.8
+    chase_look_up_m: float = 1.8
+    chase_tau_target_s: float = 0.05
+    chase_tau_heading_s: float = 0.35
+    # point of view: fixed in the target's body frame
+    pov_forward_m: float = 6.0
+    pov_up_m: float = 2.5
+    pov_right_m: float = 0.0
+    # orbit
+    orbit_tau_target_s: float = 0.15
+    orbit_range_m: float = 40.0
+    orbit_min_m: float = 2.0
+    orbit_max_m: float = 20000.0
+    orbit_elevation_deg: float = 20.0
+    orbit_min_elevation_deg: float = -10.0
+    orbit_max_elevation_deg: float = 85.0
+
+
+class CameraRig:
+    def __init__(
+        self,
+        camera_path: str,
+        targets: TargetCycler,
+        settings: RigSettings | None = None,
+        native: NativeNavigation | None = None,
+        usd_context=None,
+        name: str = "vantagekit",
+    ):
+        self.camera_path = str(camera_path)
+        self.targets = targets
+        self.settings = settings or RigSettings()
+        self.native = native or NativeNavigation()
+        self.name = name
+        self._ctx = usd_context or omni.usd.get_context()
+        self.mode = "free"
+        self.view = self.settings.views[0]
+        self.frame = UpFrame("Y")
+        self._op = None
+        self._target = Smoothed3(self.settings.chase_tau_target_s)
+        self._heading = SmoothedAngle(self.settings.chase_tau_heading_s)
+        self._last_heading = 0.0
+        self.orbit_yaw = 0.0
+        self.orbit_elevation = math.radians(self.settings.orbit_elevation_deg)
+        self.orbit_range_m = self.settings.orbit_range_m
+        # Chase perspective, relative to the target's heading: (yaw, elevation, meters).
+        # Leaving orbit for chase keeps the perspective set in orbit; home() resets it.
+        self.chase_yaw_rel, self.chase_elevation, self.chase_range_m = self.default_chase()
+        self.home_view: Optional[Tuple[Vec3, Vec3]] = None  # free-mode home (eye, look)
+
+    def default_chase(self) -> Tuple[float, float, float]:
+        s = self.settings
+        return chase_perspective(s.chase_back_m, s.chase_up_m, s.chase_look_up_m)
+
+    # stage ----------------------------------------------------------------------
+    @property
+    def stage(self) -> Usd.Stage | None:
+        return self._ctx.get_stage()
+
+    def refresh_frame(self) -> UpFrame:
+        stage = self.stage
+        if stage is not None:
+            self.frame = UpFrame(
+                str(UsdGeom.GetStageUpAxis(stage)),
+                UsdGeom.GetStageMetersPerUnit(stage),
+                self.settings.body_forward,
+            )
+        return self.frame
+
+    def reset_stage(self) -> None:
+        """Call after a stage opens: drops cached ops and returns to free mode."""
+        self._op = None
+        self.mode = "free"
+        self.native.reset()
+        self.refresh_frame()
+        self.native.set_native(True, self.stage, self.camera_path)
+
+    def _prim(self):
+        stage = self.stage
+        return stage.GetPrimAtPath(self.camera_path) if stage else None
+
+    def eye(self) -> Vec3 | None:
+        prim = self._prim()
+        if not prim or not prim.IsValid():
+            return None
+        t = UsdGeom.Xformable(prim).ComputeLocalToWorldTransform(Usd.TimeCode.Default()).ExtractTranslation()
+        return (t[0], t[1], t[2])
+
+    # modes ----------------------------------------------------------------------
+    @property
+    def attached(self) -> bool:
+        return self.mode != "free"
+
+    def set_mode(self, mode: str) -> str:
+        if mode not in MODES:
+            raise ValueError(f"mode must be one of {MODES}, not {mode!r}")
+        if mode == self.mode:
+            return self.mode
+        stage = self.stage
+        if mode != "free":
+            prim = self._prim()
+            if not prim or not prim.IsValid():
+                carb.log_warn(f"[{self.name}] no camera at {self.camera_path}; staying in {self.mode}")
+                return self.mode
+            if self.targets.ensure(near=self.eye()) is None:
+                carb.log_warn(f"[{self.name}] no target to attach to; staying in {self.mode}")
+                return self.mode
+            self.refresh_frame()
+            if self.mode == "free":
+                self._prepare_op(prim)
+                self._activate_camera()
+            self.view = mode
+            self._enter(mode, self.mode)
+        self.mode = mode
+        self.native.set_native(mode == "free", stage, self.camera_path)
+        carb.log_info(f"[{self.name}] camera mode {mode} (target {self.targets.selected})")
+        return self.mode
+
+    def step_target(self, direction: int):
+        return self.targets.step(direction)
+
+    def _pivot(self, target: Sequence[float]) -> Vec3:
+        """Chase and orbit both turn around this point above the target, so switching
+        between them does not move the camera."""
+        f = self.frame
+        return add(target, scale(f.up, f.to_units(self.settings.chase_look_up_m)))
+
+    def _enter(self, mode: str, prev: str) -> None:
+        s = self.settings
+        pose = self.targets.pose()
+        if pose is None:
+            return
+        # Keep the smoothed target and heading when moving between attached views
+        if prev == "free" or self._target.value is None:
+            self._target.snap(pose.position)
+            h = self.frame.heading(pose.orientation)
+            self._last_heading = h if h is not None else self._last_heading
+            self._heading.snap(self._last_heading)
+        self._target.tau = s.orbit_tau_target_s if mode == "orbit" else s.chase_tau_target_s
+        heading = self._heading.value if self._heading.value is not None else self._last_heading
+        # Chase and orbit share one vantage (angle from the heading, elevation, range).
+        # Point of view is a fixed seat on the target and never changes it, so chase, pov,
+        # orbit returns to the chase vantage instead of orbiting from the seat's eye (which
+        # started the orbit a few meters out, 2026-11-08).
+        if prev == "orbit" and mode in ("chase", "pov"):
+            # keep the perspective set in orbit, now turning with the target's heading
+            self.chase_yaw_rel = wrap_angle(self.orbit_yaw - heading)
+            self.chase_elevation = self.orbit_elevation
+            self.chase_range_m = self.orbit_range_m
+        if mode == "orbit":
+            if prev in ("chase", "pov"):
+                # start the orbit at the chase vantage
+                self.orbit_yaw = heading + self.chase_yaw_rel
+                self._set_elevation(self.chase_elevation)
+                self._set_range_m(self.chase_range_m)
+            else:
+                eye = self.eye()
+                if eye is not None:
+                    yaw, elev, dist = orbit_from_eye(self._pivot(self._target.value), eye, self.frame)
+                    self.orbit_yaw = yaw
+                    self._set_elevation(elev)
+                    self._set_range_m(dist * self.frame.meters_per_unit)
+
+    def home(self) -> None:
+        """Attached: back to the default chase perspective (behind the target), in chase
+        and in orbit. Free: the saved home view, if any."""
+        if not self.attached:
+            if self.home_view is not None:
+                self.place(*self.home_view)
+            return
+        self.chase_yaw_rel, self.chase_elevation, self.chase_range_m = self.default_chase()
+        heading = self._heading.value if self._heading.value is not None else self._last_heading
+        self.orbit_yaw = heading + self.chase_yaw_rel
+        self._set_elevation(self.chase_elevation)
+        self._set_range_m(self.chase_range_m)
+
+    # orbit input ------------------------------------------------------------------
+    def _set_elevation(self, e: float) -> None:
+        lo = math.radians(self.settings.orbit_min_elevation_deg)
+        hi = math.radians(self.settings.orbit_max_elevation_deg)
+        self.orbit_elevation = max(lo, min(hi, e))
+
+    def _set_range_m(self, r: float) -> None:
+        self.orbit_range_m = max(self.settings.orbit_min_m, min(self.settings.orbit_max_m, r))
+
+    def orbit_by(self, d_yaw: float = 0.0, d_elevation: float = 0.0, range_factor: float = 1.0) -> None:
+        self.orbit_yaw += d_yaw
+        self._set_elevation(self.orbit_elevation + d_elevation)
+        self._set_range_m(self.orbit_range_m * range_factor)
+
+    # per frame --------------------------------------------------------------------
+    def update(self, dt: float) -> bool:
+        """Advance one frame; returns True when the camera was written."""
+        if not self.attached:
+            return False
+        pose = self.targets.pose()
+        if pose is None:
+            return False
+        f = self.frame
+        s = self.settings
+        h = f.heading(pose.orientation)
+        if h is not None:
+            self._last_heading = h
+        target = self._target.update(pose.position, dt)
+        heading = self._heading.update(self._last_heading, dt)
+        if self.mode == "chase":
+            eye, look, up = chase_orbit_view(
+                target,
+                heading,
+                self.chase_yaw_rel,
+                self.chase_elevation,
+                f.to_units(self.chase_range_m),
+                f.to_units(s.chase_look_up_m),
+                f,
+            )
+        elif self.mode == "pov":
+            eye, look, up = pov_view(
+                pose.position,
+                pose.orientation,
+                f.to_units(s.pov_forward_m),
+                f.to_units(s.pov_up_m),
+                f.to_units(s.pov_right_m),
+                f,
+            )
+        else:  # orbit
+            look, up = self._pivot(target), f.up
+            eye = orbit_eye(look, self.orbit_yaw, self.orbit_elevation, f.to_units(self.orbit_range_m), f)
+        return self._write(look_at_matrix(eye, look, up))
+
+    def place(self, eye: Sequence[float], look: Sequence[float]) -> bool:
+        """Put the camera at eye looking at look (stage units), in any mode."""
+        prim = self._prim()
+        if not prim or not prim.IsValid():
+            return False
+        if self._op is None or not self._op_valid(prim):
+            self._prepare_op(prim)
+        return self._write(look_at_matrix(eye, look, self.refresh_frame().up))
+
+    # USD ----------------------------------------------------------------------------
+    def _activate_camera(self) -> None:
+        try:
+            from omni.kit.viewport.utility import get_active_viewport
+
+            vp = get_active_viewport()
+            if vp is not None and str(vp.camera_path) != self.camera_path:
+                vp.camera_path = self.camera_path
+        except Exception as e:
+            carb.log_warn(f"[{self.name}] could not switch the viewport camera: {e}")
+
+    def _op_valid(self, prim) -> bool:
+        ops = UsdGeom.Xformable(prim).GetOrderedXformOps()
+        return len(ops) == 1 and ops[0].GetOpType() == UsdGeom.XformOp.TypeTransform
+
+    def _prepare_op(self, prim) -> None:
+        """One xformOp:transform holding the camera's current local transform, so taking
+        over the camera does not move it."""
+        xf = UsdGeom.Xformable(prim)
+        local = xf.GetLocalTransformation(Usd.TimeCode.Default())
+        if self._op_valid(prim):
+            self._op = xf.GetOrderedXformOps()[0]
+            return
+        xf.ClearXformOpOrder()
+        self._op = xf.AddTransformOp()
+        self._op.Set(local)
+
+    def _write(self, rows) -> bool:
+        prim = self._prim()
+        if not prim or not prim.IsValid():
+            return False
+        if self._op is None or not self._op.GetAttr().IsValid():
+            self._prepare_op(prim)
+        world = Gf.Matrix4d(*[c for row in rows for c in row])
+        parent = prim.GetParent()
+        if parent and parent.IsValid() and not parent.IsPseudoRoot():
+            pw = UsdGeom.Xformable(parent).ComputeLocalToWorldTransform(Usd.TimeCode.Default())
+            world = world * pw.GetInverse()
+        self._op.Set(world)
+        return True
+
+    def status(self) -> dict:
+        return {
+            "mode": self.mode,
+            "view": self.view,
+            "target": self.targets.selected,
+            "camera": self.camera_path,
+            "up_axis": self.frame.axis,
+            "meters_per_unit": self.frame.meters_per_unit,
+            "eye": self.eye(),
+            "orbit": {
+                "yaw_deg": math.degrees(self.orbit_yaw),
+                "elevation_deg": math.degrees(self.orbit_elevation),
+                "range_m": self.orbit_range_m,
+            },
+            "chase": {
+                "yaw_rel_deg": math.degrees(self.chase_yaw_rel),
+                "elevation_deg": math.degrees(self.chase_elevation),
+                "range_m": self.chase_range_m,
+            },
+        }
+
+    def dispose(self) -> None:
+        self.native.dispose(self.stage, self.camera_path)
+        self._op = None
+        self.mode = "free"

vantagekit-0.6.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: vantagekit
+Version: 0.6.1
+Summary: Camera and input controls for viewers of terrain, ocean and vessel scenes: orbit, chase and point-of-view camera math, frame-rate independent smoothing, and bindings as data, with Omniverse Kit adapters.
+Project-URL: Demo, https://lhzn-io.github.io/vantagekit/demo/
+Project-URL: Issues, https://github.com/lhzn-io/vantagekit/issues
+Project-URL: Source, https://github.com/lhzn-io/vantagekit
+Author-email: Long Horizon Observatory <dfry@lhzn.io>
+License: MIT License
+        
+        Copyright (c) 2026 Long Horizon Observatory
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: camera,gamepad,input,navigation,omniverse,viewer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# vantagekit (Python)
+
+Camera and input controls for viewers of terrain, ocean and vessel scenes. This package is the
+Python half of [vantagekit](https://github.com/lhzn-io/vantagekit), whose JavaScript modules give
+three.js and MapLibre GL JS viewers the same navigation in the browser
+([live demo](https://lhzn-io.github.io/vantagekit/demo/)).
+
+```bash
+pip install vantagekit
+```
+
+## vantagekit.core
+
+Standard library only, so it runs anywhere Python 3.10 or later does: in tests, in tools, or in a
+viewer built on any renderer.
+
+- **Stage frames** for Y-up and Z-up scenes in any unit (`UpFrame`), with headings and yaw from
+  orientations.
+- **Camera math** for orbit, chase and point-of-view cameras around a moving target (`orbit_eye`,
+  `look_at_matrix`). Every distance is in metres and every time constant in seconds.
+- **Smoothing** that does not depend on frame rate (`Smoothed3`, `SmoothedAngle`, `exp_alpha`):
+  the filter is solved exactly for a target moving steadily between frames, so the lag behind a
+  moving target is its speed times the time constant at any frame time.
+- **Bindings as data** (`Binding`, `DEFAULT_BINDINGS`): press, hold, axis and delta kinds, exact
+  modifiers, and ordered layers, so an app layer can take the sticks from the camera while it is on.
+- **Target selection** (`CallbackTargets`, `Pose`).
+
+```python
+from vantagekit.core import SmoothedAngle, UpFrame, orbit_eye
+```
+
+## vantagekit.kit
+
+Adapters for Omniverse Kit 109 and 110 (Isaac Sim 6): a camera rig with free, chase,
+point-of-view and orbit modes, a handover to Kit's own navigation, a keyboard, mouse and gamepad
+input router, and a view badge. These import `carb` and `omni` and so work only inside Kit. A Kit
+app usually loads them as the `lhzn.vantagekit` extension from the repository's `kit/exts` folder;
+see the [main README](https://github.com/lhzn-io/vantagekit#omniverse-kit).
+
+## Versions
+
+The package version follows the repository's release tags, so `vantagekit==0.6.1` matches the
+JavaScript modules served from `@v0.6.1`. MIT licence, Long Horizon Observatory.

vantagekit-0.6.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+vantagekit/__init__.py,sha256=Dxr_68qGe3KmAbZyw2XycRuhhk6KdZ-uQ6JDhCptMfQ,224
+vantagekit/core/__init__.py,sha256=BRDw-oV58f_ug6BPyA7awTfvVXu2HLzamYe7PrONNis,885
+vantagekit/core/bindings.py,sha256=ieEvbEFXcajBeG61-mFr-raM7bgJ2cghJrh25giO3W4,9165
+vantagekit/core/frame.py,sha256=TJ7tPOGebaKWNBMPxz-rXQA-Z-UHaQ5t61uNNcu0PWM,3925
+vantagekit/core/rig_math.py,sha256=rB5h99daqe6jTfgLkblgLMGsUtSKYBoyeDeTxV8f6_0,4378
+vantagekit/core/smoothing.py,sha256=sX49eI6icS3y5B8cByMp16U5__lSUKzYyQa7gGUbres,4552
+vantagekit/core/targets.py,sha256=0K5JYo0yMjpWXkKQYwpVwSi_Ywp4CuD5x1rFblPlSGM,3009
+vantagekit/kit/__init__.py,sha256=MQe8Uv4lOmCBoyJLkD1Js37_P5ZmalQqN8EKjsM4tcU,569
+vantagekit/kit/controls.py,sha256=D4NUVa5xPpog9Q78WSf8Phin1zzzDcveD9C076mZRrQ,8164
+vantagekit/kit/events.py,sha256=VB1nsbFU6qYf1AkpiKgtKySURO9ZuLgHK2sEhkq9X8s,1797
+vantagekit/kit/input.py,sha256=RYRpOGo2uq46BASsA__SIagn9ngEInm4rI-kIIRZ7Z0,6584
+vantagekit/kit/native_nav.py,sha256=oOHn2ZD8_1oIToBPsE36tHO3pg8aHtCOiuZDKmzGgF4,3542
+vantagekit/kit/overlay.py,sha256=-byQznozLt6SS_tn-FF5qFz5hx2YjNZhiQhkFTdH9ao,4132
+vantagekit/kit/rig.py,sha256=t-khZBK9eoUTffi8hhzg0xv4Z6pjvWYLU6hUCe8eLOw,14376
+vantagekit-0.6.1.dist-info/METADATA,sha256=liTqVJCX-gF4Rf7d4-NOwYsAMvSK-59sNk9XQZVemWg,4344
+vantagekit-0.6.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+vantagekit-0.6.1.dist-info/licenses/LICENSE,sha256=VqXVp0x0MUmTZo0dT3YluvQiXyrUVAIhd5gEv_BdA28,1081
+vantagekit-0.6.1.dist-info/RECORD,,

vantagekit-0.6.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vantagekit-0.6.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Long Horizon Observatory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.