bosdyn-orbit 4.0.0__py3-none-any.whl

bosdyn/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

bosdyn/orbit/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+

bosdyn/orbit/client.py

@@ -0,0 +1,822 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+""" The client uses a web API to send HTTPs requests to a number of REStful endpoints using the Requests library.
+"""
+from collections.abc import Iterable
+
+import requests
+
+import bosdyn.orbit.utils as utils
+from bosdyn.orbit.exceptions import UnauthenticatedClientError
+
+DEFAULT_HEADERS = {'Accept': 'application/json'}
+OCTET_HEADER = {'Content-type': 'application/octet-stream', 'Accept': 'application/octet-stream'}
+
+
+class Client():
+    """Client for the Orbit web API"""
+
+    def __init__(self, hostname: str, verify: bool = True, cert: str = None):
+        """ Initializes the attributes of the Client object.
+
+            Args:
+                hostname: the IP address associated with the instance
+                verify(path to a CA bundle or Boolean): controls whether we verify the server’s TLS certificate
+                    Note that verify=False makes your application vulnerable to man-in-the-middle (MitM) attacks
+                    Defaults to True
+                cert(.pem file or a tuple with ('cert', 'key') pair): a local cert to use as client side certificate
+                    Note that the private key to your local certificate must be unencrypted because Requests does not support using encrypted keys.
+                    Defaults to None. For additional configurations, use the member Session object "_session" in accordance with Requests library
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+        """
+        # The hostname of the instance
+        self._hostname = hostname
+        # Set a Session object to persist certain parameters across requests
+        self._session = requests.Session()
+        # Set SSL verification strategy
+        self._session.verify = verify
+        # Client Side Certificates
+        self._session.cert = cert
+        # Initialize session
+        self._session.get(f'https://{self._hostname}')
+        # Set default headers for self._session
+        self._session.headers.update(DEFAULT_HEADERS)
+        # Set x-csrf-token for self._session
+        self._session.headers.update({'x-csrf-token': self._session.cookies['x-csrf-token']})
+        # Flag indicating that the Client is authenticated
+        self._is_authenticated = False
+
+    def authenticate_with_api_token(self, api_token: str = None) -> requests.Response:
+        """ Authorizes the client using the provided API token obtained from the instance.
+            Must call before using other client functions.
+
+            Args:
+                api_token: the API token obtained from the instance
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+        """
+        if not api_token:
+            api_token = utils.get_api_token()
+        # Set API token for self._session
+        self._session.headers.update({'Authorization': 'Bearer ' + api_token})
+        # Check the validity of the API token
+        authenticate_response = self._session.get(
+            f'https://{self._hostname}/api/v0/api_token/authenticate')
+        if authenticate_response.ok:
+            self._is_authenticated = True
+        else:
+            print('Client: Login failed: {} Please, obtain a valid API token from the instance!'.
+                  format(authenticate_response.text))
+            # Remove the invalid API token from session headers
+            self._session.headers.pop('Authorization')
+        return authenticate_response
+
+    def get_resource(self, path: str, **kwargs) -> requests.Response:
+        """ Base function for getting a resource in /api/v0/
+
+            Args:
+                path: the path appended to /api/v0/
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        if not self._is_authenticated:
+            raise UnauthenticatedClientError()
+        return self._session.get(f'https://{self._hostname}/api/v0/{path}/', **kwargs)
+
+    def post_resource(self, path: str, **kwargs) -> requests.Response:
+        """ Base function for posting a resource in /api/v0/
+
+            Args:
+                path: the path appended to /api/v0/
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                The response associated with the post request
+        """
+        if not self._is_authenticated and path != "login":
+            raise UnauthenticatedClientError()
+        return self._session.post(f'https://{self._hostname}/api/v0/{path}', **kwargs)
+
+    def delete_resource(self, path: str, **kwargs) -> requests.Response:
+        """ Base function for deleting a resource in /api/v0/
+
+            Args:
+                path: the path appended to /api/v0/
+                kwargs(**): a variable number of keyword arguments for the delete request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                The response associated with the delete request
+        """
+        if not self._is_authenticated:
+            raise UnauthenticatedClientError()
+        return self._session.delete(f'https://{self._hostname}/api/v0/{path}', **kwargs)
+
+    def get_version(self, **kwargs) -> requests.Response:
+        """ Retrieves version info.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("version", **kwargs)
+
+    def get_system_time(self, **kwargs) -> requests.Response:
+        """ Returns the current system time.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("settings/system-time", **kwargs)
+
+    def get_robots(self, **kwargs) -> requests.Response:
+        """ Returns robots on the specified instance.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("robots", **kwargs)
+
+    def get_robot_by_hostname(self, hostname: str, **kwargs) -> requests.Response:
+        """ Returns a robot on given a hostname of a specific robot.
+
+            Args:
+                hostname: the IP address associated with the desired robot on the instance
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'robots/{hostname}', **kwargs)
+
+    def get_site_walks(self, **kwargs) -> requests.Response:
+        """ Returns site walks on the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("site_walks", **kwargs)
+
+    def get_site_walk_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a site walk uuid, returns a site walk on the specified instance
+
+            Args:
+                uuid: the ID associated with the site walk
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'site_walks/{uuid}', **kwargs)
+
+    def get_site_elements(self, **kwargs) -> requests.Response:
+        """ Returns site elements on the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("site_elements", **kwargs)
+
+    def get_site_element_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a site element uuid, returns a site element on the specified instance
+
+            Args:
+                uuid: the ID associated with the site element
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'site_elements/{uuid}', **kwargs)
+
+    def get_site_docks(self, **kwargs) -> requests.Response:
+        """ Returns site docks on the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("site_docks", **kwargs)
+
+    def get_site_dock_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a site dock uuid, returns a site dock on the specified instance
+
+            Args:
+                uuid: the ID associated with the site dock
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'site_docks/{uuid}', **kwargs)
+
+    def get_calendar(self, **kwargs) -> requests.Response:
+        """ Returns calendar events on the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("calendar/schedule", **kwargs)
+
+    def get_run_events(self, **kwargs) -> requests.Response:
+        """ Given a dictionary of query params, returns run events
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("run_events", **kwargs)
+
+    def get_run_event_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a runEventUuid, returns a run event
+
+            Args:
+                uuid: the ID associated with the run event
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'run_events/{uuid}', **kwargs)
+
+    def get_run_captures(self, **kwargs) -> requests.Response:
+        """ Given a dictionary of query params, returns run captures
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("run_captures", **kwargs)
+
+    def get_run_capture_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a runCaptureUuid, returns a run capture
+
+            Args:
+                uuid: the ID associated with the run capture
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'run_captures/{uuid}', **kwargs)
+
+    def get_runs(self, **kwargs) -> requests.Response:
+        """ Given a dictionary of query params, returns runs
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("runs", **kwargs)
+
+    def get_run_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a runUuid, returns a run
+
+            Args:
+                uuid: the ID associated with the run
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'runs/{uuid}', **kwargs)
+
+    def get_run_archives_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a runUuid, returns run archives
+
+            Args:
+                uuid: the ID associated with the run
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'run_archives/{uuid}', **kwargs)
+
+    def get_image(self, url: str, **kwargs) -> 'urllib3.response.HTTPResponse':
+        """ Given a data capture url, returns a decoded image
+
+            Args:
+                url: the url associated with the data capture in the form of https://hostname + RunCapture["dataUrl"].
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                urllib3.response.HTTPResponse: the decoded response associated with the get request
+        """
+        if not self._is_authenticated:
+            raise UnauthenticatedClientError()
+        response = self._session.get(url, stream=True, **kwargs)
+        response.raise_for_status()
+        response.raw.decode_content = True
+        return response.raw
+
+    def get_image_response(self, url: str, **kwargs) -> requests.Response:
+        """ Given a data capture url, returns an image response
+
+            Args:
+                url: the url associated with the data capture in the form of https://hostname + RunCapture["dataUrl"]
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the image response associated with the get request
+        """
+        if not self._is_authenticated:
+            raise UnauthenticatedClientError()
+        response = self._session.get(url, stream=True, **kwargs)
+        return response
+
+    def get_webhook(self, **kwargs) -> requests.Response:
+        """ Returns webhook on the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource("webhooks", **kwargs)
+
+    def get_webhook_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a uuid, returns a specific webhook instance
+
+            Args:
+                uuid: the ID associated with the webhook
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the get request
+        """
+        return self.get_resource(f'webhooks/{uuid}', **kwargs)
+
+    def get_robot_info(self, robot_nickname: str, **kwargs) -> requests.Response:
+        """ Given a robot nickname, returns information about the robot
+
+            Args:
+                robot_nickname: the nickname of the robot
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.get_resource(f'robot-session/{robot_nickname}/session', **kwargs)
+
+    def post_export_as_walk(self, site_walk_uuid: str, **kwargs) -> requests.Response:
+        """ Given a site walk uuid, it exports the walks_pb2.Walk equivalent
+
+            Args:
+                site_walk_uuid: the ID associated with the site walk
+                kwargs(**): a variable number of keyword arguments for the get request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError: indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource(f'site_walks/export_as_walk/{site_walk_uuid}', **kwargs)
+
+    def post_import_from_walk(self, **kwargs) -> requests.Response:
+        """ Given a walk data, imports it to the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("site_walks/import_from_walk", **kwargs)
+
+    def post_site_element(self, **kwargs) -> requests.Response:
+        """ Create a site element. It also updates a pre-existing Site Element using the associated UUID.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("site_elements", **kwargs)
+
+    def post_site_walk(self, **kwargs) -> requests.Response:
+        """ Create a site walk. It also updates a pre-existing Site Walk using the associated UUID.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("site_walks", **kwargs)
+
+    def post_site_dock(self, **kwargs) -> requests.Response:
+        """ Create a site element. It also updates a pre-existing Site Dock using the associated UUID.
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("site_docks", **kwargs)
+
+    def post_robot(self, **kwargs) -> requests.Response:
+        """ Add a robot to the specified instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("robots", **kwargs)
+
+    def post_calendar_event(self, nickname: str = None, time_ms: int = None, repeat_ms: int = None,
+                            mission_id: str = None, force_acquire_estop: bool = None,
+                            require_docked: bool = None, schedule_name: str = None,
+                            blackout_times: Iterable[dict[str:int]] = None,
+                            disable_reason: str = None, event_id: str = None,
+                            **kwargs) -> requests.Response:
+        """  This function serves two purposes. It creates a new calendar event on using the following arguments
+             when Event ID is not specified. When the Event ID associated with a pre-existing calendar event is specified,
+             the function overwrites the attributes of the pre-existing calendar event.
+
+            Args:
+                nickname: the name associated with the robot
+                time_ms: the first kickoff time in terms of milliseconds since epoch
+                repeat_ms:the delay time in milliseconds for repeating calendar events
+                mission_id: the UUID associated with the mission( also known as Site Walk)
+                force_acquire_estop: instructs the system to force acquire the estop when the mission kicks off
+                require_docked: determines whether the event will require the robot to be docked to start
+                schedule_name: the desired name of the calendar event
+                blackout_times: a specification for a time period over the course of a week when a schedule should not run
+                                  specified as list of a dictionary defined as {"startMs": <int>, "endMs" : <int>}
+                                  with startMs (inclusive) being the millisecond offset from the beginning of the week (Sunday) when this blackout period starts
+                                  and endMs (exclusive) being the millisecond offset from beginning of the week(Sunday) when this blackout period ends
+                disable_reason: (optional) a reason for disabling the calendar event
+                event_id: the auto-generated ID for a calendar event that is already posted on the instance.
+                            This is only useful when editing a pre-existing calendar event.
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        # Check if the input contains the json param that is constructed outside the function
+        if 'json' in kwargs:
+            return self.post_resource("calendar/schedule", **kwargs)
+        # Construct payload based on provided inputs
+        payload = {
+            "agent": {
+                "nickname": nickname
+            },
+            "schedule": {
+                "timeMs": time_ms,
+                "repeatMs": repeat_ms,
+                "blackouts": blackout_times,
+                "disableReason": disable_reason,
+            },
+            "task": {
+                "missionId": mission_id,
+                "forceAcquireEstop": force_acquire_estop,
+                "requireDocked": require_docked,
+            },
+            "eventMetadata": {
+                "name": schedule_name,
+                "eventId": event_id
+            },
+        }
+        return self.post_resource("calendar/schedule", json=payload, **kwargs)
+
+    def post_calendar_events_disable_all(self, disable_reason: str, **kwargs) -> requests.Response:
+        """ Disable all scheduled missions
+
+            Args:
+                disable_reason: Reason for disabling all scheduled missions
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("calendar/disable-enable", json={"disableReason": disable_reason},
+                                  **kwargs)
+
+    def post_calendar_event_disable_by_id(self, event_id: str, disable_reason: str,
+                                          **kwargs) -> requests.Response:
+        """ Disable specific scheduled mission by event ID
+
+            Args:
+                event_id: eventId associated with a mission to disable
+                disable_reason: Reason for disabling a scheduled mission
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("calendar/disable-enable", json={
+            "disableReason": disable_reason,
+            "eventId": event_id
+        }, **kwargs)
+
+    def post_calendar_events_enable_all(self, **kwargs) -> requests.Response:
+        """ Enable all scheduled missions
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("calendar/disable-enable", json={"disableReason": ""}, **kwargs)
+
+    def post_calendar_event_enable_by_id(self, event_id: str, **kwargs) -> requests.Response:
+        """ Enable specific scheduled mission by event ID
+
+            Args:
+                event_id: eventId associated with a mission to enable
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("calendar/disable-enable", json={
+            "disableReason": "",
+            "eventId": event_id
+        }, **kwargs)
+
+    def post_webhook(self, **kwargs) -> requests.Response:
+        """ Create a webhook instance
+
+            Args:
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource("webhooks", **kwargs)
+
+    def post_webhook_by_id(self, uuid: str, **kwargs) -> requests.Response:
+        """ Update an existing webhook instance
+
+            Args:
+                uuid: the ID associated with the desired webhook instance
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource(f'webhooks/{uuid}', **kwargs)
+
+    def post_return_to_dock_mission(self, robot_nickname: str, site_dock_uuid: str,
+                                    **kwargs) -> requests.Response:
+        """ Generate a mission to send the robot back to the dock
+
+            Args:
+                robot_nickname: the nickname of the robot
+                site_dock_uuid: the uuid of the dock to send robot to
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        return self.post_resource('graph/send-robot', json={
+            "nickname": robot_nickname,
+            "siteDockUuid": site_dock_uuid
+        }, **kwargs)
+
+    def post_dispatch_mission_to_robot(self, robot_nickname: str, driver_id: str, mission_uuid: str,
+                                       delete_mission: bool, force_acquire_estop: bool,
+                                       **kwargs) -> requests.Response:
+        """ Dispatch the robot to a mission given a mission uuid
+
+            Args:
+                robot_nickname: the nickname of the robot
+                driver_id: the current driver ID of the mission
+                mission_uuid: uuid of the mission(also known as Site Walk) to dispatch
+                delete_mission: whether to delete the mission after playback
+                force_acquire_estop: whether to force acquire E-stop from the previous client
+                kwargs(**): a variable number of keyword arguments for the post request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the post request
+        """
+        # Payload required for dispatching a mission
+        payload = {
+            "agent": {
+                "nickname": robot_nickname
+            },
+            "schedule": {
+                "timeMs": {
+                    "low": 1,
+                    "high": 0,
+                    "unsigned": False
+                },
+                "repeatMs": {
+                    "low": 0,
+                    "high": 0,
+                    "unsigned": False
+                }
+            },
+            "task": {
+                "missionId": mission_uuid,
+                "forceAcquireEstop": force_acquire_estop,
+                "deleteMission": delete_mission,
+                "requireDocked": False
+            },
+            "eventMetadata": {
+                "name": "API Triggered Mission"
+            }
+        }
+        return self.post_resource(
+            f'calendar/mission/dispatch/{robot_nickname}?currentDriverId={driver_id}', json=payload,
+            **kwargs)
+
+    def delete_site_walk(self, uuid: str, **kwargs) -> requests.Response:
+        """ Given a site walk uuid, deletes the site walk associated with the uuid on the specified instance
+
+            Args:
+                uuid: the ID associated with the desired site walk
+                kwargs(**): a variable number of keyword arguments for the delete request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the delete request
+        """
+        return self.delete_resource(f'site_walks/{uuid}', **kwargs)
+
+    def delete_robot(self, robot_hostname: str, **kwargs) -> requests.Response:
+        """ Given a robot hostname, deletes the robot associated with the hostname on the specified instance
+
+            Args:
+                robot_hostname: the IP address associated with the robot
+                kwargs(**): a variable number of keyword arguments for the delete request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the delete request
+        """
+        return self.delete_resource(f'robots/{robot_hostname}', **kwargs)
+
+    def delete_calendar_event(self, event_id: str, **kwargs) -> requests.Response:
+        """ Delete the specified calendar event on the specified instance
+
+            Args:
+                event_id(string): the ID associated with the calendar event
+                kwargs(**): a variable number of keyword arguments for the delete request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the delete request
+        """
+        return self.delete_resource(f'calendar/schedule/{event_id}', **kwargs)
+
+    def delete_webhook(self, uuid: str, **kwargs) -> requests.Response:
+        """ Delete the specified webhook instance on the specified instance
+
+            Args:
+                uuid: the ID associated with the desired webhook
+                kwargs(**): a variable number of keyword arguments for the delete request
+            Raises:
+                RequestExceptions: exceptions thrown by the Requests library
+                UnauthenticatedClientError:  indicates that the client is not authenticated properly
+            Returns:
+                requests.Response: the response associated with the delete request
+        """
+        return self.delete_resource(f'webhooks/{uuid}', **kwargs)
+
+
+def create_client(options: 'argparse.Namespace') -> 'bosdyn.orbit.client.Client':
+    """ Creates a client object.
+
+        Args:
+            options: User input containing hostname, verification, and certification info.
+        Returns:
+            client: 'bosdyn.orbit.client.Client' object
+    """
+    # Determine the value for the argument "verify"
+    if options.verify in ["True", "False"]:
+        verify = options.verify == "True"
+    else:
+        print(
+            "The provided value for the argument verify [%s] is not either 'True' or 'False'. Assuming verify is set to 'path/to/CA bundle'"
+            .format(options.verify))
+        verify = options.verify
+
+    # A client object represents a single instance.
+    client = Client(hostname=options.hostname, verify=verify, cert=options.cert)
+
+    # The client needs to be authenticated before using its functions
+    client.authenticate_with_api_token()
+
+    return client

bosdyn/orbit/exceptions.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+"""Relevant exceptions for bosdyn-orbit"""
+
+
+class Error(Exception):
+    """Base exception"""
+
+
+class UnauthenticatedClientError(Error):
+    """The client is not authenticated properly."""
+
+    def __str__(self):
+        return 'The client is not authenticated properly. Run the proper authentication before calling other client functions!'
+
+
+class WebhookSignatureVerificationError(Error):
+    """The webhook signature could not be verified."""

bosdyn/orbit/utils.py

@@ -0,0 +1,305 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+"""Utility functions for bosdyn-orbit"""
+import datetime
+import hashlib
+import hmac
+import json
+import os
+import secrets
+import shutil
+import sys
+import time
+
+from bosdyn.orbit.exceptions import WebhookSignatureVerificationError
+
+API_TOKEN_ENV_VAR = "BOSDYN_ORBIT_CLIENT_API_TOKEN"
+DEFAULT_MAX_MESSAGE_AGE_MS = 5 * 60 * 1000
+
+
+def get_api_token() -> str:
+    """ Obtains an API token from either an environment variable or terminal input
+
+        Returns
+            api_token: the API token obtained from the instance
+    """
+    api_token = os.environ.get(API_TOKEN_ENV_VAR)
+    if not api_token:
+        if sys.stdin.isatty():
+            print('API Token: ', end='', file=sys.stderr)
+            api_token = input()
+    return api_token
+
+
+def get_latest_created_at_for_run_events(client: 'bosdyn.orbit.client.Client',
+                                         params: dict = {}) -> datetime.datetime:
+    """ Given a dictionary of query params, returns the max created at time for run events
+
+        Args:
+            client: the client for the web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            The max created at time for run events in datetime
+    """
+    base_params = {'limit': 1, 'orderBy': '-created_at'}
+    base_params.update(params)
+    latest_resource = client.get_run_events(params=base_params).json()
+    if not latest_resource["resources"]:
+        client_timestamp_response = client.get_system_time()
+        ms_since_epoch = int(client_timestamp_response.json()["msSinceEpoch"])
+        return datetime.datetime.utcfromtimestamp(ms_since_epoch / 1000)
+    return datetime_from_isostring(latest_resource["resources"][0]["createdAt"])
+
+
+def get_latest_run_capture_resources(client: 'bosdyn.orbit.client.Client',
+                                     params: dict = {}) -> list:
+    """ Given a dictionary of query params, returns the latest run capture resources in json format
+
+        Args:
+            client: the client for Orbit web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            A list of resources obtained from a RESTful endpoint
+    """
+    base_params = {'orderBy': '-created_at'}
+    base_params.update(params)
+    run_captures = client.get_run_captures(params=base_params).json()
+    return run_captures["resources"]
+
+
+def get_latest_created_at_for_run_captures(client: 'bosdyn.orbit.client.Client',
+                                           params: dict = {}) -> datetime.datetime:
+    """ Given a dictionary of query params, returns the max created at time for run captures
+
+        Args:
+            client: the client for Orbit web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            The max created at time for run captures in datetime
+    """
+    base_params = {'limit': 1, 'orderBy': '-created_at'}
+    base_params.update(params)
+    latest_resource = client.get_run_captures(params=base_params).json()
+    if not latest_resource["resources"]:
+        client_timestamp_response = client.get_system_time()
+        ms_since_epoch = int(client_timestamp_response.json()["msSinceEpoch"])
+        return datetime.datetime.utcfromtimestamp(ms_since_epoch / 1000)
+    return datetime_from_isostring(latest_resource["resources"][0]["createdAt"])
+
+
+def get_latest_run_resource(client: 'bosdyn.orbit.client.Client', params: dict = {}) -> list:
+    """ Given a dictionary of query params, returns the latest run resource in json format
+
+        Args:
+            client: the client for Orbit web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            A list corresponding to a run resource obtained from a RESTful endpoint in json
+    """
+    base_params = {'limit': 1, 'orderBy': 'newest'}
+    base_params.update(params)
+    latest_run_json = client.get_runs(params=base_params).json()
+    if not latest_run_json['resources']:
+        return None
+    return latest_run_json['resources'][0]
+
+
+def get_latest_run_in_progress(client: 'bosdyn.orbit.client.Client', params: dict = {}) -> list:
+    """ Given a dictionary of query params, returns the latest running resource in json format
+
+        Args:
+            client: the client for Orbit web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            A list corresponding to a run obtained from a RESTful endpoint in json
+    """
+    base_params = {'orderBy': 'newest'}
+    base_params.update(params)
+    latest_resources = client.get_runs(params=base_params).json()["resources"]
+    for resource in latest_resources:
+        if resource["missionStatus"] not in [
+                "SUCCESS", "FAILURE", "ERROR", "STOPPED", "NONE", "UNKNOWN"
+        ]:
+            return resource
+    return None
+
+
+def get_latest_end_time_for_runs(client: 'bosdyn.orbit.client.Client',
+                                 params: dict = {}) -> datetime.datetime:
+    """ Given a dictionary of query params, returns the max end time for runs
+
+        Args:
+            client: the client for Orbit web API
+            params: the query params associated with the get request
+        Raises:
+            RequestExceptions: exceptions thrown by the Requests library
+            UnauthenticatedClientError:  indicates that the client is not authenticated properly
+        Returns:
+            The max end time for runs in datetime
+    """
+    base_params = {'limit': 1, 'orderBy': 'newest'}
+    base_params.update(params)
+    latest_resource = client.get_runs(params=base_params).json()
+    if latest_resource.get("resources"):
+        latest_end_time = latest_resource.get("resources")[0]["endTime"]
+        if latest_end_time:
+            return datetime_from_isostring(latest_end_time)
+    client_timestamp_response = client.get_system_time()
+    ms_since_epoch = int(client_timestamp_response.json()["msSinceEpoch"])
+    return datetime.datetime.utcfromtimestamp(ms_since_epoch / 1000)
+
+
+def write_image(img_raw, image_fp: str) -> None:
+    """ Given a raw image and a desired output directory, writes the image to a file
+
+        Args:
+            img_raw(Raw image object): the input raw image
+            image_fp: the output filepath for the image
+    """
+    os.makedirs(os.path.dirname(image_fp), exist_ok=True)
+    with open(image_fp, 'wb') as out_file:
+        shutil.copyfileobj(img_raw, out_file)
+
+
+def data_capture_urls_from_run_events(client: 'bosdyn.orbit.client.Client', run_events: list,
+                                      list_of_channel_names: list = None) -> list:
+    """ Given run events and list of desired channel names, returns the list of data capture urls
+
+        Args:
+            client: the client for Orbit web API
+            run_events: a json representation of run events obtained from a RESTful endpoint
+            list_of_channel_names: a list of channel names associated with the desired data captures.
+                                           Defaults to None which returns all the available channels.
+        Returns:
+            data_urls: a list of urls
+    """
+    all_run_events_resources = run_events["resources"]
+    data_urls = []
+    for resource in all_run_events_resources:
+        all_data_captures = resource["dataCaptures"]
+        for data_capture in all_data_captures:
+            if list_of_channel_names is None:
+                # check if exists in unique_list or not
+                if list_of_channel_names not in data_urls:
+                    data_urls.append(f'https://{client._hostname}' + data_capture["dataUrl"])
+            elif data_capture["channelName"] in list_of_channel_names:
+                # check if exists in unique_list or not
+                if list_of_channel_names not in data_urls:
+                    data_urls.append(f'https://{client._hostname}' + data_capture["dataUrl"])
+    return data_urls
+
+
+def data_capture_url_from_run_capture_resources(client: 'bosdyn.orbit.client.Client',
+                                                run_capture_resources: list,
+                                                list_of_channel_names: list = None) -> list:
+    """ Given run capture resources and list of desired channel names, returns the list of data capture urls
+
+        Args:
+            client: the client for Orbit web API
+            run_capture_resources: a list of resources obtained from a RESTful endpoint
+            list_of_channel_names: a list of channel names associated with the desired data captures.
+                                           Defaults to None which returns all the available channels.
+        Returns:
+            data_urls: a list of urls
+    """
+    data_urls = []
+    for data_capture in run_capture_resources:
+        if list_of_channel_names is None:
+            # check if exists in unique_list or not
+            if list_of_channel_names not in data_urls:
+                data_urls.append(f'https://{client._hostname}' + data_capture["dataUrl"])
+        elif data_capture["channelName"] in list_of_channel_names:
+            # check if exists in unique_list or not
+            if list_of_channel_names not in data_urls:
+                data_urls.append(f'https://{client._hostname}' + data_capture["dataUrl"])
+    return data_urls
+
+
+def get_action_names_from_run_events(run_events: dict) -> list:
+    """ Given run events, returns a list of action names
+
+        Args:
+            run_events: a representation of run events obtained from a RESTful endpoint
+        Returns:
+            action_names: a list of action names
+    """
+    all_run_events_resources = run_events["resources"]
+    action_names = []
+    for resource in all_run_events_resources:
+        action_names.append(resource["actionName"])
+    return action_names
+
+
+def datetime_from_isostring(datetime_isostring: str) -> datetime.datetime:
+    """ Returns the datetime representation of the iso string representation of time
+
+        Args:
+            datetime_isostring: the iso string representation of time
+        Returns:
+            The datetime representation of the iso string representation of time
+    """
+    if "Z" in datetime_isostring:
+        return datetime.datetime.strptime(datetime_isostring, "%Y-%m-%dT%H:%M:%S.%fZ")
+    if "+" in datetime_isostring:
+        return datetime.datetime.strptime(datetime_isostring[0:datetime_isostring.index("+")],
+                                          "%Y-%m-%dT%H:%M:%S.%f")
+
+
+def validate_webhook_payload(payload: dict, signature_header: str, secret: str,
+                             max_age_ms: int = DEFAULT_MAX_MESSAGE_AGE_MS) -> None:
+    """ Verifies that the webhook payload came from
+
+        Args:
+            payload: the JSON body of the webhooks req
+            signature_header: the value of the signature header
+            secret: the configured secret value for this webhook
+            max_age_ms: the maximum age of the message before it's considered invalid (default is 5 minutes)
+        Raises:
+            bosdyn.orbit.exceptions.WebhookSignatureVerificationError: thrown if the webhook signature is invalid
+    """
+    if not signature_header:
+        raise WebhookSignatureVerificationError("Signature header cannot be empty")
+
+    header_components = dict(entry.split('=') for entry in signature_header.split(','))
+    send_time = header_components.get('t')
+    send_time_ms = int(send_time) if send_time is not None and send_time.isdigit() else None
+    received_hmac = header_components.get('v1')
+    if not send_time_ms or not received_hmac:
+        raise WebhookSignatureVerificationError(
+            "Missing either send time or HMAC in signature header")
+
+    current_time_ns = time.time()
+    current_time_ms = round(current_time_ns) * 1000
+    time_diff_ms = current_time_ms - send_time_ms
+    if time_diff_ms > max_age_ms:
+        raise WebhookSignatureVerificationError(
+            f"The payload is {time_diff_ms}ms old, which is greater than the maximum age {max_age_ms}ms"
+        )
+
+    full_payload_string = f'{send_time}.{json.dumps(payload, separators=(",",":"))}'
+    calculated_hmac = hmac.new(bytes.fromhex(secret), full_payload_string.encode('utf-8'),
+                               hashlib.sha256).hexdigest()
+
+    time_safe_equal = secrets.compare_digest(received_hmac, calculated_hmac)
+    if not time_safe_equal:
+        raise WebhookSignatureVerificationError(
+            "The received HMAC did not match the expected value")

bosdyn_orbit-4.0.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.1
+Name: bosdyn-orbit
+Version: 4.0.0
+Summary: Boston Dynamics API Orbit Client
+Home-page: https://dev.bostondynamics.com/docs/orbit/
+Author: Boston Dynamics
+Author-email: support@bostondynamics.com
+Project-URL: Documentation, https://dev.bostondynamics.com/docs/orbit/
+Project-URL: Source, https://github.com/boston-dynamics/spot-sdk/
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: Deprecated (~=1.2.10)
+
+<!--
+Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+
+Downloading, reproducing, distributing or otherwise using the SDK Software
+is subject to the terms and conditions of the Boston Dynamics Software
+Development Kit License (20191101-BDSDK-SL).
+-->
+
+# bosdyn-orbit
+
+The bosdyn-orbit wheel contains the Orbit client for the Boston Dynamics Orbit API. The Orbit API is hosted on your Orbit. The Orbit client interacts with the Orbit API by sending HTTPs requests to a number of resource endpoints. The client offers the following main functionalities:
+
+- Retrieve Orbit software version info
+- Get Orbit's current system time
+- List robots
+- List site walks, site elements, and site docks
+- List posted calendar events
+- Access resources such as runs, run events, and run captures
+- Get images
+- Export and import site walks
+- Create a site walk, site element, and site dock
+- Add robots to the specified Orbit instance
+- Create a calendar event to play a mission
+- Delete site walks, site elements, and site docks
+- Remove robots
+- Delete calendar event

bosdyn_orbit-4.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+bosdyn/__init__.py,sha256=CMQioQKK1NlMk3kZuY49b_Aw-JyvDeOtuqOCAul1I0s,330
+bosdyn/orbit/__init__.py,sha256=L_VSEXjtWZNHVHs3Jdr_TF2pJ2ju2yysAi0-YZsbJoU,266
+bosdyn/orbit/client.py,sha256=6aY_il9mPt8IjYdWwPFWBdyxrxaNv1z3KJDxeX-B9kw,40103
+bosdyn/orbit/exceptions.py,sha256=eaeHSlGh27JlZUEjcpLKxR1CNdW6Twp4e685pUgEjyQ,711
+bosdyn/orbit/utils.py,sha256=Ryz0oHIud5n433JDuiyLLUjOS89wWcMbOu45b4ISVMw,13636
+bosdyn_orbit-4.0.0.dist-info/METADATA,sha256=5zpzRF8QV-OkBQWIoNI0-1Y2gV0p-wNk47rCxuBcVwY,1894
+bosdyn_orbit-4.0.0.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
+bosdyn_orbit-4.0.0.dist-info/top_level.txt,sha256=an2OWgx1ej2jFjmBjPWNQ68ZglvUfKhmXWW-WhTtDmA,7
+bosdyn_orbit-4.0.0.dist-info/RECORD,,

bosdyn_orbit-4.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bosdyn_orbit-4.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bosdyn