franky-control 1.0.2__cp38-cp38-manylinux_2_34_x86_64.whl → 1.1.1__cp38-cp38-manylinux_2_34_x86_64.whl

franky/__init__.py

@@ -1,12 +1,17 @@
 from .robot import Robot
-from .robot_web_session import RobotWebSession
+from .robot_web_session import (
+    RobotWebSession,
+    RobotWebSessionError,
+    FrankaAPIError,
+    TakeControlTimeoutError,
+)
 from .reaction import (
     Reaction,
     TorqueReaction,
     JointVelocityReaction,
     JointPositionReaction,
     CartesianVelocityReaction,
-    CartesianPoseReaction
+    CartesianPoseReaction,
 )
 from .motion import Motion
 from ._franky import *

franky/motion.py

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

franky/reaction.py

@@ -1,10 +1,16 @@
-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 ._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
 
@@ -40,4 +46,9 @@ class TorqueReaction(_TorqueReaction, Reaction):
 
 
 _REACTION_TYPES = [
-    CartesianPoseReaction, CartesianVelocityReaction, JointPositionReaction, JointVelocityReaction, TorqueReaction]
+    CartesianPoseReaction,
+    CartesianVelocityReaction,
+    JointPositionReaction,
+    JointVelocityReaction,
+    TorqueReaction,
+]

franky/robot_web_session.py

@@ -7,22 +7,37 @@ 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):
+class RobotWebSessionError(Exception):
+    pass
+
+
+class FrankaAPIError(RobotWebSessionError):
+    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}")
+            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 TakeControlTimeoutError(RobotWebSessionError):
+    pass
+
+
 class RobotWebSession:
-    def __init__(self, fci_hostname: str, username: str, password: str):
-        self.__fci_hostname = fci_hostname
+    def __init__(self, hostname: str, username: str, password: str):
+        self.__hostname = hostname
         self.__username = username
         self.__password = password
 
@@ -33,24 +48,45 @@ class RobotWebSession:
 
     @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()])
+        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}"
-        }
+    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"))
+            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"):
+    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:
@@ -59,28 +95,38 @@ class RobotWebSession:
                 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"):
+    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 = {"X-Control-Token": self.__control_token}
         _headers.update(headers)
         return self.send_api_request(target, headers=_headers, method=method, body=body)
 
-    def open(self):
+    def open(self, timeout: float = 30.0):
         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 = HTTPSConnection(
+            self.__hostname, timeout=timeout, context=ssl._create_unverified_context()
+        )
         self.__client.connect()
         payload = json.dumps(
-            {"login": self.__username, "password": self.__encode_password(self.__username, self.__password)})
+            {
+                "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")
+            "/admin/api/login",
+            headers={"content-type": "application/json"},
+            body=payload,
+        ).decode("utf-8")
         return self
 
     def close(self):
@@ -92,82 +138,125 @@ class RobotWebSession:
         self.__client.close()
 
     def __enter__(self):
-        self.open()
+        return 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.")
+            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:
+    def take_control(self, wait_timeout: float = 30.0, force: bool = False):
+        if not self.has_control():
             res = self.send_api_request(
-                "/admin/api/control-token/request", headers={"content-type": "application/json"},
-                body=json.dumps({"requestedBy": self.__username}))
+                f"/admin/api/control-token/request{'?force' if force else ''}",
+                headers={"content-type": "application/json"},
+                body=json.dumps({"requestedBy": self.__username}),
+            )
+            if force:
+                print(
+                    "Forcibly taking control: "
+                    f"Please physically take control by pressing the top button on the FR3 within {wait_timeout}s!"
+                )
             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()
+            has_control = self.has_control()
+            while time.time() - start < wait_timeout and not has_control:
+                time.sleep(max(0.0, min(1.0, wait_timeout - (time.time() - start))))
+                has_control = self.has_control()
+            if not has_control:
+                raise TakeControlTimeoutError(
+                    f"Timed out waiting for control to be granted after {wait_timeout}s."
+                )
 
     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}))
+                "/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')))}")
+            "/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 (
+                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}")
+            "/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"})
+            "/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"})
+            "/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"})
+            "/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"})
+            "/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"))
+        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"))
+                "/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":
+        while (
+            self.get_system_status()["safety"]["safetyControllerStatus"] == "SelfTest"
+        ):
             time.sleep(0.5)
 
     @property

{franky_control-1.0.2.dist-info → franky_control-1.1.1.dist-info}/LICENSE

@@ -162,4 +162,4 @@ General Public License ever published by the Free Software Foundation.
 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.
+Library.

