antioch-py 2.2.4__py3-none-any.whl → 3.0.1__py3-none-any.whl

antioch/session/session.py

@@ -1,211 +0,0 @@
-import os
-import time
-from typing import Any, overload
-
-from antioch.session.error import (
-    SessionSimRpcClientError,
-    SessionSimRpcInternalError,
-    SessionSimRpcInterruptedError,
-    SessionSimRpcNotConnectedError,
-)
-from common.core.auth import AuthHandler
-from common.message import Message
-from common.session.sim import RpcCall, RpcResponse, SimulationInfo
-from common.utils.comms import CommsSession
-
-
-class SessionContainer:
-    """
-    Base class for all session containers.
-
-    Provides common functionality for accessing the session client. Session containers
-    include Scene, Ark, and SessionContainer subclasses. This base class only manages the
-    session connection - path management is delegated to SessionContainer subclasses.
-    """
-
-    def __init__(self):
-        """
-        Initialize the session container.
-        """
-
-        self._session = Session.get_current()
-
-    @property
-    def connected(self) -> bool:
-        """
-        Check if the session is connected to the Sim RPC server.
-
-        :return: True if connected, False otherwise.
-        """
-
-        return self._session.connected
-
-
-class Session:
-    """
-    Singleton client for interacting with the Sim RPC server.
-
-    Uses a lazy singleton pattern - the first call to get_current() creates the instance,
-    and all subsequent calls return the same instance.
-
-    Example:
-        session = Session.get_current()
-        result = session.query_sim_rpc("get_state")
-    """
-
-    _current: "Session | None" = None
-
-    def __init__(self, timeout: float = 10.0, debug: bool = False):
-        """
-        Initialize the session client.
-
-        :param timeout: Default timeout for Sim RPC calls in seconds.
-        :param debug: Whether to enable debug mode.
-        """
-
-        self._comms = CommsSession()
-        self._timeout = timeout
-        self._debug = debug or os.environ.get("ANTIOCH_RPC_PROFILE", "0") == "1"
-        Session._current = self
-
-    def __del__(self):
-        """
-        Close the client connection.
-        """
-
-        self._comms.close()
-
-    @classmethod
-    def get_current(cls) -> "Session":
-        """
-        Get the current session client, creating it if it doesn't exist (lazy singleton).
-
-        :return: The current session client.
-        """
-
-        if cls._current is None:
-            cls._current = Session()
-        return cls._current
-
-    @property
-    def connected(self) -> bool:
-        """
-        Check if the simulation RPC server is reachable.
-
-        :return: True if connected, False otherwise.
-        """
-
-        try:
-            self.query_sim_rpc("get_info", response_type=SimulationInfo, timeout=1.0)
-            return True
-        except Exception:
-            return False
-
-    @property
-    def comms(self) -> CommsSession:
-        """
-        Get the comms session.
-
-        :return: The comms session.
-        """
-
-        return self._comms
-
-    @property
-    def authenticated(self) -> bool:
-        """
-        Check if user is authenticated.
-
-        :return: True if a valid access token exists, False otherwise.
-        """
-
-        return AuthHandler().get_token() is not None
-
-    def login(self) -> None:
-        """
-        Authenticate user and cache access token.
-
-        Initiates OAuth2 device code flow, prompting user to visit a URL and enter a code.
-        The access token is cached locally for subsequent requests.
-
-        :raises AuthError: If authentication fails.
-        """
-
-        AuthHandler().login()
-
-    @overload
-    def query_sim_rpc(
-        self,
-        endpoint: str,
-        payload: dict[str, Any] | None = None,
-        *,
-        timeout: float = 60.0,
-    ) -> Any | None: ...
-
-    @overload
-    def query_sim_rpc[T](
-        self,
-        endpoint: str,
-        payload: dict[str, Any] | None = None,
-        *,
-        response_type: type[T],
-        timeout: float = 60.0,
-    ) -> T: ...
-
-    def query_sim_rpc[T](
-        self,
-        endpoint: str,
-        payload: dict[str, Any] | None = None,
-        *,
-        response_type: type[T] | None = None,
-        timeout: float = 60.0,
-    ) -> T | Any | None:
-        """
-        Execute a sim RPC query.
-
-        :param endpoint: The sim RPC endpoint.
-        :param payload: Optional request payload dict.
-        :param response_type: Expected response type (Message subclass or primitive like int, str, bool).
-        :param timeout: Query timeout in seconds.
-        :return: Response as typed object, arbitrary data, or None.
-        :raises SessionSimRpcNotConnectedError: If the Sim RPC server is not reachable.
-        :raises SessionSimRpcClientError: If the Sim RPC server returns a client error.
-        :raises SessionSimRpcInternalError: If the Sim RPC server returns an internal error.
-        """
-
-        try:
-            start_time = time.perf_counter() if self._debug else 0
-            response = self._comms.query(
-                path=f"_sim/rpc/{endpoint}",
-                response_type=RpcResponse,
-                request=RpcCall(data=payload),
-                timeout=timeout or self._timeout,
-            )
-
-            # Check for errors in RPC response
-            if response.error is not None:
-                if response.error.internal:
-                    raise SessionSimRpcInternalError(message=response.error.message, traceback=response.error.traceback)
-                else:
-                    raise SessionSimRpcClientError(response.error.message)
-
-            # Print elapsed time in debug mode
-            if self._debug:
-                elapsed_ms = (time.perf_counter() - start_time) * 1000
-                print(f"[SIM-RPC] {endpoint}: {elapsed_ms:.1f}ms", flush=True)
-
-            # Return response data or None if no data
-            if response.data is None:
-                return None
-            if response_type is not None:
-                if issubclass(response_type, Message):
-                    return response_type.model_validate(response.data)
-                return response.data
-            return response.data
-
-        except TimeoutError as e:
-            if not self.connected:
-                raise SessionSimRpcNotConnectedError("Sim RPC server is not connected") from e
-            raise
-        except KeyboardInterrupt as e:
-            raise SessionSimRpcInterruptedError("Sim RPC interrupted") from e

