mink 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

mink/__init__.py

@@ -25,7 +25,15 @@ from .limits import (
     VelocityLimit,
 )
 from .solve_ik import build_ik, solve_ik
-from .tasks import ComTask, FrameTask, Objective, PostureTask, TargetNotSet, Task
+from .tasks import (
+    ComTask,
+    DampingTask,
+    FrameTask,
+    Objective,
+    PostureTask,
+    TargetNotSet,
+    Task,
+)
 from .utils import (
     custom_configuration_vector,
     get_body_geom_ids,
@@ -34,13 +42,14 @@ from .utils import (
     move_mocap_to_frame,
 )
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 
 __all__ = (
     "ComTask",
     "Configuration",
     "build_ik",
     "solve_ik",
+    "DampingTask",
     "FrameTask",
     "PostureTask",
     "Task",

mink/configuration.py

@@ -1,3 +1,14 @@
+"""Configuration space of a robot model.
+
+The :class:`Configuration` class bundles a MuJoCo `model <https://mujoco.readthedocs.io/en/latest/APIreference/APItypes.html#mjmodel>`__
+and `data <https://mujoco.readthedocs.io/en/latest/APIreference/APItypes.html#mjdata>`__,
+and enables easy access to kinematic quantities such as frame transforms and frame
+Jacobians.
+
+Frames are coordinate systems that can be attached to different elements of
+the robot model. mink supports frames of type `body`, `geom` and `site`.
+"""
+
 from typing import Optional
 
 import mujoco
@@ -9,14 +20,24 @@ from .lie import SE3, SO3
 
 
 class Configuration:
-    """A struct that provides convenient access to kinematic quantities such as frame
-    transforms and frame jacobians. Frames can be defined at bodies, geoms or sites.
+    """Encapsulates a model and data for convenient access to kinematic quantities.
+
+    This class provides convenient methods to access and update the kinematic quantities
+    of a robot model, such as frame transforms and Jacobians. It ensures that forward
+    kinematics is computed at each time step, allowing the user to query up-to-date
+    information about the robot's state.
+
+    In this context, a frame refers to a coordinate system that can be attached to
+    different elements of the robot model. Currently supported frames include
+    `body`, `geom` and `site`.
 
-    The `update` function ensures the proper forward kinematics functions have been
-    called, namely:
+    Key functionalities include:
 
-    - mujoco.mj_kinematics(model, data)
-    - mujoco.mj_comPos(model, data)
+        - Running forward kinematics to update the state.
+        - Checking configuration limits.
+        - Computing Jacobians for different frames.
+        - Retrieving frame transforms relative to the world frame.
+        - Integrating velocities to update configurations.
     """
 
     def __init__(
@@ -27,8 +48,8 @@ class Configuration:
         """Constructor.
 
         Args:
-            model: An instance of MjModel.
-            q: Optional configuration to initialize from. If None, the configuration
+            model: Mujoco model.
+            q: Configuration to initialize from. If None, the configuration
                 is initialized to the reference configuration `qpos0`.
         """
         self.model = model
@@ -38,15 +59,13 @@ class Configuration:
     def update(self, q: Optional[np.ndarray] = None) -> None:
         """Run forward kinematics.
 
-        The minimal function call required to get updated frame transforms (aka forward
-        kinematics) is `mj_kinematics`. An extra call to `mj_comPos` is needed for
-        updated Jacobians.
-
-        Args:`
+        Args:
             q: Optional configuration vector to override internal data.qpos with.
         """
         if q is not None:
             self.data.qpos = q
+        # The minimal function call required to get updated frame transforms is
+        # mj_kinematics. An extra call to mj_comPos is required for updated Jacobians.
         mujoco.mj_kinematics(self.model, self.data)
         mujoco.mj_comPos(self.model, self.data)
 
@@ -95,24 +114,27 @@ class Configuration:
                     )
                 else:
                     print(
-                        f"Value {qval} at index {jnt} is out of limits: "
-                        f"[{qmin}, {qmax}]"
+                        f"Value {qval:.2f} at index {jnt} is outside of its limits: "
+                        f"[{qmin:.2f}, {qmax:.2f}]"
                     )
 
     def get_frame_jacobian(self, frame_name: str, frame_type: str) -> np.ndarray:
-        """Compute the Jacobian matrix of a frame velocity.
+        r"""Compute the Jacobian matrix of a frame velocity.
 
-        Denoting our frame by B and the world frame by W, the Jacobian matrix B_J_WB
-        is related to the body velocity B_v_WB by:
+        Denoting our frame by :math:`B` and the world frame by :math:`W`, the
+        Jacobian matrix :math:`{}_B J_{WB}` is related to the body velocity
+        :math:`{}_B v_{WB}` by:
 
-            B_v_WB = B_J_WB q_dot
+        .. math::
+
+            {}_B v_{WB} = {}_B J_{WB} \dot{q}
 
         Args:
             frame_name: Name of the frame in the MJCF.
             frame_type: Type of frame. Can be a geom, a body or a site.
 
         Returns:
-            Jacobian B_J_WB of the frame.
+            Jacobian :math:`{}_B J_{WB}` of the frame.
         """
         if frame_type not in consts.SUPPORTED_FRAMES:
             raise exceptions.UnsupportedFrame(frame_type, consts.SUPPORTED_FRAMES)
@@ -142,9 +164,7 @@ class Configuration:
         return jac
 
     def get_transform_frame_to_world(self, frame_name: str, frame_type: str) -> SE3:
-        """Get the pose of a frame in the current configuration.
-
-        Denoting our frame by B and the world frame by W, this function returns T_WB.
+        """Get the pose of a frame at the current configuration.
 
         Args:
             frame_name: Name of the frame in the MJCF.
@@ -177,7 +197,7 @@ class Configuration:
         """Integrate a velocity starting from the current configuration.
 
         Args:
-            velocity: The velocity.
+            velocity: The velocity in tangent space.
             dt: Integration duration in [s].
 
         Returns:
@@ -191,7 +211,7 @@ class Configuration:
         """Integrate a velocity and update the current configuration inplace.
 
         Args:
-            velocity: The velocity.
+            velocity: The velocity in tangent space.
             dt: Integration duration in [s].
         """
         mujoco.mj_integratePos(self.model, self.data.qpos, velocity, dt)

mink/lie/base.py

@@ -10,8 +10,8 @@ class MatrixLieGroup(abc.ABC):
 
     Attributes:
         matrix_dim: Dimension of square matrix output.
-        parameters_dim:: Dimension of underlying parameters.
-        tangent_dim:: Dimension of tangent space.
+        parameters_dim: Dimension of underlying parameters.
+        tangent_dim: Dimension of tangent space.
         space_dim: Dimension of coordinates that can be transformed.
     """
 

mink/lie/so3.py

@@ -14,6 +14,8 @@ _INVERT_QUAT_SIGN = np.array([1.0, -1.0, -1.0, -1.0], dtype=np.float64)
 
 
 class RollPitchYaw(NamedTuple):
+    """Struct containing roll, pitch, and yaw Euler angles."""
+
     roll: float
     pitch: float
     yaw: float

mink/limits/collision_avoidance_limit.py

@@ -1,32 +1,4 @@
-"""Collision avoidance limit.
-
-Derivation
-==========
-
-p1, p2: closest points between g1 and g2
-d: distance between g1 and g2 (d = ||p1 - p2||)
-n: normal vector from g1 to g2 (n = (p2 - p1) / ||p2 - p1||)
-
-The relative velocity constraint between g1 and g2 is given by:
-
-    n^T [J2(p2) - J1(p1)] dq <= -k * (d - d_min) / dt
-    V_n <= -k * (d - d_min)
-
-where [J2(p2) - J1(p1)] dq denotes the relative velocity between g1 and g2, and
-n^T [J2(p2) - J1(p1)] dq projects this velocity onto the direction connecting the
-closest points p1 and p2.
-
-We have three cases for the distance d:
-
-1. V_n <= R_b                                if dist_c < dist_m
-2. V_n <= -k * (dist_c - dist_m) / dt + R_b  if dist_m <= d <= dist_d
-3. V_n <= inf                                otherwise
-
-where:
-- dist_c: current normal distance between g1 and g2
-- dist_m: minimum allowed distance between g1 and g2
-- dist_d: collision detection distance
-"""
+"""Collision avoidance limit."""
 
 import itertools
 from dataclasses import dataclass
@@ -46,7 +18,7 @@ CollisionPairs = Sequence[CollisionPair]
 
 
 @dataclass(frozen=True)
-class Contact:
+class _Contact:
     dist: float
     fromto: np.ndarray
     geom1: int
@@ -107,7 +79,31 @@ def _is_pass_contype_conaffinity_check(
 
 
 class CollisionAvoidanceLimit(Limit):
-    """Normal velocity limit between geom pairs."""
+    """Normal velocity limit between geom pairs.
+
+    Attributes:
+        model: MuJoCo model.
+        geom_pairs: Set of collision pairs in which to perform active collision
+            avoidance. A collision pair is defined as a pair of geom groups. A geom
+            group is a set of geom names. For each geom pair, the solver will
+            attempt to compute joint velocities that avoid collisions between every
+            geom in the first geom group with every geom in the second geom group.
+            Self collision is achieved by adding a collision pair with the same
+            geom group in both pair fields.
+        gain: Gain factor in (0, 1] that determines how fast the geoms are
+            allowed to move towards each other at each iteration. Smaller values
+            are safer but may make the geoms move slower towards each other.
+        minimum_distance_from_collisions: The minimum distance to leave between
+            any two geoms. A negative distance allows the geoms to penetrate by
+            the specified amount.
+        collision_detection_distance: The distance between two geoms at which the
+            active collision avoidance limit will be active. A large value will
+            cause collisions to be detected early, but may incur high computational
+            cost. A negative value will cause the geoms to be detected only after
+            they penetrate by the specified amount.
+        bound_relaxation: An offset on the upper bound of each collision avoidance
+            constraint.
+    """
 
     def __init__(
         self,
@@ -141,7 +137,7 @@ class CollisionAvoidanceLimit(Limit):
                 cost. A negative value will cause the geoms to be detected only after
                 they penetrate by the specified amount.
             bound_relaxation: An offset on the upper bound of each collision avoidance
-                constraint to tighten or relax
+                constraint.
         """
         self.model = model
         self.gain = gain
@@ -178,7 +174,7 @@ class CollisionAvoidanceLimit(Limit):
 
     def _compute_contact_with_minimum_distance(
         self, data: mujoco.MjData, geom1_id: int, geom2_id: int
-    ) -> Contact:
+    ) -> _Contact:
         """Returns the smallest signed distance between a geom pair."""
         fromto = np.empty(6)
         dist = mujoco.mj_geomDistance(
@@ -189,12 +185,12 @@ class CollisionAvoidanceLimit(Limit):
             self.collision_detection_distance,
             fromto,
         )
-        return Contact(
+        return _Contact(
             dist, fromto, geom1_id, geom2_id, self.collision_detection_distance
         )
 
     def _compute_contact_normal_jacobian(
-        self, data: mujoco.MjData, contact: Contact
+        self, data: mujoco.MjData, contact: _Contact
     ) -> np.ndarray:
         """Computes the Jacobian mapping joint velocities to the normal component of
         the relative Cartesian linear velocity between the geom pair.

mink/limits/configuration_limit.py

@@ -1,24 +1,4 @@
-"""Limit on joint positions.
-
-Derivation
-==========
-
-Using a first order Taylor expansion on the configuration, we can write the limit as:
-
-    q_min     <= q + v * dt <= q_max
-    q_min     <= q + dq     <= q_max
-    q_min - q <= dq         <= q_max - q
-
-Rewriting as G dq <= h:
-
-    +I * dq <= q_max - q
-    -I * dq <= q - q_min
-
-Stacking them together, we get:
-
-    G = [+I, -I]
-    h = [q_max - q, q - q_min]
-"""
+"""Joint position limit."""
 
 import mujoco
 import numpy as np
@@ -30,16 +10,9 @@ from .limit import Constraint, Limit
 
 
 class ConfigurationLimit(Limit):
-    """Limit for joint positions in a model.
-
-    Floating base joints (joint type="free") are ignored.
+    """Inequality constraint on joint positions in a robot model.
 
-    Attributes:
-        indices: Tangent indices corresponding to configuration-limited joints.
-        projection_matrix: Projection from tangent space to subspace with
-            configuration-limited joints.
-        lower: Lower configuration limit.
-        upper: Upper configuration limit.
+    Floating base joints are ignored.
     """
 
     def __init__(
@@ -95,6 +68,26 @@ class ConfigurationLimit(Limit):
         configuration: Configuration,
         dt: float,
     ) -> Constraint:
+        r"""Compute the configuration-dependent joint position limits.
+
+        The limits are defined as:
+
+        .. math::
+
+            {q \ominus q_{min}} \leq \Delta q \leq {q_{max} \ominus q}
+
+        where :math:`q \in {\cal C}` is the robot's configuration and
+        :math:`\Delta q \in T_q({\cal C})` is the displacement in the tangent
+        space at :math:`q`. See the :ref:`derivations` section for more information.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+            dt: Integration timestep in [s].
+
+        Returns:
+            Pair :math:`(G, h)` representing the inequality constraint as
+            :math:`G \Delta q \leq h`, or ``None`` if there is no limit.
+        """
         del dt  # Unused.
 
         # Upper.

mink/limits/limit.py

@@ -1,3 +1,5 @@
+"""All kinematic limits derive from the :class:`Limit` base class."""
+
 import abc
 from typing import NamedTuple, Optional
 
@@ -7,21 +9,29 @@ from ..configuration import Configuration
 
 
 class Constraint(NamedTuple):
-    """Linear inequalities in the form G(q) dq <= h(q).
+    r"""Linear inequality constraint of the form :math:`G(q) \Delta q \leq h(q)`.
 
-    The limit is considered inactive when G or h are None.
+    Inactive if G and h are None.
     """
 
-    G: Optional[np.ndarray] = None  # (nv, nv)
-    h: Optional[np.ndarray] = None  # (nv,)
+    G: Optional[np.ndarray] = None
+    """Shape (nv, nv)."""
+    h: Optional[np.ndarray] = None
+    """Shape (nv,)."""
 
     @property
     def inactive(self) -> bool:
-        return self.G is None or self.h is None
+        """Returns True if the constraint is inactive."""
+        return self.G is None and self.h is None
 
 
 class Limit(abc.ABC):
-    """Abstract base class for kinematic limits."""
+    """Abstract base class for kinematic limits.
+
+    Subclasses must implement the :py:meth:`~Limit.compute_qp_inequalities` method
+    which takes in the current robot configuration and integration time step and
+    returns an instance of :class:`Constraint`.
+    """
 
     @abc.abstractmethod
     def compute_qp_inequalities(
@@ -29,13 +39,21 @@ class Limit(abc.ABC):
         configuration: Configuration,
         dt: float,
     ) -> Constraint:
-        """Compute limit as linearized QP inequalities.
+        r"""Compute limit as linearized QP inequalities of the form:
+
+        .. math::
+
+            G(q) \Delta q \leq h(q)
+
+        where :math:`q \in {\cal C}` is the robot's configuration and
+        :math:`\Delta q \in T_q({\cal C})` is the displacement in the tangent
+        space at :math:`q`.
 
         Args:
-            configuration: Current configuration.
+            configuration: Robot configuration :math:`q`.
             dt: Integration time step in [s].
 
         Returns:
-            Pair (G, h) representing the inequality constraint.
+            Pair :math:`(G, h)`.
         """
         raise NotImplementedError

mink/limits/velocity_limit.py

@@ -1,24 +1,4 @@
-"""Limit on joint velocities.
-
-Derivation
-==========
-
-Given maximum joint velocity magnitudes v_max, we can express joint velocity limits as:
-
-    -v_max      <= v       <= v_max
-    -v_max      <= dq / dt <= v_max
-    -v_max * dt <= dq      <= v_max * dt
-
-Rewriting as G dq <= h:
-
-    +I * dq <= v_max * dt
-    -I * dq <= v_max * dt
-
-Stacking them together, we get:
-
-    G = [+I, -I]
-    h = [v_max * dt, v_max * dt]
-"""
+"""Joint velocity limit."""
 
 from typing import Mapping
 
@@ -33,17 +13,22 @@ from .limit import Constraint, Limit
 
 
 class VelocityLimit(Limit):
-    """Limit for joint velocities in a model.
+    """Inequality constraint on joint velocities in a robot model.
 
     Floating base joints are ignored.
 
     Attributes:
         indices: Tangent indices corresponding to velocity-limited joints.
-        limit: Maximum allowed velocity magnitude for velocity-limited joints.
+        limit: Maximum allowed velocity magnitude for velocity-limited joints, in
+            [m]/[s] for slide joints and [rad]/[s] for hinge joints.
         projection_matrix: Projection from tangent space to subspace with
             velocity-limited joints.
     """
 
+    indices: np.ndarray
+    limit: np.ndarray
+    projection_matrix: np.ndarray
+
     def __init__(
         self,
         model: mujoco.MjModel,
@@ -52,6 +37,7 @@ class VelocityLimit(Limit):
         """Initialize velocity limits.
 
         Args:
+            model: MuJoCo model.
             velocities: Dictionary mapping joint name to maximum allowed magnitude in
                 [m]/[s] for slide joints and [rad]/[s] for hinge joints.
         """
@@ -84,6 +70,27 @@ class VelocityLimit(Limit):
     def compute_qp_inequalities(
         self, configuration: Configuration, dt: float
     ) -> Constraint:
+        r"""Compute the configuration-dependent joint velocity limits.
+
+        The limits are defined as:
+
+        .. math::
+
+            -v_{\text{max}} \cdot dt \leq \Delta q \leq v_{\text{max}} \cdot dt
+
+        where :math:`v_{max} \in {\cal T}` is the robot's velocity limit
+        vector and :math:`\Delta q \in T_q({\cal C})` is the displacement in the
+        tangent space at :math:`q`. See the :ref:`derivations` section for
+        more information.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+            dt: Integration timestep in [s].
+
+        Returns:
+            Pair :math:`(G, h)` representing the inequality constraint as
+            :math:`G \Delta q \leq h`, or ``None`` if there is no limit.
+        """
         del configuration  # Unused.
         if self.projection_matrix is None:
             return Constraint()

mink/tasks/__init__.py

@@ -1,6 +1,7 @@
 """Kinematic tasks."""
 
 from .com_task import ComTask
+from .damping_task import DampingTask
 from .exceptions import (
     InvalidDamping,
     InvalidGain,
@@ -16,6 +17,7 @@ __all__ = (
     "ComTask",
     "FrameTask",
     "Objective",
+    "DampingTask",
     "PostureTask",
     "Task",
     "TargetNotSet",

mink/tasks/com_task.py

@@ -1,4 +1,6 @@
-"""Center of mass task implementation."""
+"""Center-of-mass task implementation."""
+
+from __future__ import annotations
 
 from typing import Optional
 
@@ -12,7 +14,7 @@ from .task import Task
 
 
 class ComTask(Task):
-    """Regulate the center of mass (CoM) of a robot.
+    """Regulate the center-of-mass (CoM) of a robot.
 
     Attributes:
         target_com: Target position of the CoM.
@@ -33,7 +35,6 @@ class ComTask(Task):
         self.set_cost(cost)
 
     def set_cost(self, cost: npt.ArrayLike) -> None:
-        """Set a new cost for all CoM coordinates."""
         cost = np.atleast_1d(cost)
         if cost.ndim != 1 or cost.shape[0] not in (1, self.k):
             raise TaskDefinitionError(
@@ -46,7 +47,11 @@ class ComTask(Task):
         self.cost[:] = cost
 
     def set_target(self, target_com: npt.ArrayLike) -> None:
-        """Set the target CoM position in the world frame."""
+        """Set the target CoM position in the world frame.
+
+        Args:
+            target_com: Desired center-of-mass position in the world frame.
+        """
         target_com = np.atleast_1d(target_com)
         if target_com.ndim != 1 or target_com.shape[0] != (self.k):
             raise InvalidTarget(
@@ -56,14 +61,21 @@ class ComTask(Task):
         self.target_com = target_com.copy()
 
     def set_target_from_configuration(self, configuration: Configuration) -> None:
-        """Set the target CoM from a given robot configuration."""
+        """Set the target CoM from a given robot configuration.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+        """
         self.set_target(configuration.data.subtree_com[1])
 
     def compute_error(self, configuration: Configuration) -> np.ndarray:
         """Compute the CoM task error.
 
-        The error is the difference between the target CoM and current CoM positions,
-        expressed in the world frame.
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Center-of-mass task error vector :math:`e(q)`.
         """
         if self.target_com is None:
             raise TargetNotSet(self.__class__.__name__)
@@ -72,8 +84,11 @@ class ComTask(Task):
     def compute_jacobian(self, configuration: Configuration) -> np.ndarray:
         """Compute the CoM task Jacobian.
 
-        The task Jacobian is the derivative of the task error with respect to the
-        current configuration. It has dimension (3, nv).
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Center-of-mass task jacobian :math:`J(q)`.
         """
         if self.target_com is None:
             raise TargetNotSet(self.__class__.__name__)

mink/tasks/damping_task.py

@@ -0,0 +1,19 @@
+"""Damping task implementation."""
+
+from __future__ import annotations
+
+import mujoco
+
+from .posture_task import PostureTask
+
+
+class DampingTask(PostureTask):
+    """Minimize joint velocities.
+
+    This task is implemented as a special case of the PostureTask where the gain and
+    target configuration are set to 0 and qpos0 respectively.
+    """
+
+    def __init__(self, model: mujoco.MjModel, cost: float):
+        super().__init__(model=model, cost=cost, gain=0.0, lm_damping=0.0)
+        self.target_q = model.qpos0

mink/tasks/frame_task.py

@@ -1,5 +1,7 @@
 """Frame task implementation."""
 
+from __future__ import annotations
+
 from typing import Optional
 
 import numpy as np
@@ -12,12 +14,13 @@ from .task import Task
 
 
 class FrameTask(Task):
-    """Regulate the pose of a robot frame in the world frame.
+    """Regulate the pose of a frame expressed in the world frame.
 
     Attributes:
-        frame_name: Name of the frame to regulate.
-        frame_type: The frame type: body, geom or site.
-        transform_frame_to_world: Target pose of the frame in the world frame.
+        frame_name: Name of the frame to regulate, typically the name of body, geom
+            or site in the robot model.
+        frame_type: The frame type: `body`, `geom` or `site`.
+        transform_frame_to_world: Target pose of the frame.
     """
 
     k: int = 6
@@ -71,21 +74,44 @@ class FrameTask(Task):
         self.cost[3:] = orientation_cost
 
     def set_target(self, transform_target_to_world: SE3) -> None:
-        """Set the target pose in the world frame."""
+        """Set the target pose.
+
+        Args:
+            transform_target_to_world: Transform from the task target frame to the
+                world frame.
+        """
         self.transform_target_to_world = transform_target_to_world.copy()
 
     def set_target_from_configuration(self, configuration: Configuration) -> None:
-        """Set the target pose from a given robot configuration."""
+        """Set the target pose from a given robot configuration.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+        """
         self.set_target(
             configuration.get_transform_frame_to_world(self.frame_name, self.frame_type)
         )
 
     def compute_error(self, configuration: Configuration) -> np.ndarray:
-        """Compute the frame task error.
+        r"""Compute the frame task error.
+
+        This error is a twist :math:`e(q) \in se(3)` expressed in the local frame,
+        i.e., it is a body twist. It is computed by taking the right-minus difference
+        between the target pose :math:`T_{0t}` and current frame pose :math:`T_{0b}`:
 
-        This error is a twist expressed in the local frame, i.e., it is a body twist.
-        It is computed by taking the right minus difference between the target pose
-        and the current frame pose: `e = T_wt ⊖ T_wf`.
+        .. math::
+
+            e(q) := {}_b \xi_{0b} = -(T_{t0} \ominus T_{b0})
+            = -\log(T_{t0} \cdot T_{0b}) = -\log(T_{tb}) = \log(T_{bt})
+
+        where :math:`b` denotes our frame, :math:`t` the target frame and
+        :math:`0` the inertial frame.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Frame task error vector :math:`e(q)`.
         """
         if self.transform_target_to_world is None:
             raise TargetNotSet(self.__class__.__name__)
@@ -96,10 +122,16 @@ class FrameTask(Task):
         return self.transform_target_to_world.minus(transform_frame_to_world)
 
     def compute_jacobian(self, configuration: Configuration) -> np.ndarray:
-        """Compute the frame task Jacobian.
+        r"""Compute the frame task Jacobian.
+
+        The derivation of the formula for this Jacobian is detailed in
+        [FrameTaskJacobian]_.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
 
-        The task Jacobian is the derivative of the task error with respect to the
-        current configuration. It has dimension (6, nv).
+        Returns:
+            Frame task jacobian :math:`J(q)`.
         """
         if self.transform_target_to_world is None:
             raise TargetNotSet(self.__class__.__name__)

mink/tasks/posture_task.py

@@ -1,3 +1,7 @@
+"""Posture task implementation."""
+
+from __future__ import annotations
+
 from typing import Optional
 
 import mujoco
@@ -11,7 +15,7 @@ from .task import Task
 
 
 class PostureTask(Task):
-    """Regulate joint angles to a desired posture.
+    """Regulate the joint angles of the robot towards a desired posture.
 
     A posture is a vector of actuated joint angles. Floating-base coordinates are not
     affected by this task.
@@ -50,7 +54,11 @@ class PostureTask(Task):
         self.nq = model.nq
 
     def set_target(self, target_q: npt.ArrayLike) -> None:
-        """Set the target posture."""
+        """Set the target posture.
+
+        Args:
+            target_q: Desired joint configuration.
+        """
         target_q = np.atleast_1d(target_q)
         if target_q.ndim != 1 or target_q.shape[0] != (self.nq):
             raise InvalidTarget(
@@ -60,14 +68,27 @@ class PostureTask(Task):
         self.target_q = target_q.copy()
 
     def set_target_from_configuration(self, configuration: Configuration) -> None:
-        """Set the target posture from the current configuration."""
+        """Set the target posture from the current configuration.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+        """
         self.set_target(configuration.q)
 
     def compute_error(self, configuration: Configuration) -> np.ndarray:
-        """Compute the posture task error.
+        r"""Compute the posture task error.
+
+        The error is defined as:
 
-        The error is defined as the right minus error between the target posture and
-        the current posture: `q^* ⊖ q`.
+        .. math::
+
+            e(q) = q^* \ominus q
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Posture task error vector :math:`e(q)`.
         """
         if self.target_q is None:
             raise TargetNotSet(self.__class__.__name__)
@@ -88,10 +109,19 @@ class PostureTask(Task):
         return qvel
 
     def compute_jacobian(self, configuration: Configuration) -> np.ndarray:
-        """Compute the posture task Jacobian.
+        r"""Compute the posture task Jacobian.
+
+        The task Jacobian is defined as:
+
+        .. math::
+
+            J(q) = I_{n_v}
+
+        Args:
+            configuration: Robot configuration :math:`q`.
 
-        The task Jacobian is the derivative of the task error with respect to the
-        current configuration. It is equal to -I and has dimension (nv, nv).
+        Returns:
+            Posture task jacobian :math:`J(q)`.
         """
         if self.target_q is None:
             raise TargetNotSet(self.__class__.__name__)

mink/tasks/task.py

@@ -1,3 +1,5 @@
+"""All kinematic tasks derive from the :class:`Task` base class."""
+
 import abc
 from typing import NamedTuple
 
@@ -8,10 +10,12 @@ from .exceptions import InvalidDamping, InvalidGain
 
 
 class Objective(NamedTuple):
-    """Quadratic objective function in the form 0.5 x^T H x + c^T x."""
+    r"""Quadratic objective of the form :math:`\frac{1}{2} x^T H x + c^T x`."""
 
-    H: np.ndarray  # (nv, nv)
-    c: np.ndarray  # (nv,)
+    H: np.ndarray
+    """Hessian matrix, of shape (n_v, n_v)"""
+    c: np.ndarray
+    """Linear vector, of shape (n_v,)."""
 
     def value(self, x: np.ndarray) -> float:
         """Returns the value of the objective at the input vector."""
@@ -19,7 +23,33 @@ class Objective(NamedTuple):
 
 
 class Task(abc.ABC):
-    """Abstract base class for kinematic tasks."""
+    r"""Abstract base class for kinematic tasks.
+
+    Subclasses must implement the configuration-dependent task error
+    :py:meth:`~Task.compute_error` and Jacobian :py:meth:`~Task.compute_jacobian`
+    functions.
+
+    The error function :math:`e(q) \in \mathbb{R}^{k}` is the quantity that
+    the task aims to drive to zero (:math:`k` is the dimension of the
+    task). It appears in the first-order task dynamics:
+
+    .. math::
+
+        J(q) \Delta q = -\alpha e(q)
+
+    The Jacobian matrix :math:`J(q) \in \mathbb{R}^{k \times n_v}`, with
+    :math:`n_v` the dimension of the robot's tangent space, is the
+    derivative of the task error :math:`e(q)` with respect to the
+    configuration :math:`q \in \mathbb{R}^{n_q}`. The configuration displacement
+    :math:`\Delta q` is the output of inverse kinematics; we divide it by dt to get a
+    commanded velocity.
+
+    In the first-order task dynamics, the error :math:`e(q)` is multiplied
+    by the task gain :math:`\alpha \in [0, 1]`. This gain can be 1.0 for
+    dead-beat control (*i.e.* converge as fast as possible), but might be
+    unstable as it neglects our first-order approximation. Lower values
+    cause slow down the task, similar to low-pass filtering.
+    """
 
     def __init__(
         self,
@@ -41,7 +71,7 @@ class Task(abc.ABC):
         if not 0.0 <= gain <= 1.0:
             raise InvalidGain("`gain` must be in the range [0, 1]")
 
-        if not lm_damping >= 0.0:
+        if lm_damping < 0.0:
             raise InvalidDamping("`lm_damping` must be >= 0")
 
         self.cost = cost
@@ -50,23 +80,13 @@ class Task(abc.ABC):
 
     @abc.abstractmethod
     def compute_error(self, configuration: Configuration) -> np.ndarray:
-        """Compute the task error function at the current configuration.
-
-        The error function e(q), of shape (k,), is the quantity that the task aims to
-        drive to zero. It appears in the first-order task dynamics:
-
-            J(q) Δq = -alpha e(q)
+        """Compute the task error at the current configuration.
 
-        The Jacobian matrix J(q), of shape (k, nv), is the derivative of the task error
-        with respect to the configuration. This Jacobian is implemented in
-        `compute_jacobian`. Finally, the configuration displacement Δq is the output
-        of inverse kinematics.
+        Args:
+            configuration: Robot configuration :math:`q`.
 
-        In the first-order task dynamics, the error e(q) is multiplied by the task gain
-        alpha which is between [0, 1]. This gain can be 1.0 for dead-beat control
-        (i.e., converge as fast as possible), but might be unstable as it neglects the
-        first-order approximation. Lower values make the task slower and have a similar
-        effect to low-pass filtering.
+        Returns:
+            Task error vector :math:`e(q)`.
         """
         raise NotImplementedError
 
@@ -74,20 +94,33 @@ class Task(abc.ABC):
     def compute_jacobian(self, configuration: Configuration) -> np.ndarray:
         """Compute the task Jacobian at the current configuration.
 
-        The task Jacobian J(q), of shape (k, nv) is the first-order derivative of the
-        error e(q) that defines the task, with k the dimension of the task and
-        nv the dimension of the robot's tangent space.
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Task jacobian :math:`J(q)`.
         """
         raise NotImplementedError
 
     def compute_qp_objective(self, configuration: Configuration) -> Objective:
-        """Compute the matrix-vector pair :math:`(H, c)` of the QP objective.
+        r"""Compute the matrix-vector pair :math:`(H, c)` of the QP objective.
+
+        This pair is such that the contribution of the task to the QP objective is:
 
-        This pair is such that the contribution of the task to the QP objective
-        of the IK is:
+        .. math::
+
+            \| J \Delta q + \alpha e \|_{W}^2 = \frac{1}{2} \Delta q^T H
+            \Delta q + c^T q
+
+        The weight matrix :math:`W \in \mathbb{R}^{k \times k}` weights and
+        normalizes task coordinates to the same unit. The unit of the overall
+        contribution is [cost]^2.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
 
-        The weight matrix W, of shape (k, k), weighs and normalizes task coordinates
-        to the same unit. The unit of the overall contribution is [cost]^2.
+        Returns:
+            Pair :math:`(H(q), c(q))`.
         """
         jacobian = self.compute_jacobian(configuration)  # (k, nv)
         minus_gain_error = -self.gain * self.compute_error(configuration)  # (k,)

mink/utils.py

@@ -17,8 +17,8 @@ def move_mocap_to_frame(
     """Initialize mocap body pose at a desired frame.
 
     Args:
-        model: An instance of mujoco.MjModel.
-        data: An instance of mujoco.MjData.
+        model: Mujoco model.
+        data: Mujoco data.
         mocap_name: The name of the mocap body.
         frame_name: The desired frame name.
         frame_type: The desired frame type. Can be "body", "geom" or "site".
@@ -36,7 +36,15 @@ def move_mocap_to_frame(
 
 
 def get_freejoint_dims(model: mujoco.MjModel) -> tuple[list[int], list[int]]:
-    """Get all floating joint configuration and tangent indices."""
+    """Get all floating joint configuration and tangent indices.
+
+    Args:
+        model: Mujoco model.
+
+    Returns:
+        A (q_ids, v_ids) pair containing all floating joint indices in the
+        configuration and tangent spaces respectively.
+    """
     q_ids: list[int] = []
     v_ids: list[int] = []
     for j in range(model.njnt):
@@ -56,9 +64,9 @@ def custom_configuration_vector(
     """Generate a configuration vector where named joints have specific values.
 
     Args:
-        model: An MjModel instance.
+        model: Mujoco model.
         key_name: Optional keyframe name to initialize the configuration vector from.
-            Otherwise, the default pose qpos0 is used.
+            Otherwise, the default pose `qpos0` is used.
         kwargs: Custom values for joint coordinates.
 
     Returns:
@@ -93,7 +101,7 @@ def get_subtree_geom_ids(model: mujoco.MjModel, body_id: int) -> list[int]:
     """Get all geoms belonging to subtree starting at a given body.
 
     Args:
-        model: An MjModel instance.
+        model: Mujoco model.
         body_id: ID of body where subtree starts.
 
     Returns:
@@ -117,7 +125,7 @@ def get_body_geom_ids(model: mujoco.MjModel, body_id: int) -> list[int]:
     """Get all geoms belonging to a given body.
 
     Args:
-        model: An MjModel instance.
+        model: Mujoco model.
         body_id: ID of body.
 
     Returns:

{mink-0.0.1.dist-info → mink-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mink
-Version: 0.0.1
+Version: 0.0.2
 Summary: mink: MuJoCo inverse kinematics.
 Keywords: inverse,kinematics,mujoco
 Author-email: Kevin Zakka <zakka@berkeley.edu>
@@ -11,26 +11,31 @@ Classifier: Framework :: Robot Framework :: Library
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Requires-Dist: mujoco >= 3.1.6
-Requires-Dist: qpsolvers >= 4.3.1
-Requires-Dist: quadprog >= 0.1.11
+Requires-Dist: qpsolvers[quadprog] >= 4.3.1
 Requires-Dist: typing_extensions
-Requires-Dist: mypy ; extra == "dev"
-Requires-Dist: ruff ; extra == "dev"
+Requires-Dist: numpy < 2.0.0
+Requires-Dist: mink[examples,dev] ; extra == "all"
 Requires-Dist: black ; extra == "dev"
 Requires-Dist: mink[test] ; extra == "dev"
-Requires-Dist: loop-rate-limiters >= 0.1.0 ; extra == "examples"
+Requires-Dist: mypy ; extra == "dev"
+Requires-Dist: ruff ; extra == "dev"
 Requires-Dist: dm_control >= 1.0.20 ; extra == "examples"
+Requires-Dist: loop-rate-limiters >= 0.1.0 ; extra == "examples"
+Requires-Dist: qpsolvers[quadprog,osqp] >= 4.3.1 ; extra == "examples"
 Requires-Dist: absl-py ; extra == "test"
+Requires-Dist: coveralls ; extra == "test"
 Requires-Dist: pytest ; extra == "test"
 Requires-Dist: robot_descriptions >= 1.9.0 ; extra == "test"
 Project-URL: Changelog, https://github.com/kevinzakka/mink/blob/main/CHANGELOG.md
 Project-URL: Source, https://github.com/kevinzakka/mink
 Project-URL: Tracker, https://github.com/kevinzakka/mink/issues
+Provides-Extra: all
 Provides-Extra: dev
 Provides-Extra: examples
 Provides-Extra: test
@@ -38,21 +43,43 @@ Provides-Extra: test
 # mink
 
 [![Build](https://img.shields.io/github/actions/workflow/status/kevinzakka/mink/ci.yml?branch=main)](https://github.com/kevinzakka/mink/actions)
+[![Coverage Status](https://coveralls.io/repos/github/kevinzakka/mink/badge.svg)](https://coveralls.io/github/kevinzakka/mink)
+[![PyPI version](https://img.shields.io/pypi/v/mink)](https://pypi.org/project/mink/)
+![Banner for mink](https://github.com/kevinzakka/mink/blob/assets/banner.png?raw=true)
 
 mink is a library for differential inverse kinematics in Python, based on the [MuJoCo](https://github.com/google-deepmind/mujoco) physics engine.
 
+Features include:
+
+* Task specification in configuration or operational space;
+* Limits on joint positions and velocities;
+* Collision avoidance between any geom pair;
+* Lie group interface for rigid body transformations.
+
+For usage and API reference, see the [documentation](https://kevinzakka.github.io/mink/).
+
 ## Installation
 
+You can install `mink` using `pip`:
+
 ```bash
-pip install -e ".[examples]"
+pip install mink
+```
+
+To include the example dependencies:
+
+```bash
+pip install "mink[examples]"
 ```
 
 ## Examples
 
+mink works with a variety of robots, including:
+
 * Arms: [UR5e](https://github.com/kevinzakka/mink/blob/main/examples/arm_ur5e_actuators.py), [iiwa14](https://github.com/kevinzakka/mink/blob/main/examples/arm_iiwa.py), [bimanual iiwa14](https://github.com/kevinzakka/mink/blob/main/examples/dual_iiwa.py)
 * Humanoids: [Unitree G1](https://github.com/kevinzakka/mink/blob/main/examples/humanoid_g1.py)
 * Quadrupeds: [Unitree Go1](https://github.com/kevinzakka/mink/blob/main/examples/quadruped_go1.py), [Boston Dynamics Spot](https://github.com/kevinzakka/mink/blob/main/examples/quadruped_spot.py)
-* Hands: [Shadow Hand]()
+* Hands: [Shadow Hand](https://github.com/kevinzakka/mink/blob/main/examples/hand_shadow.py)
 
 Check out the [examples](https://github.com/kevinzakka/mink/blob/main/examples/) directory for more code.
 
@@ -62,7 +89,7 @@ Install the library, use it and report any bugs in the [issue tracker](https://g
 
 ## Acknowledgements
 
-mink is a direct port of [pink](https://github.com/stephane-caron/pink) which uses [Pinocchio](https://github.com/stack-of-tasks/pinocchio) under the hood. Stéphane Caron, the original author of pink, is a role model for open-source software in robotics. This library would not have been possible without his work and assistance throughout this project.
+mink is a direct port of [Pink](https://github.com/stephane-caron/pink) which uses [Pinocchio](https://github.com/stack-of-tasks/pinocchio) under the hood. Stéphane Caron, the author of Pink, is a role model for open-source software in robotics. This library would not have been possible without his work and assistance throughout this project.
 
 mink also heavily adapts code from the following libraries:
 

{mink-0.0.1.dist-info → mink-0.0.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mink/__init__.py,sha256=qLYRMUEsu-XusX2bvM_S3MJhYwYM-u3fvizqYur69XI,1627
-mink/configuration.py,sha256=6ScxC-mQwaSJ7Vp5Ofcms12qxgPUIMQ_0DacW6w_XwU,7490
+mink/__init__.py,sha256=8EUZVesmJRHjCqwB-h-NA8l7pb1o0ou0Efeg3rVIvlU,1692
+mink/configuration.py,sha256=V1Kpc5oW7Ts-db1mjAU8O-OgkjFVjKRIJ1IX-56vZ2s,8555
 mink/constants.py,sha256=hcWy4zM4hGI7vvJrTmCjJgs2WtOxKJ1IVtYHucWbOAI,813
 mink/exceptions.py,sha256=tmExo-ydn_mu9Mny5sP0Ehr7hfo3d79fM8HvvxZBKYM,2931
 mink/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mink/solve_ik.py,sha256=0ljN-CXDZFX8dPDvtyQxlI4vGoRpmeWmBkLT1-999Rw,3542
-mink/utils.py,sha256=vU3huZtKY_RWYjZRez7iZbXaagXIfGa_E6KZGbJ-oo0,4251
+mink/utils.py,sha256=-00C_AmtfvkmmWiHpds5Fu83gLcnt9OJ2KmyB01aTa8,4387
 mink/.mypy_cache/.gitignore,sha256=amnaZw0RUw038PDP3HvtMLeOpkNOJPenMgi5guKdMiw,34
 mink/.mypy_cache/CACHEDIR.TAG,sha256=8cE6_FVTWMkDOw8fMKqhd_6IvaQPS4okWYQA1UeHatw,190
 mink/.mypy_cache/3.12/@plugins_snapshot.json,sha256=RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o,2
@@ -327,26 +327,27 @@ mink/.mypy_cache/3.12/unittest/signals.meta.json,sha256=t4kGxxcZb9aDLojvZ5naLIcc
 mink/.mypy_cache/3.12/unittest/suite.data.json,sha256=3XPU9U8rt00fnG-hgEIbpIqS14lI9xQMDiBsl2_mlXQ,12050
 mink/.mypy_cache/3.12/unittest/suite.meta.json,sha256=5ADDHudtGO-JtLaD0-SB-7_Ekm34XeG_QCXLEDIZeIM,1699
 mink/lie/__init__.py,sha256=tI-lfqTHT8iABKemXZCZUEtiDtj4LC9o7DEDXpkn6tI,228
-mink/lie/base.py,sha256=p9PoZBZ-6vCGUN0kiguz2ActGtpXRInltGU2Vk9bu54,4222
+mink/lie/base.py,sha256=ummp2-yROMrcYCtsNCoKEiKoJ7wLF0nSjnOOD95aXaY,4220
 mink/lie/se3.py,sha256=R4hH4i0-do5I8bWV0le-huSuAfQ_bwolkAjJNVlDNXs,7914
-mink/lie/so3.py,sha256=ii3jYqy3KrOrNR0GLA3w5OBvujUpgRg0BXa7cPXXwFE,7238
+mink/lie/so3.py,sha256=LkjciJHcVTWYzpDzAo1KuUI7xy0HPnSGAYxQS_q-Kx4,7302
 mink/lie/utils.py,sha256=Drx_l0adSLlZl89kVLRZxMW4ctafG1pk0iucS7gShOI,608
 mink/lie/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mink/lie/tests/test_axioms.py,sha256=Vgkwoa-GtqUgiI8A5F041NfdOkP4Gxj6wUdNzHzuuFE,1756
 mink/lie/tests/test_operations.py,sha256=UTUyYA-jDm73LCe8KWOcQo0PFx45UDDm25Y1J03FVhk,2664
 mink/lie/tests/utils.py,sha256=N6B86t7BRH_Ls5yykCD4llVM2ElyXp9ze2RyLPMBUY4,562
 mink/limits/__init__.py,sha256=hX5Dgpri9AE6YtUCkW79AXMBuNAuBhniR9kQ6Rxwv3Y,416
-mink/limits/collision_avoidance_limit.py,sha256=vwi3CBdwkc04_z97xanol5Bi2khMbI94lP63ZzC0uXo,11177
-mink/limits/configuration_limit.py,sha256=I-4U2oXupdfgdQUWhDrrNmyvK58ZdrIxiOCSJjbZ-HY,3995
+mink/limits/collision_avoidance_limit.py,sha256=k7_FfoYlPRxhYfxmGt03JiCU0J4kIMgfnqQYT3qZpn8,11765
+mink/limits/configuration_limit.py,sha256=8GlOIRWHJUX9QCGrmR6YEYkpXntnQxWjd5oz2r8qUb4,4037
 mink/limits/exceptions.py,sha256=EnVKgFhUJFM6rNVCtdngb-XMu66PWKMFSDy-XkdKzr8,178
-mink/limits/limit.py,sha256=1uNmQGcYuiLQ4q9AVEZzzyekc-kQtx9d0HKKSH8_7ks,978
-mink/limits/velocity_limit.py,sha256=8q7QuBdcN5msspsz24MKGZSinrFlZEIHsby62PMtF-k,2935
-mink/tasks/__init__.py,sha256=e_6bfrOKuYdInaqd-7uPEXVWhWJH71R5UF73DaF59Pc,491
-mink/tasks/com_task.py,sha256=GvHvj1nuz_tTxglvqHL9N4VlHuNDCAHh7rgXAgrbrVY,2926
+mink/limits/limit.py,sha256=feF9yjgLHWShnuSrJNOH-PfMWtEMRGQi2mDiRia9tFg,1578
+mink/limits/velocity_limit.py,sha256=2zPOAb69V9RusKk-U4cJ0lK3-Ek9g4nvr3c8QHbixzw,3506
+mink/tasks/__init__.py,sha256=mD7kGU22-mIqkK2ZGUsglqxiLC-KePV7SYfh8Xh63TM,548
+mink/tasks/com_task.py,sha256=ch6w7pwa5E0GVo2DCAuEF-c8TCN1iMk-ySY9A4B6yoQ,3121
+mink/tasks/damping_task.py,sha256=_o8Uxt9a_MHcW7e_j5wuSPPeZhRZyN88YjwGtZbH3hM,521
 mink/tasks/exceptions.py,sha256=1BxQS_t8vuKoTd8RY0MdZOJ_-2RX--iUtVs-Bu3IVgs,708
-mink/tasks/frame_task.py,sha256=QpavqXsShhv89EeomXu9HhSqkX_MWqEaPO2Q8Y-Ik68,4472
-mink/tasks/posture_task.py,sha256=jMBmDiavG05RutJzJ4QO6xgSuSqCFbAx9bzRT8JqcjU,3125
-mink/tasks/task.py,sha256=bkhqO76lS1cgx4gJbXnJvD4WPLovTSQ3gDH8D0QAMd0,4074
-mink-0.0.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-mink-0.0.1.dist-info/METADATA,sha256=mAfZ_hgRpS8vVrvz6Z_t5uoEet0jki28ILFjFuLpvHY,3575
-mink-0.0.1.dist-info/RECORD,,
+mink/tasks/frame_task.py,sha256=DeNg-bEJxqnrRI0FaJK4UHyb8CyF4A7uPF9G-CdN0sg,5307
+mink/tasks/posture_task.py,sha256=KuDXctRlRXaxqtL2fHNijk5acKLWL27X7Dtyb6VZeuk,3548
+mink/tasks/task.py,sha256=F16YZT1L9ueNOcKoOhbCyEnZw0DOgrmjqADl0jahVQI,4838
+mink-0.0.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+mink-0.0.2.dist-info/METADATA,sha256=FYHlYmtZa5zrnHl0tomLx0RJi0Vt0bAvl8P6-74dsP8,4642
+mink-0.0.2.dist-info/RECORD,,