{franky_control-1.0.2.dist-info → franky_control-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: franky-control
-Version: 1.0.2
+Version: 1.1.1
 Summary: High-level control library for Franka robots.
 Home-page: https://github.com/TimSchneider42/franky
 Author: Tim Schneider
@@ -64,25 +64,25 @@ at [https://timschneider42.github.io/franky/](https://timschneider42.github.io/f
 
 ## 🚀 Features
 
-- **Control your Franka robot directly from Python in just a few lines!**  
+- **Control your Franka robot directly from Python in just a few lines!**
   No more endless hours setting up ROS, juggling packages, or untangling dependencies. Just `pip install` — no ROS at all.
 
-- **[Four control modes](#motion-types)**: [Cartesian position](#cartesian-position-control), [Cartesian velocity](#cartesian-velocity-control), [Joint position](#joint-position-control), [Joint velocity](#joint-velocity-control)  
+- **[Four control modes](#motion-types)**: [Cartesian position](#cartesian-position-control), [Cartesian velocity](#cartesian-velocity-control), [Joint position](#joint-position-control), [Joint velocity](#joint-velocity-control)
   Franky uses [Ruckig](https://github.com/pantor/ruckig) to generate smooth, time-optimal trajectories while respecting velocity, acceleration, and jerk limits.
 
 - **[Real-time control from Python and C++](#real-time-motions)**
   Need to change the target while the robot’s moving? No problem. Franky re-plans trajectories on the fly so that you can preempt motions anytime.
 
-- **[Reactive behavior](#-real-time-reactions)**  
+- **[Reactive behavior](#-real-time-reactions)**
   Robots don’t always go according to plan. Franky lets you define reactions to unexpected events—like contact with the environment — so you can change course in real-time.
 
-- **[Motion and reaction callbacks](#motion-callbacks)**  
+- **[Motion and reaction callbacks](#motion-callbacks)**
   Want to monitor what’s happening under the hood? Add callbacks to your motions and reactions. They won’t block the control thread and are super handy for debugging or logging.
 
-- **Things are moving too fast? [Tune the robot's dynamics to your needs](#-robot)**  
+- **Things are moving too fast? [Tune the robot's dynamics to your needs](#-robot)**
   Adjust max velocity, acceleration, and jerk to match your setup or task. Fine control for smooth, safe operation.
 
-- **Full Python access to the libfranka API**  
+- **Full Python access to the libfranka API**
   Want to tweak impedance, read the robot state, set force thresholds, or mess with the Jacobian? Go for it. If libfranka supports it, chances are Franky does, too.
 
 ## 📖 Python Quickstart Guide
@@ -97,6 +97,7 @@ otherwise, follow the [setup instructions](#setup) first.
 
 Now we are already ready to go!
 Unlock the brakes in the web interface, activate FCI, and start coding:
+
 ```python
 from franky import *
 
@@ -196,6 +197,60 @@ pip install numpy
 pip install --no-index --find-links=./dist franky-control
 ```
 
+### Using Docker
+
+To use Franky within Docker we provide a [Dockerfile](docker/run/Dockerfile) and
+accompanying [docker-compose](docker-compose.yml) file.
+
+```bash
+git clone --recurse-submodules https://github.com/timschneider42/franky.git
+cd franky/
+docker compose build franky-run
+```
+
+To use another version of libfranka than the default (0.15.0) add a build argument:
+
+```bash
+docker compose build franky-run --build-arg LIBFRANKA_VERSION=0.9.2
+```
+
+To run the container:
+
+```bash
+docker compose run franky-run bash
+```
+
+The container requires access to the host machines network *and* elevated user rights to allow the docker user to set RT
+capabilities of the processes run from within it.
+
+### Can I use CUDA jointly with Franky?
+
+Yes. However, you need to set `IGNORE_PREEMPT_RT_PRESENCE=1` during the installation and all subsequent updates of the CUDA drivers on the real-time kernel.
+
+First, make sure that you have rebooted your system after installing the real-time kernel.
+Then, add `IGNORE_PREEMPT_RT_PRESENCE=1` to `/etc/environment`, call `export IGNORE_PREEMPT_RT_PRESENCE=1` to also set it in the current session and follow the instructions of Nvidia to install CUDA on your system.
+
+If you are on Ubuntu, you can also use [this](tools/install_cuda_realtime.bash) script to install CUDA on your real-time system:
+```bash
+# Download the script
+wget https://raw.githubusercontent.com/timschneider42/franky/master/tools/install_cuda_realtime.bash
+
+# Inspect the script to ensure it does what you expect
+
+# Make it executable
+chmod +x install_cuda_realtime.bash
+
+# Execute the script
+./install_cuda_realtime.bash
+```
+
+Alternatively, if you are a cowboy and do not care about security, you can also use this one-liner to directly call the script without checking it:
+```bash
+bash <(wget -qO- https://raw.githubusercontent.com/timschneider42/franky/master/tools/install_cuda_realtime.bash)
+```
+
+### Building Franky
+
 Franky is based on [libfranka](https://github.com/frankaemika/libfranka), [Eigen](https://eigen.tuxfamily.org) for
 transformation calculations and [pybind11](https://github.com/pybind/pybind11) for the Python bindings.
 As the Franka is sensitive to acceleration discontinuities, it requires jerk-constrained motion generation, for which
@@ -226,32 +281,6 @@ pip install .
 Make sure that the built library `_franky.cpython-3**-****-linux-gnu.so` is in the Python path, e.g. by adjusting
 `PYTHONPATH` accordingly.
 
-#### Using Docker
-
-To use Franky within Docker we provide a [Dockerfile](docker/run/Dockerfile) and
-accompanying [docker-compose](docker-compose.yml) file.
-
-```bash
-git clone --recurse-submodules https://github.com/timschneider42/franky.git
-cd franky/
-docker compose build franky-run
-```
-
-To use another version of libfranka than the default (0.15.0) add a build argument:
-
-```bash
-docker compose build franky-run --build-arg LIBFRANKA_VERSION=0.9.2
-```
-
-To run the container:
-
-```bash
-docker compose run franky-run bash
-```
-
-The container requires access to the host machines network *and* elevated user rights to allow the docker user to set RT
-capabilities of the processes run from within it.
-
 #### Building Franky with Docker
 
 For building Franky and its wheels, we provide another Docker container that can also be launched using docker-compose:
@@ -299,6 +328,8 @@ motion = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion)
 ```
 
+Before executing any code, make sure that you have enabled the Franka Control Interface (FCI) in the Franka UI web interface.
+
 Furthermore, we will introduce methods for geometric calculations, for moving the robot according to different motion
 types, how to implement real-time reactions and changing waypoints in real time as well as controlling the gripper.
 
@@ -340,7 +371,9 @@ robot.recover_from_errors()
 robot.relative_dynamics_factor = 0.05
 
 # Alternatively, you can define each constraint individually
-robot.relative_dynamics_factor = RelativeDynamicsFactor(velocity=0.1, acceleration=0.05, jerk=0.1)
+robot.relative_dynamics_factor = RelativeDynamicsFactor(
+    velocity=0.1, acceleration=0.05, jerk=0.1
+)
 
 # Or, for more finegrained access, set individual limits
 robot.translation_velocity_limit.set(3.0)
@@ -372,7 +405,7 @@ The robot state can be retrieved by accessing the following properties:
   obtained
   from [franka::RobotState::O_T_EE](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a193781d47722b32925e0ea7ac415f442)
   and [franka::RobotState::O_dP_EE_c](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a4be112bd1a9a7d777a67aea4a18a8dcc).
-* `current_joint_position`: Object of type `franky.JointState`, which contains the joint positions and velocities
+* `current_joint_state`: Object of type `franky.JointState`, which contains the joint positions and velocities
   obtained
   from [franka::RobotState::q](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#ade3335d1ac2f6c44741a916d565f7091)
   and [franka::RobotState::dq](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a706045af1b176049e9e56df755325bd2).
@@ -408,7 +441,8 @@ ee_pose_kin = robot.model.pose(Frame.EndEffector, q, f_t_ee, ee_t_k)
 # Get the jacobian of the current robot state
 jacobian = robot.model.body_jacobian(Frame.EndEffector, state)
 
-# Alternatively, just get the URDF as string and do the kinematics computation yourself (only for libfranka >= 0.15.0)
+# Alternatively, just get the URDF as string and do the kinematics computation yourself (only
+# for libfranka >= 0.15.0)
 urdf_model = robot.model_urdf
 ```
 
@@ -418,8 +452,7 @@ and [Model](https://timschneider42.github.io/franky/classfranky_1_1_model.html)
 
 ### <a id="motion-types" /> 🏃‍♂️ Motion Types
 
-Franky currently supports four different impedance control modes: **joint position control**, **joint velocity control
-**, **cartesian position control**, and **cartesian velocity control**.
+Franky currently supports four different impedance control modes: **joint position control**, **joint velocity control**, **cartesian position control**, and **cartesian velocity control**.
 Each of these control modes is invoked by passing the robot an appropriate _Motion_ object.
 
 In the following, we provide a brief example for each motion type implemented by Franky in Python.
@@ -437,28 +470,37 @@ from franky import *
 # A point-to-point motion in the joint space
 m_jp1 = JointMotion([-0.3, 0.1, 0.3, -1.4, 0.1, 1.8, 0.7])
 
-# A motion in joint space with multiple waypoints
-m_jp2 = JointWaypointMotion([
-    JointWaypoint([-0.3, 0.1, 0.3, -1.4, 0.1, 1.8, 0.7]),
-    JointWaypoint([0.0, 0.3, 0.3, -1.5, -0.2, 1.5, 0.8]),
-    JointWaypoint([0.1, 0.4, 0.3, -1.4, -0.3, 1.7, 0.9])
-])
-
-# Intermediate waypoints also permit to specify target velocities. The default target velocity is 0, meaning that the
-# robot will stop at every waypoint.
-m_jp3 = JointWaypointMotion([
-    JointWaypoint([-0.3, 0.1, 0.3, -1.4, 0.1, 1.8, 0.7]),
-    JointWaypoint(
-        JointState(
-            position=[0.0, 0.3, 0.3, -1.5, -0.2, 1.5, 0.8],
-            velocity=[0.1, 0.0, 0.0, 0.0, -0.0, 0.0, 0.0])),
-    JointWaypoint([0.1, 0.4, 0.3, -1.4, -0.3, 1.7, 0.9])
-])
-
-# Stop the robot in joint position control mode. The difference of JointStopMotion to other stop motions such as 
-# CartesianStopMotion is that # JointStopMotion # stops the robot in joint position control mode while 
-# CartesianStopMotion stops it in cartesian pose control mode. The difference becomes relevant when asynchronous move 
-# commands are being sent or reactions are being used(see below).
+# A motion in joint space with multiple waypoints. The robot will stop at each of these
+# waypoints. If you want the robot to move continuously, you have to specify a target velocity
+# at every waypoint as shown in the example following this one.
+m_jp2 = JointWaypointMotion(
+    [
+        JointWaypoint([-0.3, 0.1, 0.3, -1.4, 0.1, 1.8, 0.7]),
+        JointWaypoint([0.0, 0.3, 0.3, -1.5, -0.2, 1.5, 0.8]),
+        JointWaypoint([0.1, 0.4, 0.3, -1.4, -0.3, 1.7, 0.9]),
+    ]
+)
+
+# Intermediate waypoints also permit to specify target velocities. The default target velocity
+# is 0, meaning that the robot will stop at every waypoint.
+m_jp3 = JointWaypointMotion(
+    [
+        JointWaypoint([-0.3, 0.1, 0.3, -1.4, 0.1, 1.8, 0.7]),
+        JointWaypoint(
+            JointState(
+                position=[0.0, 0.3, 0.3, -1.5, -0.2, 1.5, 0.8],
+                velocity=[0.1, 0.0, 0.0, 0.0, -0.0, 0.0, 0.0],
+            )
+        ),
+        JointWaypoint([0.1, 0.4, 0.3, -1.4, -0.3, 1.7, 0.9]),
+    ]
+)
+
+# Stop the robot in joint position control mode. The difference of JointStopMotion to other
+# stop-motions such as CartesianStopMotion is that JointStopMotion stops the robot in joint
+# position control mode while CartesianStopMotion stops it in cartesian pose control mode. The
+# difference becomes relevant when asynchronous move commands are being sent or reactions are
+# being used(see below).
 m_jp4 = JointStopMotion()
 ```
 
@@ -468,18 +510,30 @@ m_jp4 = JointStopMotion()
 from franky import *
 
 # Accelerate to the given joint velocity and hold it. After 1000ms stop the robot again.
-m_jv1 = JointVelocityMotion([0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], duration=Duration(1000))
-
-# Joint velocity motions also support waypoints. Unlike in joint position control, a joint velocity waypoint is a
-# target velocity to be reached. This particular example first accelerates the joints, holds the velocity for 1s, then
-# reverses direction for 2s, reverses direction again for 1s, and finally stops. It is important not to forget to stop
-# the robot at the end of such a sequence, as it will otherwise throw an error.
-m_jv2 = JointVelocityWaypointMotion([
-    JointVelocityWaypoint([0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], hold_target_duration=Duration(1000)),
-    JointVelocityWaypoint([-0.1, -0.3, 0.1, -0.0, -0.1, 0.2, -0.4], hold_target_duration=Duration(2000)),
-    JointVelocityWaypoint([0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], hold_target_duration=Duration(1000)),
-    JointVelocityWaypoint([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
-])
+m_jv1 = JointVelocityMotion(
+    [0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], duration=Duration(1000)
+)
+
+# Joint velocity motions also support waypoints. Unlike in joint position control, a joint
+# velocity waypoint is a target velocity to be reached. This particular example first
+# accelerates the joints, holds the velocity for 1s, then reverses direction for 2s, reverses
+# direction again for 1s, and finally stops. It is important not to forget to stop the robot
+# at the end of such a sequence, as it will otherwise throw an error.
+m_jv2 = JointVelocityWaypointMotion(
+    [
+        JointVelocityWaypoint(
+            [0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], hold_target_duration=Duration(1000)
+        ),
+        JointVelocityWaypoint(
+            [-0.1, -0.3, 0.1, -0.0, -0.1, 0.2, -0.4],
+            hold_target_duration=Duration(2000),
+        ),
+        JointVelocityWaypoint(
+            [0.1, 0.3, -0.1, 0.0, 0.1, -0.2, 0.4], hold_target_duration=Duration(1000)
+        ),
+        JointVelocityWaypoint([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]),
+    ]
+)
 
 # Stop the robot in joint velocity control mode.
 m_jv3 = JointVelocityStopMotion()
@@ -497,29 +551,44 @@ quat = Rotation.from_euler("xyz", [0, 0, math.pi / 2]).as_quat()
 m_cp1 = CartesianMotion(Affine([0.4, -0.2, 0.3], quat))
 
 # With target elbow angle (otherwise, the Franka firmware will choose by itself)
-m_cp2 = CartesianMotion(RobotPose(Affine([0.4, -0.2, 0.3], quat), elbow_state=ElbowState(0.3)))
+m_cp2 = CartesianMotion(
+    RobotPose(Affine([0.4, -0.2, 0.3], quat), elbow_state=ElbowState(0.3))
+)
 
 # A linear motion in cartesian space relative to the initial position
-# (Note that this motion is relative both in position and orientation. Hence, when the robot's end-effector is oriented
-# differently, it will move in a different direction)
+# (Note that this motion is relative both in position and orientation. Hence, when the robot's
+# end-effector is oriented differently, it will move in a different direction)
 m_cp3 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 
-# Generalization of CartesianMotion that allows for multiple waypoints
-m_cp4 = CartesianWaypointMotion([
-    CartesianWaypoint(RobotPose(Affine([0.4, -0.2, 0.3], quat), elbow_state=ElbowState(0.3))),
-    # The following waypoint is relative to the prior one and 50% slower
-    CartesianWaypoint(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative, RelativeDynamicsFactor(0.5, 1.0, 1.0))
-])
-
-# Cartesian waypoints also permit to specify target velocities
-m_cp5 = CartesianWaypointMotion([
-    CartesianWaypoint(Affine([0.5, -0.2, 0.3], quat)),
-    CartesianWaypoint(
-        CartesianState(
-            pose=Affine([0.4, -0.1, 0.3], quat),
-            velocity=Twist([-0.01, 0.01, 0.0]))),
-    CartesianWaypoint(Affine([0.3, 0.0, 0.3], quat))
-])
+# Generalization of CartesianMotion that allows for multiple waypoints. The robot will stop at
+# each of these waypoints. If you want the robot to move continuously, you have to specify a
+# target velocity at every waypoint as shown in the example following this one.
+m_cp4 = CartesianWaypointMotion(
+    [
+        CartesianWaypoint(
+            RobotPose(Affine([0.4, -0.2, 0.3], quat), elbow_state=ElbowState(0.3))
+        ),
+        # The following waypoint is relative to the prior one and 50% slower
+        CartesianWaypoint(
+            Affine([0.2, 0.0, 0.0]),
+            ReferenceType.Relative,
+            RelativeDynamicsFactor(0.5, 1.0, 1.0),
+        ),
+    ]
+)
+
+# Cartesian waypoints permit to specify target velocities
+m_cp5 = CartesianWaypointMotion(
+    [
+        CartesianWaypoint(Affine([0.5, -0.2, 0.3], quat)),
+        CartesianWaypoint(
+            CartesianState(
+                pose=Affine([0.4, -0.1, 0.3], quat), velocity=Twist([-0.01, 0.01, 0.0])
+            )
+        ),
+        CartesianWaypoint(Affine([0.3, 0.0, 0.3], quat)),
+    ]
+)
 
 # Stop the robot in cartesian position control mode.
 m_cp6 = CartesianStopMotion()
@@ -530,22 +599,37 @@ m_cp6 = CartesianStopMotion()
 ```python
 from franky import *
 
-# A cartesian velocity motion with linear (first argument) and angular (second argument) components
+# A cartesian velocity motion with linear (first argument) and angular (second argument)
+# components
 m_cv1 = CartesianVelocityMotion(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]))
 
 # With target elbow velocity
-m_cv2 = CartesianVelocityMotion(RobotVelocity(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]), elbow_velocity=-0.2))
-
-# Cartesian velocity motions also support multiple waypoints. Unlike in cartesian position control, a cartesian velocity
-# waypoint is a target velocity to be reached. This particular example first accelerates the end-effector, holds the 
-# velocity for 1s, then # reverses direction for 2s, reverses direction again for 1s, and finally stops. It is important
-# not to forget to stop # the robot at the end of such a sequence, as it will otherwise throw an error.
-m_cv4 = CartesianVelocityWaypointMotion([
-    CartesianVelocityWaypoint(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]), hold_target_duration=Duration(1000)),
-    CartesianVelocityWaypoint(Twist([-0.2, 0.1, -0.1], [-0.1, 0.1, -0.2]), hold_target_duration=Duration(2000)),
-    CartesianVelocityWaypoint(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]), hold_target_duration=Duration(1000)),
-    CartesianVelocityWaypoint(Twist()),
-])
+m_cv2 = CartesianVelocityMotion(
+    RobotVelocity(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]), elbow_velocity=-0.2)
+)
+
+# Cartesian velocity motions also support multiple waypoints. Unlike in cartesian position
+# control, a cartesian velocity waypoint is a target velocity to be reached. This particular
+# example first accelerates the end-effector, holds the velocity for 1s, then reverses
+# direction for 2s, reverses direction again for 1s, and finally stops. It is important not to
+# forget to stop the robot at the end of such a sequence, as it will otherwise throw an error.
+m_cv4 = CartesianVelocityWaypointMotion(
+    [
+        CartesianVelocityWaypoint(
+            Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]),
+            hold_target_duration=Duration(1000),
+        ),
+        CartesianVelocityWaypoint(
+            Twist([-0.2, 0.1, -0.1], [-0.1, 0.1, -0.2]),
+            hold_target_duration=Duration(2000),
+        ),
+        CartesianVelocityWaypoint(
+            Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]),
+            hold_target_duration=Duration(1000),
+        ),
+        CartesianVelocityWaypoint(Twist()),
+    ]
+)
 
 # Stop the robot in cartesian velocity control mode.
 m_cv6 = CartesianVelocityStopMotion()
@@ -574,14 +658,15 @@ The real robot can be moved by applying a motion to the robot using `move`:
 ```python
 # Before moving the robot, set an appropriate dynamics factor. We start small:
 robot.relative_dynamics_factor = 0.05
-# or alternatively, to control the scaling of velocity, acceleration, and jerk limits separately:
+# or alternatively, to control the scaling of velocity, acceleration, and jerk limits
+# separately:
 robot.relative_dynamics_factor = RelativeDynamicsFactor(0.05, 0.1, 0.15)
 # If these values are set too high, you will see discontinuity errors
 
 robot.move(m_jp1)
 
-# We can also set a relative dynamics factor in the move command. It will be multiplied with the other relative 
-# dynamics factors (robot and motion if present).
+# We can also set a relative dynamics factor in the move command. It will be multiplied with
+# the other relative dynamics factors (robot and motion if present).
 robot.move(m_jp2, relative_dynamics_factor=0.8)
 ```
 
@@ -596,7 +681,8 @@ def cb(
         time_step: Duration,
         rel_time: Duration,
         abs_time: Duration,
-        control_signal: JointPositions):
+        control_signal: JointPositions,
+):
     print(f"At time {abs_time}, the target joint positions were {control_signal.q}")
 
 