antioch/session/task.py

@@ -1,309 +0,0 @@
-import json
-import tarfile
-import tempfile
-from datetime import datetime, timezone
-from pathlib import Path
-
-from antioch.session.error import SessionTaskError
-from antioch.session.scene import Scene
-from antioch.session.session import SessionContainer
-from common.constants import ANTIOCH_API_URL
-from common.core import Agent, AuthHandler
-from common.core.task import TaskOutcome
-from common.rome import RomeClient
-from common.utils.logger import Logger
-
-
-class Task(SessionContainer):
-    """
-    Singleton for task management and telemetry recording.
-
-    Uses a lazy singleton pattern - the first instantiation or call to get_current()
-    creates the instance, and all subsequent calls return the same instance.
-
-    Provides logging with simulation time context and telemetry recording.
-    A task represents a single simulation run with defined outcomes.
-    Telemetry is always streamed to WebSocket on port 8765 when started.
-
-    Example:
-        scene = Scene()
-        task = Task()  # or Task.get_current()
-
-        # Start task (streams to WebSocket on port 8765)
-        task.start()
-
-        # Or start task with MCAP recording
-        task.start(mcap_path="/tmp/task_telemetry.mcap")
-
-        # Run simulation
-        scene.step(dt=0.01)
-
-        # Log telemetry with sim time (automatically recorded when started)
-        task.logger.telemetry("velocity", VelocityMessage(...))
-
-        # Finish task with outcome (finalizes telemetry and uploads to cloud)
-        task.finish(TaskOutcome.SUCCESS)
-
-        # Or finish without uploading MCAP
-        task.finish(TaskOutcome.SUCCESS, upload_mcap=False)
-    """
-
-    _current: "Task | None" = None
-
-    def __init__(self):
-        """
-        Initialize the task.
-        """
-
-        super().__init__()
-        self._agent = Agent()
-        self._scene = Scene()
-
-        self._logger: Logger | None = None
-        self._started = False
-        self._mcap_path: str | None = None
-
-        # Task metadata for cloud storage
-        self._ark_name: str | None = None
-        self._ark_version: str | None = None
-        self._ark_hash: str | None = None
-        self._task_start_time: datetime | None = None
-
-        Task._current = self
-
-    @property
-    def logger(self) -> Logger:
-        """
-        Get the logger with current simulation time.
-
-        Sets the logger's logical execution time to match the current
-        simulation time before returning. We lazy load the scene to avoid
-        circular dependencies.
-
-        :return: The task logger.
-        :raises SessionTaskError: If task has not been started.
-        """
-
-        if self._logger is None:
-            raise SessionTaskError("Task not started")
-
-        self._logger.set_let(self._scene.time_us)
-        return self._logger
-
-    @classmethod
-    def get_current(cls) -> "Task":
-        """
-        Get the current task, creating it if it doesn't exist (lazy singleton).
-
-        :return: The current task.
-        """
-
-        if cls._current is None:
-            cls._current = Task()
-        return cls._current
-
-    @property
-    def started(self) -> bool:
-        """
-        Check if the task is currently started.
-
-        :return: True if task is started, False otherwise.
-        """
-
-        return self._started
-
-    def start(self, mcap_path: str | None = None) -> None:
-        """
-        Start the task and begin streaming telemetry to WebSocket (always active on port 8765).
-        Optionally records telemetry to an MCAP file.
-
-        This operation is idempotent - calling it multiple times will finish the previous
-        task and start a new one.
-
-        :param mcap_path: Optional path to save MCAP telemetry file (defaults to None for no MCAP recording).
-        :raises SessionTaskError: If no Ark is loaded in the scene or if user is not authenticated.
-        """
-
-        if self._started:
-            print("Task already started. Finish or clear the task before starting a new one")
-            return
-
-        # Check that an Ark is loaded
-        if self._scene.ark is None:
-            raise SessionTaskError("No Ark loaded. Please load an Ark before starting a task")
-
-        # Get auth token
-        auth = AuthHandler()
-        token = auth.get_token()
-        if not token:
-            raise SessionTaskError("User not authenticated. Please login first")
-
-        # Store task metadata
-        self._ark_name = self._scene.ark.definition.name
-        self._ark_version = self._scene.ark.definition.info.version
-        self._ark_hash = self._scene.ark.definition.metadata.digest
-        self._task_start_time = datetime.now(timezone.utc)
-
-        # Start recording telemetry
-        self._agent.record_telemetry(mcap_path)
-
-        # Update task state
-        self._logger = Logger(self._session.comms, base_channel="task", print_logs=True)
-        self._started = True
-        self._mcap_path = mcap_path
-
-    def finish(
-        self,
-        outcome: TaskOutcome,
-        result: dict | None = None,
-        bundle_paths: list[Path] | None = None,
-        upload_mcap: bool = True,
-        show_progress: bool = True,
-    ) -> None:
-        """
-        Finish the task with the specified outcome and optionally upload results to cloud storage.
-
-        Resets telemetry session (finalizes MCAP file if one was created and resets time tracking).
-        The WebSocket server remains active.
-
-        If result and/or bundle_paths are provided, uploads them to Antioch for cloud storage.
-
-        :param outcome: The task outcome (defaults to SUCCESS).
-        :param result: Optional dictionary of task results (must be JSON-serializable).
-        :param bundle_paths: Optional list of file paths to bundle and upload to cloud storage.
-        :param upload_mcap: Upload MCAP file to cloud storage if one was recorded (defaults to True).
-        :param show_progress: Show upload progress bars (defaults to True).
-        :raises SessionTaskError: If task not started or if result is not JSON-serializable.
-        """
-
-        if not self._started:
-            raise SessionTaskError("Task not started")
-
-        # Validate result is JSON-serializable if provided
-        if result is not None:
-            try:
-                json.dumps(result)
-            except (TypeError, ValueError) as e:
-                raise SessionTaskError(f"Task result must be JSON-serializable: {e}") from e
-
-        # Validate bundle paths exist and are accessible
-        bundle_tar_path = None
-        if bundle_paths is not None and len(bundle_paths) > 0:
-            for path in bundle_paths:
-                if not Path(path).exists():
-                    raise SessionTaskError(f"Bundle path does not exist: {path}")
-                if not Path(path).is_file():
-                    raise SessionTaskError(f"Bundle path is not a file: {path}")
-
-            # Create tar.gz bundle
-            try:
-                bundle_tar_path = self._create_bundle(bundle_paths)
-            except Exception as e:
-                raise SessionTaskError(f"Failed to create bundle: {e}") from e
-
-        # Save the MCAP file to disk (does not reset websocket session)
-        self._agent.save_telemetry()
-
-        # Upload task to Antioch Cloud
-        try:
-            task_complete_time = datetime.now(timezone.utc)
-            self._upload_task_to_antioch(outcome, result, bundle_tar_path, task_complete_time, upload_mcap, show_progress)
-        except Exception as e:
-            raise SessionTaskError(f"Failed to upload task to Antioch Cloud: {e}") from e
-
-        # Clean up temp bundle file
-        if bundle_tar_path and Path(bundle_tar_path).exists():
-            Path(bundle_tar_path).unlink()
-
-        # Reset task state
-        self._logger = None
-        self._started = False
-        self._mcap_path = None
-        self._ark_name = None
-        self._ark_version = None
-        self._ark_hash = None
-        self._task_start_time = None
-
-    def _create_bundle(self, bundle_paths: list[Path]) -> str:
-        """
-        Create a tar.gz archive from the provided file paths.
-
-        :param bundle_paths: List of file paths to include in the bundle.
-        :return: Path to the created tar.gz file.
-        """
-
-        # Create temp file for the bundle
-        with tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False) as temp_file:
-            temp_path = temp_file.name
-        with tarfile.open(temp_path, "w:gz") as tar:
-            for path in bundle_paths:
-                tar.add(str(path), arcname=Path(path).name)
-
-        return temp_path
-
-    def _upload_task_to_antioch(
-        self,
-        outcome: TaskOutcome,
-        result: dict | None,
-        bundle_tar_path: str | None,
-        task_complete_time: datetime,
-        upload_mcap: bool,
-        show_progress: bool,
-    ) -> None:
-        """
-        Upload task completion data to Antioch Cloud.
-
-        :param outcome: The task outcome.
-        :param result: Optional task result dictionary.
-        :param bundle_tar_path: Optional path to bundle tar.gz file.
-        :param task_complete_time: ISO 8601 timestamp of task completion.
-        :param upload_mcap: Upload MCAP file if one was recorded.
-        :param show_progress: Show upload progress bars.
-        :raises SessionTaskError: If upload operations fail.
-        """
-
-        # Get auth token
-        token = AuthHandler().get_token()
-        if token is None:
-            raise SessionTaskError("User not authenticated. Please login first")
-
-        # Create Rome client
-        rome_client = RomeClient(api_url=ANTIOCH_API_URL, token=token)
-
-        # Assert all required fields are set (should never be None at this point)
-        assert self._ark_name is not None, "Ark name should be set"
-        assert self._ark_version is not None, "Ark version should be set"
-        assert self._ark_hash is not None, "Ark hash should be set"
-        assert self._task_start_time is not None, "Task start time should be set"
-
-        # Complete the task (creates ES entry)
-        try:
-            task_id = rome_client.complete_task(
-                ark_name=self._ark_name,
-                ark_version=self._ark_version,
-                ark_hash=self._ark_hash,
-                task_start_time=self._task_start_time,
-                task_complete_time=task_complete_time,
-                outcome=outcome,
-                result=result,
-            )
-        except Exception as e:
-            raise SessionTaskError(f"Failed to complete task in Antioch: {e}") from e
-
-        # Upload MCAP if it exists and upload_mcap is True
-        if upload_mcap and self._mcap_path:
-            if not Path(self._mcap_path).exists():
-                raise SessionTaskError(f"MCAP file does not exist, or is inaccessible: {self._mcap_path}")
-            try:
-                rome_client.upload_mcap(task_id=task_id, mcap_path=self._mcap_path, show_progress=show_progress)
-            except Exception as e:
-                raise SessionTaskError(f"Failed to upload MCAP to Antioch: {e}") from e
-
-        # Upload bundle if it exists
-        if bundle_tar_path:
-            if not Path(bundle_tar_path).exists():
-                raise SessionTaskError(f"Bundle file does not exist, or is inaccessible: {bundle_tar_path}")
-            try:
-                rome_client.upload_bundle(task_id=task_id, bundle_path=bundle_tar_path, show_progress=show_progress)
-            except Exception as e:
-                raise SessionTaskError(f"Failed to upload bundle to Antioch: {e}") from e

