franky-control 1.0.2__cp38-cp38-manylinux_2_28_x86_64.whl

franky/motion.py

@@ -0,0 +1,12 @@
+from typing import Union
+
+from ._franky import BaseCartesianPoseMotion, BaseCartesianVelocityMotion, BaseJointPositionMotion, \
+    BaseJointVelocityMotion, BaseTorqueMotion
+
+Motion = Union[
+    BaseCartesianPoseMotion,
+    BaseCartesianVelocityMotion,
+    BaseJointPositionMotion,
+    BaseJointVelocityMotion,
+    BaseTorqueMotion
+]

franky/reaction.py

@@ -0,0 +1,43 @@
+from ._franky import Condition, BaseCartesianPoseMotion, BaseCartesianVelocityMotion, BaseJointPositionMotion, \
+    BaseJointVelocityMotion, BaseTorqueMotion, \
+    CartesianPoseReaction as _CartesianPoseReaction, \
+    CartesianVelocityReaction as _CartesianVelocityReaction, \
+    JointPositionReaction as _JointPositionReaction, \
+    JointVelocityReaction as _JointVelocityReaction, \
+    TorqueReaction as _TorqueReaction
+
+from .motion import Motion
+
+
+class Reaction:
+    _control_signal_type = None
+
+    def __new__(cls, condition: Condition, motion: Motion):
+        for reaction_type in _REACTION_TYPES:
+            if isinstance(motion, reaction_type._motion_type):
+                return reaction_type.__new__(reaction_type, condition, motion)
+        raise TypeError(f"Unknown motion type {type(motion)}.")
+
+
+class CartesianPoseReaction(_CartesianPoseReaction, Reaction):
+    _motion_type = BaseCartesianPoseMotion
+
+
+class CartesianVelocityReaction(_CartesianVelocityReaction, Reaction):
+    _motion_type = BaseCartesianVelocityMotion
+
+
+class JointPositionReaction(_JointPositionReaction, Reaction):
+    _motion_type = BaseJointPositionMotion
+
+
+class JointVelocityReaction(_JointVelocityReaction, Reaction):
+    _motion_type = BaseJointVelocityMotion
+
+
+class TorqueReaction(_TorqueReaction, Reaction):
+    _motion_type = BaseTorqueMotion
+
+
+_REACTION_TYPES = [
+    CartesianPoseReaction, CartesianVelocityReaction, JointPositionReaction, JointVelocityReaction, TorqueReaction]

franky/robot.py

@@ -0,0 +1,8 @@
+from ._franky import _RobotInternal
+
+from .robot_web_session import RobotWebSession
+
+
+class Robot(_RobotInternal):
+    def create_web_session(self, username: str, password: str):
+        return RobotWebSession(self, username, password)

franky/robot_web_session.py