@@ -621,9 +707,10 @@ from franky import CartesianMotion, Affine, ReferenceType, Measure, Reaction
 
 motion = CartesianMotion(Affine([0.0, 0.0, 0.1]), ReferenceType.Relative)  # Move down 10cm
 
-# It is important that the reaction motion uses the same control mode as the original motion. Hence, we cannot register
-# a JointMotion as a reaction motion to a CartesianMotion.
-reaction_motion = CartesianMotion(Affine([0.0, 0.0, 0.01]), ReferenceType.Relative)  # Move up for 1cm
+# It is important that the reaction motion uses the same control mode as the original motion.
+# Hence, we cannot register a JointMotion as a reaction motion to a CartesianMotion.
+# Move up for 1cm
+reaction_motion = CartesianMotion(Affine([0.0, 0.0, 0.01]), ReferenceType.Relative)
 
 # Trigger reaction if the Z force is greater than 30N
 reaction = Reaction(Measure.FORCE_Z > 30.0, reaction_motion)
@@ -686,7 +773,8 @@ them.
 In C++ you can additionally use lambdas to define more complex behaviours:
 
 ```c++
-auto motion = CartesianMotion(RobotPose(Affine({0.0, 0.0, 0.2}), 0.0), ReferenceType::Relative);
+auto motion = CartesianMotion(
+  RobotPose(Affine({0.0, 0.0, 0.2}), 0.0), ReferenceType::Relative);
 
 // Stop motion if force is over 10N
 auto stop_motion = StopMotion<franka::CartesianPose>()
@@ -705,7 +793,7 @@ motion
         }),
       [](const franka::RobotState& state, double rel_time, double abs_time) {
         // Lambda reaction motion generator
-        // (we are just returning a stop motion, but there could be arbitrary 
+        // (we are just returning a stop motion, but there could be arbitrary
         // logic here for generating reaction motions)
         return StopMotion<franka::CartesianPose>();
       })
@@ -731,8 +819,8 @@ motion1 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion1, asynchronous=True)
 
 time.sleep(0.5)
-# Note that similar to reactions, when preempting active motions with new motions, the control mode cannot change.
-# Hence, we cannot use, e.g., a JointMotion here.
+# Note that similar to reactions, when preempting active motions with new motions, the
+# control mode cannot change. Hence, we cannot use, e.g., a JointMotion here.
 motion2 = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion2, asynchronous=True)
 ```