antioch_py-2.2.4.dist-info/RECORD

@@ -1,85 +0,0 @@
-antioch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-antioch/message.py,sha256=7YsmUA6H3Imikv6beUJilTpA8Nb5DCkeOwbRQwOLfGI,1463
-antioch/module/__init__.py,sha256=nSbYXkicwbypnfyko2cN2JwvIzSntfVEYyP63VVPaGU,1008
-antioch/module/clock.py,sha256=54NpvlbkFLtmiLGMXADGCkYbooUaKsDGN-xjjDqq7mw,2026
-antioch/module/execution.py,sha256=bASbLFz3YqP7Ma5Pbga6W7ddNCQo3GzbjAlgrQXYWSw,7995
-antioch/module/input.py,sha256=BGbJ6AOgm7gVTO6PBYs8B53q0v_YD3Jy2joM5M7kUlk,4317
-antioch/module/module.py,sha256=6b9s_N1Tpr4Wtp8hXVxZHDzhfKgG2IHeOd8KE65TfMk,7581
-antioch/module/node.py,sha256=1EDNzKbQINs4nKZiSdn_FEPg-3MyCKdC0b7pfucmLgk,14542
-antioch/module/token.py,sha256=6KJbPMoaMqUrx8nfYzAgVTf8EaazT46g6KMC1zO97Pk,830
-antioch/session/__init__.py,sha256=-TtFaO3SCjIjBvh29Dso54qlfqnfdUbUN_p8tW5i220,3526
-antioch/session/ark.py,sha256=r8hpCM8wymtgIX1mcvGofQR6mZOdn9UCsnFAtnnpvto,18814
-antioch/session/asset.py,sha256=G4wKHVxDkzLEtUap7b7jDF6Y_I4gdHiJ-b756QFBx54,2222
-antioch/session/error.py,sha256=hEByLcsS8PPpK46prnz1GSWBx0ErGTnSkwBd29FUmWg,1685
-antioch/session/record.py,sha256=acNeikDeWJFZLovgwbXGHTriqi5-szYjjrnt9s_cdUY,5527
-antioch/session/scene.py,sha256=srg2F8PH4tOx9f2an2Q9TULyDtGPcBpBC3Gm6gMzjo8,60036
-antioch/session/session.py,sha256=K25RZZ8HYMUpyeDoCzzWh-YLs1DcjBlrzxN2SvbtZ4E,6348
-antioch/session/task.py,sha256=OBGFAD-oWRjkQUAElO9bXhJ_SI-j7S6TxKpUmCgN1-M,11484
-antioch/session/objects/__init__.py,sha256=n7EYDfneWwro1OaXphbWGyasZ0tvAAAGe72PcUmTF_Y,1184
-antioch/session/objects/animation.py,sha256=FIgYsHG9TWcdi5aG3ycGorJv-nJBFkiHArDWXLEx8bY,5427
-antioch/session/objects/articulation.py,sha256=bSAvi6ZOAGOPTsXEtt8fGAG3VF8UR8TxSL0L1izGtbQ,6644
-antioch/session/objects/basis_curve.py,sha256=I5x5CklyDeg7m3907Gs9vDa4PP9mjnMPZutjg7Vc8Kg,5918
-antioch/session/objects/camera.py,sha256=clFfSKKlvMlh8x_OZb7AmHrqmWxO9sI760_LGvIBwBM,2252
-antioch/session/objects/collision.py,sha256=ZGAINF7p3MbCoTwvx4Pzicc8dIfbJgjBgUn_TC_hrT0,1479
-antioch/session/objects/geometry.py,sha256=MuC6qnHCVGnxYGovHU8U2G-tRGbINoL273t3yYQAPCE,1954
-antioch/session/objects/ground_plane.py,sha256=o82nW9Ndhw-AiwiSKUrr1IhspFmdah7BYOTc1EUVEeg,1460
-antioch/session/objects/imu.py,sha256=vx59MutAg1HOEvZESqOmxlQocrnXEW1B5rqD7LBzLwM,1602
-antioch/session/objects/joint.py,sha256=_mqXq1IDvzQ9FnvCpKXGa0YNh8f9zCtmskC8UP4QgNI,1476
-antioch/session/objects/light.py,sha256=Sl0zPIiCnocCCLUaaJaiDLbHVhAJ-ZnIr9IOueIrc_g,3831
-antioch/session/objects/pir_sensor.py,sha256=gAHZRmuQXSsOdTKiEFDnBxOwGnOJ-IctfbU0DuUV7vU,3514
-antioch/session/objects/radar.py,sha256=BXl8OzngiY_urBRBB7kAlBHvtpR9aosWv7nuYcKSeWo,1930
-antioch/session/objects/rigid_body.py,sha256=TuJ04vG0eyzg4lFAVp7ZE0YTzOjhlcqLoNaeW2sZM0E,6294
-antioch/session/objects/xform.py,sha256=VkSDIfFEuutrDVuKO2F5sI4zKsGa0xZzxFeH-tRMjp0,3237
-common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-common/constants.py,sha256=0jsX0pWUklL9UNLK4_rzGuo53qFWZX1_PIw9j2aKDnU,1652
-common/ark/__init__.py,sha256=Lu2lJ5k7-vN6ZGeX2sYhRwzXEyt9kCyXtgsyvdIaCiU,1472
-common/ark/ark.py,sha256=RqD8fmSPK_cjnaUOsscAj9406BsMXVCEynu_RtGa6qk,2444
-common/ark/hardware.py,sha256=5AH9jkrjIvVK6JBfWM7Okpqm9Iqbs7gtyxktlzBS4oI,2252
-common/ark/kinematics.py,sha256=BCPQKmQ5vWlZBCie861TIImmR3X5BniiuGRPoIvByDM,748
-common/ark/module.py,sha256=IwkoirFb4dZkfVpn3tjgChRy5S6hVPbrtR9XgJ5UIBI,1922
-common/ark/node.py,sha256=PWESl7sDdY_Q6aA3CZMRTQ0SONlO9LkUmXhRbUhT8_g,2303
-common/ark/scheduler.py,sha256=QGO_-ZewCvOHJ-w9BAJJQdco0-b-mbbzufpSX9b-mNo,15703
-common/ark/sim.py,sha256=SQtZkf97QF91oLWkTUEhq62GYL3yk7-LLDDR-lXVKcA,900
-common/assets/__init__.py,sha256=We71LsStYI5-hknGd2XHrvHg8G4k1dity887BnI5oPI,102
-common/core/__init__.py,sha256=L8rvLHQd-mOCfDQ2WN9BZiMqU0skeTTkeQvpJ59ouqI,1110
-common/core/agent.py,sha256=EBNSTuxCOUM66UV7e1LA1aQLyYgIsRjFZXWqbbp-lR0,8613
-common/core/auth.py,sha256=ihMnlhyDWJ73VhxqSulLTPxgorDK76WT7Mx97RCAhLY,9244
-common/core/registry.py,sha256=J2Ihhgr6aTfovm-zSiGEcyHB8iBcpFcZVw6vVYKFjNg,11399
-common/core/task.py,sha256=eybV7yQ8nPYgQtYuse-QvoMJ87Msh6rAN_LUOTGmN94,629
-common/message/__init__.py,sha256=JHTTMFuMYUF9jspydMihfz2dK9-Mp37zWOTMZBUwK5g,1802
-common/message/annotation.py,sha256=BlzDYhioAK1ATFfgZozmaF7uOqFdSr7KBhe2m03Z2q4,1911
-common/message/array.py,sha256=Fly7u8BE-_QRwnkmv3k6P2EI0FguEUIzF_tE-mFGT1Q,13971
-common/message/base.py,sha256=kdBEmcHy6R9EV_QbarSwPWZE0n_Sar-gXK8g5ceT2-U,18080
-common/message/camera.py,sha256=Xv3Y31ppg9fkjncMteHwgB3Dx7RNRWbnStoDFp-YnhM,3075
-common/message/color.py,sha256=PsM-mD-LAitJJD4DCvMaSFGwXjFEiWgdcrqxFRj0wGI,3292
-common/message/frame.py,sha256=J8J0EutQ3mfHvmGjna-7hhWgIyqHgkKPPjIgMMyxCUw,1674
-common/message/image.py,sha256=aF_rU_sOSJQci6g_Wr5Sd16FUFnHm2kgurqWcPPKbaA,5296
-common/message/imu.py,sha256=mwIu_dK64aixrnz6Hsg8v-vXVKUabLBNbfHe2KqbVPo,328
-common/message/joint.py,sha256=V9qEILZVaWoAbKGT_V3wvSAvZzoJ7YmrcROkIdzmg5o,1051
-common/message/log.py,sha256=VN1zCwrUtTPNiyakNjYPZuz3UDMtW19fhD1F1M8MTf8,552
-common/message/pir.py,sha256=nSm5dymphomoOZqZAtQeUCowrIginEjVvLwW9NdGNAU,797
-common/message/point.py,sha256=oryHZEltba1z3GFRyb099oDddmiLE5SM4TKexgtBYaE,2229
-common/message/point_cloud.py,sha256=e06e6-bGaN8VzwkCy4MltDZocnKP7Bbr14gBlUhXu-A,2035
-common/message/pose.py,sha256=fcb0-xuIYWaaHHGC_iET9yma1fuicFvXJsaJaLO5XVI,4703
-common/message/quaternion.py,sha256=Y6-XR3g7VaWVOkLoK6hE26wTYjnJFjrHIv9y17GM1EY,6897
-common/message/radar.py,sha256=18w89hpq5tahh9V_49CWKXkU78b21xrTj_bH35u1UFE,2014
-common/message/types.py,sha256=k2wtbozsyd4HhMBoDfPFMLyCAGmTxaOvVhzIr-wx3N0,480
-common/message/vector.py,sha256=IrREGUi2zKTUmp5PG4YNiJKEM1zRXLl0fK9QuF7I06o,20302
-common/message/velocity.py,sha256=vHcFH_nMNBgobwY7dLeBaHJNvNiJxsQaPxImUh3GjHY,205
-common/rome/__init__.py,sha256=hfwUw5wbT-Ph-OFwGhiqw3XEeWaZwmLAs66LOYKqfzU,210
-common/rome/client.py,sha256=jhF4BEwtvJ3cIaT-M0ZxOljEHD9QJnO8b_QnIvu1-Wk,15797
-common/rome/error.py,sha256=oW8yI81o3hQghop4omFcMkXx4IbacGye38Iyw2VKihQ,294
-common/session/__init__.py,sha256=S6DsgJbRwFHaEcqe2CNrR_KI2811B1auLv-VX4g5JVU,643
-common/session/config.py,sha256=IxNK4uGRVmruLq9eFktBu8opyc_ACg1kysgkvCb5lho,17874
-common/session/environment.py,sha256=CVW00KXWF8L0L6ocUsZ2UWt-iqAiP0usFdhZsK43fak,714
-common/session/sim.py,sha256=CrwVPbu0m8UAFUSsTsU_TMgD1Ik9FKxs9FsaepIuZzg,2859
-common/utils/__init__.py,sha256=9zRb7XayzCGRs4I94hWKJHyQ1MevlUiTzXsPNBLBX7Y,113
-common/utils/comms.py,sha256=1lpnb9ra5I3xv-Eo0GFZ7nR4TjKseOeDNf9QMWQZbds,17283
-common/utils/logger.py,sha256=VcZ4dduWut8xWPs-F5ye8RRrNdBehSSG3r1LAWc-IBY,3389
-common/utils/time.py,sha256=kGDzObbaqWOep4vT1Y2W-BheunxdjYBI4V3Nfp4Ck3Q,790
-common/utils/usd.py,sha256=to4VPtnamMDIQK-pwDIVfiuzUnNzEImj5szOar1NHiE,253
-antioch_py-2.2.4.dist-info/METADATA,sha256=ahK5PzztFRLcl8Gd7-cp_EGRRYsegqHdf-Qzr6BqHpc,3485
-antioch_py-2.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-antioch_py-2.2.4.dist-info/entry_points.txt,sha256=1bLTH5BXCOsQkS8k6L_wJ6Nj62j4aoU9Ey_PhWzsRRM,59
-antioch_py-2.2.4.dist-info/top_level.txt,sha256=GtzNccsep3YdBt9VXQ7-ZFsFJFffr4hyZvqg0YqRqtw,15
-antioch_py-2.2.4.dist-info/RECORD,,

antioch_py-2.2.4.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-schedule_viz = scripts.schedule_viz:main