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

anki_vector/camera_viewer/__init__.py

@@ -0,0 +1,121 @@
+# 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
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module provides the camera viewer's render process.
+
+It should be launched in a separate process to allow Vector to run freely while
+the viewer is rendering.
+
+It uses Tkinter, a standard Python GUI package.
+It also depends on the Pillow library for image processing.
+"""
+
+import multiprocessing as mp
+import sys
+import tkinter as tk
+
+try:
+    from PIL import ImageTk
+except ImportError:
+    sys.exit('Cannot import from PIL: Do `pip3 install --user "wirepod_vector_sdk[3dviewer]"` to install')
+
+
+class TkCameraViewer:  # pylint: disable=too-few-public-methods
+    """A Tkinter based camera video feed.
+
+    :param queue: A queue to send frames between the user's main thread and the viewer process.
+    :param event: An event to signal that the viewer process has closed.
+    :param overlays: Overlays to be drawn on the images of the renderer.
+    :param timeout: The time without a new frame before the process will exit.
+    :param force_on_top: Specifies whether the window should be forced on top of all others.
+    """
+
+    def __init__(self, queue: mp.Queue, event: mp.Event, overlays: list = None, timeout: float = 10.0, force_on_top: bool = True):
+        self.tk_root = tk.Tk()
+        self.width = None
+        self.height = None
+        self.queue = queue
+        self.event = event
+        self.overlays = overlays
+        self.timeout = timeout
+        self.tk_root.title("Vector Camera Feed")
+        self.tk_root.protocol("WM_DELETE_WINDOW", self._delete_window)
+        self.tk_root.bind("<Configure>", self._resize_window)
+        if force_on_top:
+            self.tk_root.wm_attributes("-topmost", 1)
+        self.label = tk.Label(self.tk_root, borderwidth=0)
+        self.label.pack(fill=tk.BOTH, expand=True)
+
+    def _delete_window(self) -> None:
+        """Handle window close event."""
+        self.event.set()
+        self.tk_root.destroy()
+
+    def _resize_window(self, evt: tk.Event) -> None:
+        """Handle window resize event.
+
+        :param evt: A Tkinter window event (keyboard, mouse events, etc).
+        """
+        self.width = evt.width
+        self.height = evt.height
+
+    def draw_frame(self) -> None:
+        """Display an image on to a Tkinter label widget."""
+        try:
+            image = self.queue.get(True, timeout=self.timeout)
+        except:
+            return
+        self.width, self.height = image.size
+        while image:
+            if self.event.is_set():
+                break
+            if self.overlays:
+                for overlay in self.overlays:
+                    overlay.apply_overlay(image)
+            if (self.width, self.height) != image.size:
+                image = image.resize((self.width, self.height))
+            tk_image = ImageTk.PhotoImage(image)
+            self.label.config(image=tk_image)
+            self.label.image = tk_image
+            self.tk_root.update_idletasks()
+            self.tk_root.update()
+            try:
+                image = self.queue.get(True, timeout=self.timeout)
+            except:
+                return
+
+
+def main(queue: mp.Queue, event: mp.Event, overlays: list = None, timeout: float = 10.0, force_on_top: bool = False) -> None:
+    """Rendering the frames in another process. This allows the UI to have the
+    main thread of its process while the user code continues to execute.
+
+    :param queue: A queue to send frames between the user's main thread and the viewer process.
+    :param event: An event to signal that the viewer process has closed.
+    :param overlays: Overlays to be drawn on the images of the renderer.
+    :param timeout: The time without a new frame before the process will exit.
+    :param force_on_top: Specifies whether the window should be forced on top of all others.
+    """
+
+    try:
+        tk_viewer = TkCameraViewer(queue, event, overlays, timeout, force_on_top)
+        tk_viewer.draw_frame()
+    except TimeoutError:
+        pass
+    except KeyboardInterrupt:
+        pass
+    finally:
+        event.set()
+
+
+__all__ = ['TkCameraViewer', 'main']

anki_vector/color.py

@@ -0,0 +1,88 @@
+# 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.
+
+"""
+Colors to be used with a light or Vector's screen.
+"""
+
+
+class Color:
+    """A Color to be used with a Light or Vector's screen.
+
+    Either int_color or rgb may be used to specify the actual color.
+    Any alpha components (from int_color) are ignored - all colors are fully opaque.
+
+    :param int_color: A 32 bit value holding the binary RGBA value (where A
+            is ignored and forced to be fully opaque).
+    :param rgb: A tuple holding the integer values from 0-255 for (reg, green, blue)
+    :param name: A name to assign to this color.
+    """
+
+    def __init__(self, int_color: int = None, rgb: tuple = None, name: str = None):
+        self.name = name
+        self._int_color = 0
+        if int_color is not None:
+            self._int_color = int_color | 0xff
+        elif rgb is not None:
+            self._int_color = (rgb[0] << 24) | (rgb[1] << 16) | (rgb[2] << 8) | 0xff
+
+    @property
+    def int_color(self) -> int:
+        """The encoded integer value of the color."""
+        return self._int_color
+
+    @property
+    def rgb565_bytepair(self):
+        """bytes[]: Two bytes representing an int16 color with rgb565 encoding.
+
+        This format reflects the robot's Screen color range, and performing this
+        conversion will reduce network traffic when sending Screen data.
+        """
+
+        red5 = ((self._int_color >> 24) & 0xff) >> 3
+        green6 = ((self._int_color >> 16) & 0xff) >> 2
+        blue5 = ((self._int_color >> 8) & 0xff) >> 3
+
+        green3_hi = green6 >> 3
+        green3_low = green6 & 0x07
+
+        int_565_color_lowbyte = (green3_low << 5) | blue5
+        int_565_color_highbyte = (red5 << 3) | green3_hi
+
+        return [int_565_color_highbyte, int_565_color_lowbyte]
+
+
+#: :class:`Color`: Green color instance.
+green = Color(name="green", int_color=0x00ff00ff)
+
+#: :class:`Color`: Red color instance.
+red = Color(name="red", int_color=0xff0000ff)
+
+#: :class:`Color`: Blue color instance.
+blue = Color(name="blue", int_color=0x0000ffff)
+
+#: :class:`Color`: Cyan color instance.
+cyan = Color(name="cyan", int_color=0x00ffffff)
+
+#: :class:`Color`: Magenta color instance.
+magenta = Color(name="magenta", int_color=0xff00ffff)
+
+#: :class:`Color`: Yellow color instance.
+yellow = Color(name="yellow", int_color=0xffff00ff)
+
+#: :class:`Color`: White color instance.
+white = Color(name="white", int_color=0xffffffff)
+
+#: :class:`Color`: Instance representing no color (i.e., lights off).
+off = Color(name="off")

anki_vector/configure/__main__.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+
+"""
+***Anki Vector Python SDK Setup***
+
+Vector requires all requests be authorized by an authenticated Anki user.
+
+This script will enable this device to authenticate with your Vector
+robot for use with a Vector Python SDK program.
+
+Vector must be powered on and connected on the same network as your
+computer. By running this script, you will be asked to provide your
+Anki account credentials, and the script will download an authentication
+token and cert that will grant you access to the robot and his
+capabilities (such as camera and audio) as well as data stored on the
+robot (such as faces and photos).
+
+See the README for more information.
+
+Use of Vector and the Vector SDK is subject to Anki's Privacy Policy and Terms and Conditions.
+
+https://www.anki.com/en-us/company/privacy
+https://www.anki.com/en-us/company/terms-and-conditions
+
+"""
+
+import argparse
+import configparser
+from getpass import getpass
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import socket
+import sys
+
+from cryptography import x509
+from cryptography.hazmat.backends import default_backend
+import grpc
+import requests
+try:
+    from termcolor import colored  # pylint: disable=import-error
+except:  # pylint: disable=bare-except
+    def colored(text, color=None, on_color=None, attrs=None):  # pylint: disable=unused-argument
+        return text
+
+import anki_vector
+from anki_vector import messaging
+
+
+class ApiHandler:
+    def __init__(self, headers: dict, url: str):
+        self._headers = headers
+        self._url = url
+
+    @property
+    def headers(self):
+        return self._headers
+
+    @property
+    def url(self):
+        return self._url
+
+
+class Api:
+    def __init__(self):
+        self._handler = ApiHandler(
+            headers={
+                'User-Agent': 'Vector-sdk/{} {}/{}'.format(anki_vector.__version__,
+                                                           platform.python_implementation(),
+                                                           platform.python_version()),
+
+                'Anki-App-Key': 'aung2ieCho3aiph7Een3Ei'
+            },
+            url='https://accounts.api.anki.com/1/sessions'
+        )
+
+    @property
+    def name(self):
+        return "Anki Cloud"
+
+    @property
+    def handler(self):
+        return self._handler
+
+
+def get_serial(serial=None):
+    if not serial:
+        serial = os.environ.get('ANKI_ROBOT_SERIAL')
+        if not serial:
+            print("\n\nPlease find your robot serial number (ex. 00e20100) located on the underside of Vector, or accessible from Vector's debug screen.")
+            serial = input('Enter robot serial number: ')
+        else:
+            print("Found robot serial number in environment variable '{}'".format(colored("ANKI_ROBOT_SERIAL", "green")))
+    serial = serial.lower()
+    print("Using robot serial number: {}".format(colored(serial, "cyan")))
+    return serial
+
+
+def get_cert(serial=None):
+    print("\n\nEnter the IP address and webserver port of your wire-pod instance (ex. 192.168.1.50:8080) (:8080 is the default port)\nLeave this blank and press enter if you want this script to attempt to automatically connect to your wire-pod instance via escapepod.local.")
+    podip = input("Enter wire-pod ip: ")
+    if podip == "":
+        podip = "escapepod.local:8080"
+    serial = get_serial(serial)
+    print("\nDownloading Vector certificate from wire-pod...", end="")
+    sys.stdout.flush()
+    r = requests.get('http://{}/session-certs/{}'.format(podip, serial))
+    if r.status_code != 200:
+        print(colored(" ERROR", "red"))
+        sys.exit(r.content)
+    print(colored(" DONE", "green"))
+    cert = r.content
+    return cert, serial
+
+
+def user_authentication(session_id: bytes, cert: bytes, ip: str, name: str) -> str:
+    # Pin the robot certificate for opening the channel
+    creds = grpc.ssl_channel_credentials(root_certificates=cert)
+
+    print("Attempting to download guid from {} at {}:443...".format(colored(name, "cyan"), colored(ip, "cyan")), end="")
+    sys.stdout.flush()
+    channel = grpc.secure_channel("{}:443".format(ip), creds,
+                                  options=(("grpc.ssl_target_name_override", name,),))
+
+    # Verify the connection to Vector is able to be established (client-side)
+    try:
+        # Explicitly grab _channel._channel to test the underlying grpc channel directly
+        grpc.channel_ready_future(channel).result(timeout=15)
+    except grpc.FutureTimeoutError:
+        print(colored(" ERROR", "red"))
+        sys.exit("\nUnable to connect to Vector\n"
+                 "Please be sure to connect via the Vector companion app first, and connect your computer to the same network as your Vector.")
+
+    try:
+        interface = messaging.client.ExternalInterfaceStub(channel)
+        request = messaging.protocol.UserAuthenticationRequest(
+            user_session_id=session_id.encode('utf-8'),
+            client_name=socket.gethostname().encode('utf-8'))
+        response = interface.UserAuthentication(request)
+        if response.code != messaging.protocol.UserAuthenticationResponse.AUTHORIZED:  # pylint: disable=no-member
+            print(colored(" ERROR", "red"))
+            sys.exit("\nFailed to authorize request:\n"
+                     "Please be sure to first set up Vector using the companion app.")
+    except grpc.RpcError as e:
+        print(colored(" ERROR", "red"))
+        sys.exit("\nFailed to authorize request:\n"
+                 "An unknown error occurred '{}'".format(e))
+
+    print(colored(" DONE\n", "green"))
+    return response.client_token_guid
+
+
+def get_session_token(api, username=None):
+    print("Enter your email and password. Make sure to use the same account that was used to set up your Vector.")
+    if not username:
+        username = input("Enter Email: ")
+    else:
+        print("Using email from command line: {}".format(colored(username, "cyan")))
+    password = getpass("Enter Password: ")
+    payload = {'username': username, 'password': password}
+
+    print("\nAuthenticating with {}...".format(api.name), end="")
+    sys.stdout.flush()
+    r = requests.post(api.handler.url, data=payload, headers=api.handler.headers)
+    if r.status_code != 200:
+        print(colored(" ERROR", "red"))
+        sys.exit(r.content)
+    print(colored(" DONE\n", "green"))
+    return json.loads(r.content)
+
+
+def standardize_name(robot_name):
+    # Extend the name if not enough is provided
+    if len(robot_name) == 4:
+        robot_name = "Vector-{}".format(robot_name.upper())
+    # Fix possible capitalization and space/dash/etc.
+    if re.match("[Vv]ector.[A-Za-z0-9]{4}", robot_name):
+        robot_name = "V{}-{}".format(robot_name[1:-5], robot_name[-4:].upper())
+    # Check that the end is valid
+    if re.match("Vector-[A-Z0-9]{4}", robot_name):
+        return robot_name
+    print(colored(" ERROR", "red"))
+    sys.exit("Invalid robot name. Please match the format exactly. Example: Vector-A1B2")
+
+
+def get_name_and_ip(robot_name=None, ip=None):
+    if not robot_name:
+        robot_name = os.environ.get('VECTOR_ROBOT_NAME')
+        if not robot_name:
+            print("\n\nFind your robot name (ex. Vector-A1B2) by placing Vector on the charger and double-clicking Vector's backpack button.")
+            robot_name = input("Enter robot name: ")
+        else:
+            print("Found robot name in environment variable '{}'".format(colored("VECTOR_ROBOT_NAME", "green")))
+    robot_name = standardize_name(robot_name)
+    print("Using robot name: {}".format(colored(robot_name, "cyan")))
+    if not ip:
+        ip = os.environ.get('ANKI_ROBOT_HOST')
+        if not ip:
+            print("\n\nFind your robot ip address (ex. 192.168.42.42) by placing Vector on the charger, double-clicking Vector's backpack button,\n"
+                  "then raising and lowering his arms. If you see {} on his face, reconnect Vector to your WiFi using the Vector Companion App.".format(colored("XX.XX.XX.XX", "red")))
+            ip = input("Enter robot ip: ")
+        else:
+            print("Found robot ip address in environment variable '{}'".format(colored("ANKI_ROBOT_HOST", "green")))
+    print("Using IP: {}".format(colored(ip, "cyan")))
+    return robot_name, ip
+
+
+def save_cert(cert, name, serial, anki_dir):
+    """Write Vector's certificate to a file located in the user's home directory"""
+    os.makedirs(str(anki_dir), exist_ok=True)
+    cert_file = str(anki_dir / "{name}-{serial}.cert".format(name=name, serial=serial))
+    print("Writing certificate file to '{}'...\n".format(colored(cert_file, "cyan")))
+    with os.fdopen(os.open(cert_file, os.O_WRONLY | os.O_CREAT, 0o600), 'wb') as f:
+        f.write(cert)
+    return cert_file
+
+
+def validate_cert_name(cert_file, robot_name):
+    """Validate the name on Vector's certificate against the user-provided name"""
+    with open(cert_file, "rb") as f:
+        cert_file = f.read()
+        cert = x509.load_pem_x509_certificate(cert_file, default_backend())
+        for fields in cert.subject:
+            current = str(fields.oid)
+            if "commonName" in current:
+                common_name = fields.value
+                if common_name != robot_name:
+                    print(colored(" ERROR", "red"))
+                    sys.exit("The name of the certificate ({}) does not match the name provided ({}).\n"
+                             "Please verify the name, and try again.".format(common_name, robot_name))
+                else:
+                    return
+
+
+def write_config(serial, cert_file=None, ip=None, name=None, guid=None, clear=True):
+    home = Path.home()
+    config_file = str(home / ".anki_vector" / "sdk_config.ini")
+    print("Writing config file to '{}'...".format(colored(config_file, "cyan")))
+
+    config = configparser.ConfigParser(strict=False)
+
+    try:
+        config.read(config_file)
+    except configparser.ParsingError:
+        if os.path.exists(config_file):
+            os.rename(config_file, config_file + "-error")
+    if clear:
+        config[serial] = {}
+    if cert_file:
+        config[serial]["cert"] = cert_file
+    if ip:
+        config[serial]["ip"] = ip
+    if name:
+        config[serial]["name"] = name
+    if guid:
+        config[serial]["guid"] = guid.decode("utf-8")
+    temp_file = config_file + "-temp"
+    if os.path.exists(config_file):
+        os.rename(config_file, temp_file)
+    try:
+        with os.fdopen(os.open(config_file, os.O_WRONLY | os.O_CREAT, 0o600), 'w') as f:
+            config.write(f)
+    except Exception as e:
+        if os.path.exists(temp_file):
+            os.rename(temp_file, config_file)
+        raise e
+    else:
+        if os.path.exists(temp_file):
+            os.remove(temp_file)
+
+
+def main(api):
+    parser = argparse.ArgumentParser(description=("Vector requires all requests be authorized by an authenticated Anki user. "
+                                                  "This script will enable this device to authenticate with your Vector "
+                                                  "robot for use with a Vector Python SDK program."),
+                                     epilog=("See the README for more information. "
+                                             "Use of Vector and the Vector SDK is subject to Anki's Privacy Policy and Terms and Conditions. "
+                                             "https://www.anki.com/en-us/company/privacy and "
+                                             "https://www.anki.com/en-us/company/terms-and-conditions"))
+    parser.add_argument("-e", "--email", help="The email used by your Anki account.")
+    parser.add_argument("-i", "--ip", help=("Your robot ip address (ex. 192.168.42.42). "
+                                            "It may be found by placing Vector on the charger, "
+                                            "double-clicking Vector's backpack button, "
+                                            "then raising and lowering his arms. "
+                                            "If you see {} on his face, "
+                                            "reconnect Vector to your WiFi using the Vector Companion App.".format(colored("XX.XX.XX.XX", "red"))))
+    parser.add_argument("-n", "--name", help=("Your robot name (ex. Vector-A1B2). "
+                                              "It may be found by placing Vector on the charger and double-clicking Vector's backpack button."))
+    parser.add_argument("-s", "--serial", help=("Your robot serial number (ex. 00e20100). "
+                                                "It is located on the underside of Vector, or accessible from Vector's debug screen."))
+    parser.add_argument("-u", "--update", dest="new_ip", help=("Update the stored ip for Vector. This makes it easier to transfer between networks."))
+    args = parser.parse_args()
+
+    if args.new_ip:
+        serial = get_serial(args.serial)
+        write_config(serial, ip=args.new_ip, clear=False)
+        print(colored("\nIP Updated!", "green"))
+        sys.exit()
+
+    print(__doc__)
+
+    valid = ["y", "Y", "yes", "YES"]
+    environ = input("Do you wish to proceed? (y/n) ")
+    if environ not in valid:
+        sys.exit("Stopping...")
+
+    name, ip = get_name_and_ip(args.name, args.ip)
+    cert, serial = get_cert(args.serial)
+
+    home = Path.home()
+    anki_dir = home / ".anki_vector"
+
+    cert_file = save_cert(cert, name, serial, anki_dir)
+    validate_cert_name(cert_file, name)
+
+    # token = get_session_token(api, args.email)
+    # if not token.get("session"):
+    #     sys.exit("Session error: {}".format(token))
+    token = "2vMhFgktH3Jrbemm2WHkfGN"
+
+    guid = user_authentication(token, cert, ip, name)
+
+    # Store credentials in the .anki_vector directory's sdk_config.ini file
+    write_config(serial, cert_file, ip, name, guid)
+    print(colored("\nSUCCESS!", "green"))
+
+
+if __name__ == "__main__":
+    main(Api())