@@ -0,0 +1,183 @@
+import base64
+import hashlib
+import http.client
+import json
+import ssl
+import time
+import urllib.parse
+from http.client import HTTPSConnection, HTTPResponse
+from typing import Dict, Optional, Any, Literal
+from urllib.error import HTTPError
+
+
+class FrankaAPIError(Exception):
+    def __init__(self, target: str, http_code: int, http_reason: str, headers: Dict[str, str], message: str):
+        super().__init__(
+            f"Franka API returned error {http_code} ({http_reason}) when accessing end-point {target}: {message}")
+        self.target = target
+        self.http_code = http_code
+        self.headers = headers
+        self.message = message
+
+
+class RobotWebSession:
+    def __init__(self, fci_hostname: str, username: str, password: str):
+        self.__fci_hostname = fci_hostname
+        self.__username = username
+        self.__password = password
+
+        self.__client = None
+        self.__token = None
+        self.__control_token = None
+        self.__control_token_id = None
+
+    @staticmethod
+    def __encode_password(user: str, password: str) -> str:
+        bs = ",".join([str(b) for b in hashlib.sha256((password + "#" + user + "@franka").encode("utf-8")).digest()])
+        return base64.encodebytes(bs.encode("utf-8")).decode("utf-8")
+
+    def _send_api_request(self, target: str, headers: Optional[Dict[str, str]] = None, body: Optional[Any] = None,
+                          method: Literal["GET", "POST", "DELETE"] = "POST"):
+        _headers = {
+            "Cookie": f"authorization={self.__token}"
+        }
+        if headers is not None:
+            _headers.update(headers)
+        self.__client.request(method, target, headers=_headers, body=body)
+        res: HTTPResponse = self.__client.getresponse()
+        if res.getcode() != 200:
+            raise FrankaAPIError(target, res.getcode(), res.reason, dict(res.headers), res.read().decode("utf-8"))
+        return res.read()
+
+    def send_api_request(self, target: str, headers: Optional[Dict[str, str]] = None, body: Optional[Any] = None,
+                         method: Literal["GET", "POST", "DELETE"] = "POST"):
+        last_error = None
+        for i in range(3):
+            try:
+                return self._send_api_request(target, headers, body, method)
+            except http.client.RemoteDisconnected as ex:
+                last_error = ex
+        raise last_error
+
+    def send_control_api_request(self, target: str, headers: Optional[Dict[str, str]] = None,
+                                 body: Optional[Any] = None,
+                                 method: Literal["GET", "POST", "DELETE"] = "POST"):
+        if headers is None:
+            headers = {}
+        self.__check_control_token()
+        _headers = {
+            "X-Control-Token": self.__control_token
+        }
+        _headers.update(headers)
+        return self.send_api_request(target, headers=_headers, method=method, body=body)
+
+    def open(self):
+        if self.is_open:
+            raise RuntimeError("Session is already open.")
+        self.__client = HTTPSConnection(self.__fci_hostname, timeout=12, context=ssl._create_unverified_context())
+        self.__client.connect()
+        payload = json.dumps(
+            {"login": self.__username, "password": self.__encode_password(self.__username, self.__password)})
+        self.__token = self.send_api_request(
+            "/admin/api/login", headers={"content-type": "application/json"},
+            body=payload).decode("utf-8")
+        return self
+
+    def close(self):
+        if not self.is_open:
+            raise RuntimeError("Session is not open.")
+        if self.__control_token is not None:
+            self.release_control()
+        self.__token = None
+        self.__client.close()
+
+    def __enter__(self):
+        self.open()
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def __check_control_token(self):
+        if self.__control_token is None:
+            raise RuntimeError("Client does not have control. Call take_control() first.")
+
+    def take_control(self, wait_timeout: float = 10.0):
+        if self.__control_token is None:
+            res = self.send_api_request(
+                "/admin/api/control-token/request", headers={"content-type": "application/json"},
+                body=json.dumps({"requestedBy": self.__username}))
+            response_dict = json.loads(res)
+            self.__control_token = response_dict["token"]
+            self.__control_token_id = response_dict["id"]
+            # One should probably use websockets here but that would introduce another dependency
+            start = time.time()
+            while time.time() - start < wait_timeout and not self.has_control():
+                time.sleep(1.0)
+        return self.has_control()
+
+    def release_control(self):
+        if self.__control_token is not None:
+            self.send_control_api_request(
+                "/admin/api/control-token", headers={"content-type": "application/json"}, method="DELETE",
+                body=json.dumps({"token": self.__control_token}))
+            self.__control_token = None
+            self.__control_token_id = None
+
+    def enable_fci(self):
+        self.send_control_api_request(
+            "/desk/api/system/fci", headers={"content-type": "application/x-www-form-urlencoded"},
+            body=f"token={urllib.parse.quote(base64.b64encode(self.__control_token.encode('ascii')))}")
+
+    def has_control(self):
+        if self.__control_token_id is not None:
+            status = self.get_system_status()
+            active_token = status["controlToken"]["activeToken"]
+            return active_token is not None and active_token["id"] == self.__control_token_id
+        return False
+
+    def start_task(self, task: str):
+        self.send_api_request(
+            "/desk/api/execution", headers={"content-type": "application/x-www-form-urlencoded"},
+            body=f"id={task}")
+
+    def unlock_brakes(self):
+        self.send_control_api_request(
+            "/desk/api/joints/unlock", headers={"content-type": "application/x-www-form-urlencoded"})
+
+    def lock_brakes(self):
+        self.send_control_api_request(
+            "/desk/api/joints/lock", headers={"content-type": "application/x-www-form-urlencoded"})
+
+    def set_mode_programming(self):
+        self.send_control_api_request(
+            "/desk/api/operating-mode/programming", headers={"content-type": "application/x-www-form-urlencoded"})
+
+    def set_mode_execution(self):
+        self.send_control_api_request(
+            "/desk/api/operating-mode/execution", headers={"content-type": "application/x-www-form-urlencoded"})
+
+    def get_system_status(self):
+        return json.loads(self.send_api_request("/admin/api/system-status", method="GET").decode("utf-8"))
+
+    def execute_self_test(self):
+        if self.get_system_status()["safety"]["recoverableErrors"]["td2Timeout"]:
+            self.send_control_api_request(
+                "/admin/api/safety/recoverable-safety-errors/acknowledge?error_id=TD2Timeout")
+        response = json.loads(self.send_control_api_request(
+            "/admin/api/safety/td2-tests/execute", headers={"content-type": "application/json"}).decode("utf-8"))
+        assert response["code"] == "SuccessResponse"
+        time.sleep(0.5)
+        while self.get_system_status()["safety"]["safetyControllerStatus"] == "SelfTest":
+            time.sleep(0.5)
+
+    @property
+    def client(self) -> HTTPSConnection:
+        return self.__client
+
+    @property
+    def token(self) -> str:
+        return self.__token
+
+    @property
+    def is_open(self) -> bool:
+        return self.__token is not None

franky_control-1.0.2.dist-info/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.