@@ -750,7 +838,7 @@ The next time `Robot.join_motion` or `Robot.move` are called, they will throw th
 Hence, after an asynchronous motion has finished, make sure to call `Robot.join_motion` to ensure being notified of any
 exceptions that occurred during the motion.
 
-### Gripper
+### <a id="gripper" /> 👌  Gripper
 
 In the `franky::Gripper` class, the default gripper force and gripper speed can be set.
 Then, additionally to the libfranka commands, the following helper methods can be used:
@@ -825,6 +913,81 @@ else:
     print("Gripper motion timed out.")
 ```
 
+### Accessing the Web Interface API
+
+For Franka robots, control happens via the Franka Control Interface (FCI), which has to be enabled through the Franka UI in the robot's web interface.
+The Franka UI also provides methods for locking and unlocking the brakes, setting the execution mode, and executing the safety self-test.
+However, sometimes you may want to access these methods programmatically, e.g. for automatically unlocking the brakes before starting a motion, or automatically executing the self-test after 24h of continuous execution.
+
+For that reason, Franky provides a `RobotWebSession` class that allows you to access the web interface API of the robot.
+Note that directly accessing the web interface API is not officially supported and documented by Franka.
+Hence, use this feature at your own risk.
+
+A typical automated workflow could look like this:
+
+```python
+import franky
+
+with franky.RobotWebSession("172.16.0.2", "username", "password") as robot_web_session:
+    # First take control
+    try:
+        # Try taking control. The session currently holding control has to release it in order
+        # for this session to gain control. In the web interface, a notification will show
+        # prompting the user to release control. If the other session is another
+        # franky.RobotWebSession, then the `release_control` method can be called on the other
+        # session to release control.
+        robot_web_session.take_control(wait_timeout=10.0)
+    except franky.TakeControlTimeoutError:
+        # If nothing happens for 10s, we try to take control forcefully. This is particularly
+        # useful if the session holding control is dead. Taking control by force requires the
+        # user to manually push the blue button close to the robot's wrist.
+        robot_web_session.take_control(wait_timeout=30.0, force=True)
+
+    # Unlock the brakes
+    robot_web_session.unlock_brakes()
+
+    # Enable the FCI
+    robot_web_session.enable_fci()
+
+    # Create a franky.Robot instance and do whatever you want
+    ...
+
+    # Disable the FCI
+    robot_web_session.disable_fci()
+
+    # Lock brakes
+    robot_web_session.lock_brakes()
+```
+
+In case you are running the robot for longer than 24h you will have noticed that you have to do a safety self-test every 24h.
+`RobotWebSession` allows to automate this task as well:
+
+```python
+import time
+import franky
+
+with franky.RobotWebSession("172.16.0.2", "username", "password") as robot_web_session:
+    # Execute self-test if the time until self-test is less than 5 minutes.
+    if robot_web_session.get_system_status()["safety"]["timeToTd2"] < 300:
+        robot_web_session.disable_fci()
+        robot_web_session.lock_brakes()
+        time.sleep(1.0)
+
+        robot_web_session.execute_self_test()
+
+        robot_web_session.unlock_brakes()
+        robot_web_session.enable_fci()
+        time.sleep(1.0)
+
+        # Recreate your franky.Robot instance as the FCI has been disabled and re-enabled
+        ...
+```
+
+`robot_web_session.get_system_status()` contains more information than just the time until self-test, such as the current execution mode, whether the brakes are locked, whether the FCI is enabled, and more.
+
+If you want to call other API functions, you can use the `RobotWebSession.send_api_request` and `RobotWebSession.send_control_api_request` methods.
+See [robot_web_session.py](franky/robot_web_session.py) for an example of how to use these methods.
+
 ## 🛠️ Development
 
 Franky is currently tested against following versions
@@ -867,3 +1030,12 @@ Aside of bug fixes and general performance improvements, Franky provides the fol
 * Franky supports [joint velocity control](#joint-velocity-control)
   and [cartesian velocity control](#cartesian-velocity-control)
 * The dynamics limits are not hard-coded anymore but can be [set for each robot instance](#-robot).
+
+## Contributing
+
+If you wish to contribute to this project, you are welcome to create a pull request.
+Please run the [pre-commit](https://pre-commit.com/) hooks before submitting your pull request.
+To install the pre-commit hooks, run:
+
+1. [Install pre-commit](https://pre-commit.com/#install)
+2. Install the Git hooks by running `pre-commit install` or, alternatively, run `pre-commit run --all-files manually.

