wirepod-vector-sdk-audio 0.9.0__py3-none-any.whl

anki_vector/photos.py

@@ -0,0 +1,145 @@
+# Copyright (c) 2018 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Photo related classes, functions, events and values.
+"""
+
+# __all__ should order by constants, event classes, other classes, functions.
+__all__ = ["PhotographComponent"]
+
+import concurrent
+from typing import List
+
+from . import connection, util
+from .messaging import protocol
+
+
+class PhotographComponent(util.Component):
+    """Access the photos on Vector.
+
+    .. testcode::
+
+        import anki_vector
+        import io
+        from PIL import Image
+
+        with anki_vector.Robot() as robot:
+            for photo_info in robot.photos.photo_info:
+                print(f"Opening photo {photo_info.photo_id}")
+                photo = robot.photos.get_photo(photo_info.photo_id)
+                image = Image.open(io.BytesIO(photo.image))
+                image.show()
+
+    :param anki_vector.Robot robot: A reference to an instance of the Robot class. Used to make rpc calls.
+    """
+
+    def __init__(self, robot):
+        super().__init__(robot)
+        self._photo_info: List[protocol.PhotoInfo] = []
+
+    @property
+    def photo_info(self) -> List[protocol.PhotoInfo]:
+        """The information about what photos are stored on Vector.
+
+        If the photo info hasn't been loaded yet, accessing this property will request it from the robot.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                for photo_info in robot.photos.photo_info:
+                    print(f"photo_info.photo_id: {photo_info.photo_id}") # the id to use to grab a photo from the robot
+                    print(f"photo_info.timestamp_utc: {photo_info.timestamp_utc}") # utc timestamp of when the photo was taken (according to the robot)
+        """
+        if not self._photo_info:
+            self.logger.debug("Photo list was empty. Lazy-loading photo list now.")
+            result = self.load_photo_info()
+            if isinstance(result, concurrent.futures.Future):
+                result.result()
+        return self._photo_info
+
+    @connection.on_connection_thread()
+    async def load_photo_info(self) -> protocol.PhotosInfoResponse:
+        """Request the photo information from the robot.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                photo_info = robot.photos.load_photo_info()
+                print(f"photo_info: {photo_info}")
+
+        :return: UTC timestamp of the photo and additional data.
+        """
+        req = protocol.PhotosInfoRequest()
+        result = await self.grpc_interface.PhotosInfo(req)
+        self._photo_info = result.photo_infos
+        return result
+
+    @connection.on_connection_thread(log_messaging=False)
+    async def get_photo(self, photo_id: int) -> protocol.PhotoResponse:
+        """Download a full-resolution photo from the robot's storage.
+
+        .. testcode::
+
+            import anki_vector
+            import io
+            from PIL import Image
+
+            with anki_vector.Robot() as robot:
+                for photo_info in robot.photos.photo_info:
+                    print(f"Opening photo {photo_info.photo_id}")
+                    photo = robot.photos.get_photo(photo_info.photo_id)
+                    image = Image.open(io.BytesIO(photo.image))
+                    image.show()
+
+        :param photo_id: The id of the photo to download. It's recommended to get this
+                         value from the photo_info list first.
+
+        :return: A response containing all of the photo bytes which may be rendered using
+                 another library (like :mod:`PIL`)
+        """
+        req = protocol.PhotoRequest(photo_id=photo_id)
+        return await self.grpc_interface.Photo(req)
+
+    @connection.on_connection_thread(log_messaging=False)
+    async def get_thumbnail(self, photo_id: int) -> protocol.ThumbnailResponse:
+        """Download a thumbnail of a given photo from the robot's storage.
+
+        You may use this function to pull all of the images off the robot in a smaller format, and
+        then determine which one to download as full resolution.
+
+        .. testcode::
+
+            import anki_vector
+            from PIL import Image
+            import io
+
+            with anki_vector.Robot() as robot:
+                for photo_info in robot.photos.photo_info:
+                    photo = robot.photos.get_thumbnail(photo_info.photo_id)
+                    image = Image.open(io.BytesIO(photo.image))
+                    image.show()
+
+        :param photo_id: The id of the thumbnail to download. It's recommended to get this
+                         value from the photo_info list first.
+
+        :return: A response containing all of the thumbnail bytes which may be rendered using
+                 another library (like :mod:`PIL`)
+        """
+        req = protocol.ThumbnailRequest(photo_id=photo_id)
+        return await self.grpc_interface.Thumbnail(req)

anki_vector/proximity.py

@@ -0,0 +1,176 @@
+# Copyright (c) 2018 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Support for Vector's distance sensor.
+
+Vector's time-of-flight distance sensor has a usable range of about 30 mm to 1200 mm
+(max useful range closer to 300mm for Vector) with a field of view of 25 degrees.
+
+The distance sensor can be used to detect objects in front of the robot.
+"""
+
+# __all__ should order by constants, event classes, other classes, functions.
+__all__ = ["ProximityComponent", "ProximitySensorData"]
+
+from . import util
+from .events import Events
+from .messaging import protocol
+
+
+class ProximitySensorData:
+    """A distance sample from the time-of-flight sensor with metadata describing reliability of the measurement
+
+    The proximity sensor is located near the bottom of Vector between the two front wheels, facing forward. The
+    reported distance describes how far in front of this sensor the robot feels an obstacle is. The sensor estimates
+    based on time-of-flight information within a field of view which the engine resolves to a certain quality value.
+
+    Four additional flags are supplied by the engine to indicate whether this proximity data is considered valid
+    for the robot's internal pathfinding. Respecting these is optional, but will help python code respect the
+    behavior of the robot's innate object avoidance.
+    """
+
+    def __init__(self, proto_data: protocol.ProxData):
+        self._distance = util.Distance(distance_mm=proto_data.distance_mm)
+        self._signal_quality = proto_data.signal_quality
+        self._unobstructed = proto_data.unobstructed
+        self._found_object = proto_data.found_object
+        self._is_lift_in_fov = proto_data.is_lift_in_fov
+
+    @property
+    @util.block_while_none()
+    def distance(self) -> util.Distance:
+        """The distance between the sensor and a detected object
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                distance = robot.proximity.last_sensor_reading.distance
+        """
+        return self._distance
+
+    @property
+    @util.block_while_none()
+    def signal_quality(self) -> float:
+        """The quality of the detected object.
+
+        The proximity sensor detects obstacles within a given field of view,
+        this value represents the likelihood of the reported distance being
+        a solid surface.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                signal_quality = robot.proximity.last_sensor_reading.signal_quality
+        """
+        return self._signal_quality
+
+    @property
+    @util.block_while_none()
+    def unobstructed(self) -> bool:
+        """The sensor has confirmed it has not detected anything up to its max range.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                unobstructed = robot.proximity.last_sensor_reading.unobstructed
+        """
+        return self._unobstructed
+
+    @property
+    @util.block_while_none()
+    def found_object(self) -> bool:
+        """The sensor detected an object in the valid operating range.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                found_object = robot.proximity.last_sensor_reading.found_object
+        """
+        return self._found_object
+
+    @property
+    @util.block_while_none()
+    def is_lift_in_fov(self) -> bool:
+        """Whether Vector's lift is blocking the time-of-flight sensor. While
+        the lift will send clear proximity signals, it's not useful for object
+        detection.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                is_lift_in_fov = robot.proximity.last_sensor_reading.is_lift_in_fov
+        """
+        return self._is_lift_in_fov
+
+
+class ProximityComponent(util.Component):
+    """Maintains the most recent proximity sensor data
+
+    This will be updated with every broadcast RobotState, and can be queried at any time. Two sensor readings are made available:
+        - the most recent data from the robot
+        - the most recent data which was considered valid by the engine for usage
+
+    An example of how to extract sensor data:
+
+    .. testcode::
+
+        import anki_vector
+
+        with anki_vector.Robot() as robot:
+            proximity_data = robot.proximity.last_sensor_reading
+            if proximity_data is not None:
+                print('Proximity distance: {0}'.format(proximity_data.distance))
+    """
+
+    def __init__(self, robot):
+        super().__init__(robot)
+        self._last_sensor_reading = None
+
+        # Subscribe to a callback that updates the robot's local properties - which includes proximity data.
+        self._robot.events.subscribe(self._on_robot_state,
+                                     Events.robot_state,
+                                     _on_connection_thread=True)
+
+    def close(self):
+        """Closing the touch component will unsubscribe from robot state updates."""
+        self._robot.events.unsubscribe(self._on_robot_state,
+                                       Events.robot_state)
+
+    @property
+    @util.block_while_none()
+    def last_sensor_reading(self) -> ProximitySensorData:
+        """:class:`anki_vector.proximity.ProximitySensorData`: The last reported sensor data.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                last_sensor_reading = robot.proximity.last_sensor_reading
+        """
+        return self._last_sensor_reading
+
+    def _on_robot_state(self, _robot, _event_type, msg):
+        self._last_sensor_reading = ProximitySensorData(msg.prox_data)

anki_vector/reserve_control/__main__.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""" Reserve SDK Behavior Control
+
+While this script runs, other SDK scripts may run and Vector will not perform most
+default behaviors before/after they complete.  This will keep Vector still.
+
+High priority behaviors like returning to the charger in a low battery situation,
+or retreating from a cliff will still take precedence.
+"""
+
+from anki_vector import behavior, util
+
+
+def hold_control():
+    args = util.parse_command_args()
+    with behavior.ReserveBehaviorControl(args.serial):
+        input("Vector behavior control reserved for SDK.  Hit 'Enter' to release control.")
+
+
+if __name__ == "__main__":
+    hold_control()