franky_control-1.1.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+franky/__init__.py,sha256=57BsmUytdeqMrhHglwvxMS6CgpAEVPw0KJge8_UTzEA,378
+franky/_franky.cpython-38-x86_64-linux-gnu.so,sha256=ma1dPQVos-S7VtmVPwIQjbHXm0WAAeMl_5f327vUc5U,3049137
+franky/_franky.pyi,sha256=odBnBaM2qGN4mUa8WvFN5SL9aszPgDTsZj5Jb9UkFHk,60047
+franky/motion.py,sha256=TWsx2Ba9iYG9e-OxpuYZlVn1wdzKS-Zvz6ayHT_HYXQ,354
+franky/reaction.py,sha256=cBuHAMek9yH-9Zmwfa0dzz2t5G_1SQEWXNdW7mhhCI8,1519
+franky/robot.py,sha256=NaTNh4PaJshbz44eibvLCMt6O_Ak7TRVjhUR6AGay9A,236
+franky/robot_web_session.py,sha256=rYpnUe4b8xj5JjCYxNRZ0uYz8lL2qfxKglcImFDw24Y,9070
+franky_control.libs/libPocoFoundation-44d67b9f.so.95,sha256=6sSpoT5WNjvmbsEdjYvp5uu8nhEx-elAH67Gw8I2twA,3269633
+franky_control.libs/libPocoNet-3bdfeb79.so.95,sha256=_ZbdxzOFhIIiSHA79e8yKNyCjfGVFbzYFvHqaKnqoFc,2482737
+franky_control.libs/libboost_filesystem-0bf67256.so.1.75.0,sha256=MV-QRMY_pZ0zReU4H4AbcpyZ_sc6yZ6QR6QdDxF84Qc,139961
+franky_control.libs/libboost_serialization-67da18f6.so.1.75.0,sha256=Wjn9rKqoXLrVK29NShhm_evaRsbhTFvvGydi8gwr5hs,319177
+franky_control.libs/libconsole_bridge-acce180d.so.1.0,sha256=-iSKX9xNyLCSSrducf7rDx6hXzdU5v7xQqZDulppIP8,22769
+franky_control.libs/libfmt-677b7a5c.so.8.1.1,sha256=rN3uzEn_limS_u6DV-BxdTEbs2GrhlicD_OjyAlKYpA,140649
+franky_control.libs/libfranka-e5e9247f.so.0.15.0,sha256=rJDob_PoDQHpC78J-rhR67oqlhmlTnS2Red0bClsi2I,973497
+franky_control.libs/libpinocchio_default-def973fb.so.3.1.0,sha256=cMnEW8NgbxqYEpdZH0Ymp-B5SEKzGiKq4GA0BcZ-JV4,9668545
+franky_control.libs/libpinocchio_parsers-d98f9e85.so.3.1.0,sha256=HbwrdisSDbC2mXCz1NVhACUIaXconvI3i-BN1W9qJuE,707441
+franky_control.libs/libtinyxml-69e5f0dd.so.0.2.6.2,sha256=V45jOzaljaUrtOAYBS20QBFHn0qPFHTEcWxdcOBoJNA,118121
+franky_control.libs/liburdfdom_model-9ec0392f.so.1.0,sha256=Kwlq8DuENLdEX5URKcwUC06sl9rxUYoRjGx3EI-uRiY,146081
+franky_control.libs/liburdfdom_model_state-01125232.so.1.0,sha256=LNMEG27nv_6BYvelpjXjr0YsBl-6IsGQfg3uG0DvTQQ,20857
+franky_control.libs/liburdfdom_sensor-011819fa.so.1.0,sha256=LzFH_sfeyWcV042TmgSEXTQL1c0teyYg3veA8sTn_EM,20857
+franky_control.libs/liburdfdom_world-4d53bc81.so.1.0,sha256=IziPhPYdFfZTgKDOnUMGLYSCsZRxYfC1rEKWjvzrpb4,146081
+franky_control-1.1.1.dist-info/LICENSE,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+franky_control-1.1.1.dist-info/METADATA,sha256=krU979EyVmkb6rZBCIm_sLRAurodnpVmyAJLOVGZXXU,40968
+franky_control-1.1.1.dist-info/WHEEL,sha256=L3HW8fVbXzdi0Qbq6Dl6IkkMSshhqlUpffoAzAKCWvI,111
+franky_control-1.1.1.dist-info/top_level.txt,sha256=LdDKRvHTODs6ll6Ow5b-gmWqt4NJffHxL83MRTCv_Ag,22
+franky_control-1.1.1.dist-info/RECORD,,

franky_control-1.0.2.dist-info/RECORD

@@ -1,26 +0,0 @@
-franky/__init__.py,sha256=lmRG8cc4eX-0gZgCkxxVCOrmuUEGJsppWl7DDURib-Y,293
-franky/_franky.cpython-38-x86_64-linux-gnu.so,sha256=giR-PnoKEbVXiTR_fGw-hRsy5aubJ7iIWjIl04C-uzk,3040945
-franky/_franky.pyi,sha256=odBnBaM2qGN4mUa8WvFN5SL9aszPgDTsZj5Jb9UkFHk,60047
-franky/motion.py,sha256=EZmZPvu2r4YBhcokV1PFh8s8NmiwOUERvct3Zz629C8,334
-franky/reaction.py,sha256=gDD7kVc_7Et2NwMmCB4Hcd12aK0eygJVqXzZ9Dzw0_M,1488
-franky/robot.py,sha256=NaTNh4PaJshbz44eibvLCMt6O_Ak7TRVjhUR6AGay9A,236
-franky/robot_web_session.py,sha256=zOTAqDF4PbZLqJFr3RcuBwfWRSEMiw0Eag1stk3GWKE,7622
-franky_control.libs/libPocoFoundation-44c2a91d.so.95,sha256=kMB_IJ_gYGE1jprdF_RIVEbhg9gQH3IimwBUksadJNc,3265609
-franky_control.libs/libPocoNet-2f9ce4bf.so.95,sha256=wwgasubJUNFpW5brGQoUiyCEx6NgPQSG2Vjgk66OQ0s,2482737
-franky_control.libs/libboost_filesystem-42b111b5.so.1.75.0,sha256=8tanNbQ7I455iTdjcNXuKf8snHpXq6N7SVvnX5H-_bY,139961
-franky_control.libs/libboost_serialization-0b785d4d.so.1.75.0,sha256=sOHF1ncSl_Hg4oBqbyEuQCYAE9IaREqfm-dspP-O5mw,319177
-franky_control.libs/libconsole_bridge-acce180d.so.1.0,sha256=-iSKX9xNyLCSSrducf7rDx6hXzdU5v7xQqZDulppIP8,22769
-franky_control.libs/libfmt-677b7a5c.so.8.1.1,sha256=rN3uzEn_limS_u6DV-BxdTEbs2GrhlicD_OjyAlKYpA,140649
-franky_control.libs/libfranka-976dfd01.so.0.15.0,sha256=q6EJaLfNrYHNcwJvov9s2sM18ahCZ2LgKZwZTbvDbok,973497
-franky_control.libs/libpinocchio_default-b05a4796.so.3.1.0,sha256=NFyO0kOaOcpnFYVAehcgJj5spee4weJ_PqPZ5uUqpEg,9668545
-franky_control.libs/libpinocchio_parsers-74bdc3cc.so.3.1.0,sha256=4yyz3Gw4SoyFEtvfx546_UMpH3GN9SjVWsWH28eCVSs,707441
-franky_control.libs/libtinyxml-69e5f0dd.so.0.2.6.2,sha256=V45jOzaljaUrtOAYBS20QBFHn0qPFHTEcWxdcOBoJNA,118121
-franky_control.libs/liburdfdom_model-9ec0392f.so.1.0,sha256=Kwlq8DuENLdEX5URKcwUC06sl9rxUYoRjGx3EI-uRiY,146081
-franky_control.libs/liburdfdom_model_state-01125232.so.1.0,sha256=LNMEG27nv_6BYvelpjXjr0YsBl-6IsGQfg3uG0DvTQQ,20857
-franky_control.libs/liburdfdom_sensor-011819fa.so.1.0,sha256=LzFH_sfeyWcV042TmgSEXTQL1c0teyYg3veA8sTn_EM,20857
-franky_control.libs/liburdfdom_world-4d53bc81.so.1.0,sha256=IziPhPYdFfZTgKDOnUMGLYSCsZRxYfC1rEKWjvzrpb4,146081
-franky_control-1.0.2.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-franky_control-1.0.2.dist-info/METADATA,sha256=8w7ITX99ftSyZ4TTdgcZ8fxgYC0_UsNfzcbgatWPK-4,34881
-franky_control-1.0.2.dist-info/WHEEL,sha256=L3HW8fVbXzdi0Qbq6Dl6IkkMSshhqlUpffoAzAKCWvI,111
-franky_control-1.0.2.dist-info/top_level.txt,sha256=LdDKRvHTODs6ll6Ow5b-gmWqt4NJffHxL83MRTCv_Ag,22
-franky_control-1.0.2.dist-info/RECORD,,