dartpy 0.2.0.post107__cp311-cp311-manylinux_2_28_x86_64.whl

tests/unit/collision/test_collision.py

@@ -0,0 +1,249 @@
+import platform
+
+import dartpy as dart
+import numpy as np
+import pytest
+
+
+def collision_groups_tester(cd):
+    size = [1, 1, 1]
+    pos1 = [0, 0, 0]
+    pos2 = [0.5, 0, 0]
+
+    simple_frame1 = dart.dynamics.SimpleFrame()
+    simple_frame2 = dart.dynamics.SimpleFrame()
+
+    sphere1 = dart.dynamics.SphereShape(1)
+    sphere2 = dart.dynamics.SphereShape(1)
+
+    simple_frame1.setShape(sphere1)
+    simple_frame2.setShape(sphere2)
+
+    group = cd.createCollisionGroup()
+    group.addShapeFrame(simple_frame1)
+    group.addShapeFrame(simple_frame2)
+    assert group.getNumShapeFrames() is 2
+
+    #
+    #    ( s1,s2 )              collision!
+    # ---+---|---+---+---+---+--->
+    #   -1   0  +1  +2  +3  +4
+    #
+    assert group.collide()
+
+    #
+    #    (  s1   )   (  s2   )  no collision
+    # ---+---|---+---+---+---+--->
+    #   -1   0  +1  +2  +3  +4
+    #
+    simple_frame2.setTranslation([3, 0, 0])
+    assert not group.collide()
+
+    option = dart.collision.CollisionOption()
+    result = dart.collision.CollisionResult()
+
+    group.collide(option, result)
+    assert not result.isCollision()
+    assert result.getNumContacts() is 0
+
+    option.enableContact = True
+    simple_frame2.setTranslation([1.99, 0, 0])
+
+    group.collide(option, result)
+    assert result.isCollision()
+    assert result.getNumContacts() is not 0
+
+    # Repeat the same test with BodyNodes instead of SimpleFrames
+
+    group.removeAllShapeFrames()
+    assert group.getNumShapeFrames() is 0
+
+    skel1 = dart.dynamics.Skeleton()
+    skel2 = dart.dynamics.Skeleton()
+
+    [joint1, body1] = skel1.createFreeJointAndBodyNodePair(None)
+    [joint2, body2] = skel2.createFreeJointAndBodyNodePair(None)
+
+    shape_node1 = body1.createShapeNode(sphere1)
+    shape_node1.createVisualAspect()
+    shape_node1.createCollisionAspect()
+
+    shape_node2 = body2.createShapeNode(sphere2)
+    shape_node2.createVisualAspect()
+    shape_node2.createCollisionAspect()
+
+    group.addShapeFramesOf(body1)
+    group.addShapeFramesOf(body2)
+
+    assert group.getNumShapeFrames() is 2
+
+    assert group.collide()
+
+    joint2.setPosition(3, 3)
+    assert not group.collide()
+
+    # Repeat the same test with BodyNodes and two groups
+
+    joint2.setPosition(3, 0)
+
+    group.removeAllShapeFrames()
+    assert group.getNumShapeFrames() is 0
+    group2 = cd.createCollisionGroup()
+
+    group.addShapeFramesOf(body1)
+    group2.addShapeFramesOf(body2)
+
+    assert group.getNumShapeFrames() is 1
+    assert group2.getNumShapeFrames() is 1
+
+    assert group.collide(group2)
+
+    joint2.setPosition(3, 3)
+    assert not group.collide(group2)
+
+
+def test_collision_groups():
+    cd = dart.collision.FCLCollisionDetector()
+    collision_groups_tester(cd)
+
+    cd = dart.collision.DARTCollisionDetector()
+    collision_groups_tester(cd)
+
+    if hasattr(dart.collision, "BulletCollisionDetector"):
+        cd = dart.collision.BulletCollisionDetector()
+        collision_groups_tester(cd)
+
+    if hasattr(dart.collision, "OdeCollisionDetector"):
+        cd = dart.collision.OdeCollisionDetector()
+        collision_groups_tester(cd)
+
+
+# TODO: Add more collision detectors
+@pytest.mark.parametrize("cd", [dart.collision.FCLCollisionDetector()])
+def test_filter(cd):
+    # Create two bodies skeleton. The two bodies are placed at the same position
+    # with the same size shape so that they collide by default.
+    skel = dart.dynamics.Skeleton()
+
+    shape = dart.dynamics.BoxShape(np.ones(3))
+
+    _, body0 = skel.createRevoluteJointAndBodyNodePair()
+    shape_node0 = body0.createShapeNode(shape)
+    shape_node0.createVisualAspect()
+    shape_node0.createCollisionAspect()
+
+    _, body1 = skel.createRevoluteJointAndBodyNodePair(body0)
+    shape_node1 = body1.createShapeNode(shape)
+    shape_node1.createVisualAspect()
+    shape_node1.createCollisionAspect()
+
+    # Create a world and add the created skeleton
+    world = dart.simulation.World()
+    world.addSkeleton(skel)
+
+    # Set a new collision detector
+    constraint_solver = world.getConstraintSolver()
+    constraint_solver.setCollisionDetector(cd)
+
+    # Get the collision group from the constraint solver
+    group = constraint_solver.getCollisionGroup()
+    assert group.getNumShapeFrames() == 2
+
+    # Create BodyNodeCollisionFilter
+    option = constraint_solver.getCollisionOption()
+    body_node_filter = dart.collision.BodyNodeCollisionFilter()
+    option.collisionFilter = body_node_filter
+
+    skel.enableSelfCollisionCheck()
+    skel.enableAdjacentBodyCheck()
+    assert skel.isEnabledSelfCollisionCheck()
+    assert skel.isEnabledAdjacentBodyCheck()
+    assert group.collide()
+    assert group.collide(option)
+
+    skel.enableSelfCollisionCheck()
+    skel.disableAdjacentBodyCheck()
+    assert skel.isEnabledSelfCollisionCheck()
+    assert not skel.isEnabledAdjacentBodyCheck()
+    assert group.collide()
+    assert not group.collide(option)
+
+    skel.disableSelfCollisionCheck()
+    skel.enableAdjacentBodyCheck()
+    assert not skel.isEnabledSelfCollisionCheck()
+    assert skel.isEnabledAdjacentBodyCheck()
+    assert group.collide()
+    assert not group.collide(option)
+
+    skel.disableSelfCollisionCheck()
+    skel.disableAdjacentBodyCheck()
+    assert not skel.isEnabledSelfCollisionCheck()
+    assert not skel.isEnabledAdjacentBodyCheck()
+    assert group.collide()
+    assert not group.collide(option)
+
+    # Test collision body filtering
+    skel.enableSelfCollisionCheck()
+    skel.enableAdjacentBodyCheck()
+    body_node_filter.addBodyNodePairToBlackList(body0, body1)
+    assert not group.collide(option)
+    body_node_filter.removeBodyNodePairFromBlackList(body0, body1)
+    assert group.collide(option)
+    body_node_filter.addBodyNodePairToBlackList(body0, body1)
+    assert not group.collide(option)
+    body_node_filter.removeAllBodyNodePairsFromBlackList()
+    assert group.collide(option)
+
+
+def test_raycast():
+    cd = dart.collision.BulletCollisionDetector()
+
+    simple_frame = dart.dynamics.SimpleFrame()
+    sphere = dart.dynamics.SphereShape(1)
+    simple_frame.setShape(sphere)
+
+    group = cd.createCollisionGroup()
+    group.addShapeFrame(simple_frame)
+    assert group.getNumShapeFrames() == 1
+
+    option = dart.collision.RaycastOption()
+    option.mEnableAllHits = False
+
+    result = dart.collision.RaycastResult()
+    assert not result.hasHit()
+
+    ray_hit = dart.collision.RayHit()
+
+    result.clear()
+    simple_frame.setTranslation(np.zeros(3))
+    assert group.raycast([-2, 0, 0], [2, 0, 0], option, result)
+    assert result.hasHit()
+    assert len(result.mRayHits) == 1
+    ray_hit = result.mRayHits[0]
+    assert np.isclose(ray_hit.mPoint, [-1, 0, 0]).all()
+    assert np.isclose(ray_hit.mNormal, [-1, 0, 0]).all()
+    assert ray_hit.mFraction == pytest.approx(0.25)
+
+    result.clear()
+    simple_frame.setTranslation(np.zeros(3))
+    assert group.raycast([2, 0, 0], [-2, 0, 0], option, result)
+    assert result.hasHit()
+    assert len(result.mRayHits) == 1
+    ray_hit = result.mRayHits[0]
+    assert np.isclose(ray_hit.mPoint, [1, 0, 0]).all()
+    assert np.isclose(ray_hit.mNormal, [1, 0, 0]).all()
+    assert ray_hit.mFraction == pytest.approx(0.25)
+
+    result.clear()
+    simple_frame.setTranslation([1, 0, 0])
+    assert group.raycast([-2, 0, 0], [2, 0, 0], option, result)
+    assert result.hasHit()
+    assert len(result.mRayHits) == 1
+    ray_hit = result.mRayHits[0]
+    assert np.isclose(ray_hit.mPoint, [0, 0, 0]).all()
+    assert np.isclose(ray_hit.mNormal, [-1, 0, 0]).all()
+    assert ray_hit.mFraction == pytest.approx(0.5)
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/common/test_logging.py

@@ -0,0 +1,20 @@
+import dartpy as dart
+import pytest
+
+
+def test_basics():
+    dart.common.trace("trace log")
+    dart.common.debug("debug log")
+    dart.common.info("info log")
+    dart.common.warn("warn log")
+    dart.common.error("error log")
+    dart.common.fatal("fatal log")
+
+
+def test_arguments():
+    val = 10
+    dart.common.info("Log with param '{}' and '{}'".format(1, val))
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/common/test_stopwatch.py

@@ -0,0 +1,50 @@
+import dartpy as dart
+import pytest
+
+
+def test_basics():
+    sw = dart.common.Stopwatch()
+
+    # Stopwatch is started by default
+    assert sw.isStarted()
+    assert dart.common.Stopwatch(True).isStarted()
+    assert not dart.common.Stopwatch(False).isStarted()
+
+    # Stop the stopwatch
+    sw.stop()
+    assert not sw.isStarted()
+
+    # Elapsed time should be the same
+    elapsed1 = sw.elapsedS()
+    assert elapsed1 == sw.elapsedS()
+    assert elapsed1 == sw.elapsedS()
+
+    # Elapsed time monotonically increase while the stopwatch is running
+    sw.start()
+    assert sw.elapsedS() >= elapsed1
+    assert sw.elapsedS() >= elapsed1
+
+    # Starting a stopwatch already started doesn't have any effect
+    sw.start()
+    assert sw.isStarted()
+
+    # Restting a started stopwatch resets the elapsed time but doesn't stop the
+    # stopwatch
+    sw.start()
+    sw.reset()
+    assert sw.isStarted()
+    assert sw.elapsedS() >= 0.0
+    assert sw.elapsedS() >= 0.0
+
+    # Restting a stopped stopwatch resets the elapsed time but doesn't start the
+    # stopwatch
+    sw.stop()
+    sw.reset()
+    assert not sw.isStarted()
+    assert sw.elapsedS() == pytest.approx(0.0)
+
+    sw.print()
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/common/test_string.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2011-2024, The DART development contributors
+# All rights reserved.
+#
+# The list of contributors can be found at:
+#   https://github.com/dartsim/dart/blob/main/LICENSE
+#
+# This file is provided under the "BSD-style" License
+
+import dartpy as dart
+import pytest
+
+
+def test_case_conversions():
+    assert dart.common.toUpper("to UppEr") == "TO UPPER"
+    assert dart.common.toLower("to LowEr") == "to lower"
+
+
+def test_trim():
+    assert dart.common.trimLeft(" trim ThIs ") == "trim ThIs "
+    assert dart.common.trimRight(" trim ThIs ") == " trim ThIs"
+    assert dart.common.trim(" trim ThIs ") == "trim ThIs"
+
+    assert dart.common.trimLeft("\n trim ThIs ", " ") == "\n trim ThIs "
+    assert dart.common.trimLeft("\n trim ThIs ", "\n") == " trim ThIs "
+    assert dart.common.trimRight(" trim ThIs \n", " ") == " trim ThIs \n"
+    assert dart.common.trimRight(" trim ThIs \n", "\n") == " trim ThIs "
+    assert dart.common.trim("\n trim ThIs \n", " ") == "\n trim ThIs \n"
+    assert dart.common.trim("\n trim ThIs \n", "\n") == " trim ThIs "
+
+    assert dart.common.trimLeft("\n trim ThIs \n", " \n") == "trim ThIs \n"
+    assert dart.common.trimRight("\n trim ThIs \n", " \n") == "\n trim ThIs"
+    assert dart.common.trim("\n trim ThIs \n", " \n") == "trim ThIs"
+
+
+def test_split():
+    assert len(dart.common.split(" trim ThIs ")) == 2
+    assert dart.common.split(" trim ThIs ")[0] == "trim"
+    assert dart.common.split(" trim ThIs ")[1] == "ThIs"
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/common/test_uri.py

@@ -0,0 +1,20 @@
+import platform
+
+import pytest
+from dartpy.common import Uri
+
+
+def test_from_string_valid_uri_returns_true():
+    uri = Uri()
+    assert uri.fromString("ftp://ftp.is.co.za/rfc/rfc1808.txt") is True
+    assert uri.fromString("http://www.ietf.org/rfc/rfc2396.txt") is True
+    assert uri.fromString("ldap://[2001:db8::7]/c=GB?objectClass?one") is True
+    assert uri.fromString("mailto:John.Doe@example.com") is True
+    assert uri.fromString("news:comp.infosystems.www.servers.unix") is True
+    assert uri.fromString("tel:+1-816-555-1212") is True
+    assert uri.fromString("telnet://192.0.2.16:80/") is True
+    assert uri.fromString("urn:oasis:names:specification:docbook:dtd:xml:4.1.2") is True
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/constraint/test_constraint.py

@@ -0,0 +1,42 @@
+import platform
+
+import dartpy as dart
+import numpy as np
+import pytest
+
+
+def test_ball_joint_constraint():
+    world = dart.utils.SkelParser.readWorld("dart://sample/skel/chain.skel")
+    world.setGravity([0, -9.81, 0])
+    world.setTimeStep(1.0 / 2000)
+
+    # Set joint damping
+    chain = world.getSkeleton(0)
+    for i in range(chain.getNumJoints()):
+        joint = chain.getJoint(i)
+        for j in range(joint.getNumDofs()):
+            joint.setDampingCoefficient(j, 0.01)
+
+    # Create a ball joint contraint
+    bd1 = chain.getBodyNode("link 6")
+    bd2 = chain.getBodyNode("link 10")
+    offset1 = [0, 0.025, 0]
+    joint_pos = bd1.getTransform().multiply(offset1)
+    offset2 = bd2.getTransform().inverse().multiply(joint_pos)
+    constraint = dart.constraint.BallJointConstraint(bd1, bd2, joint_pos)
+    assert constraint.getType() == dart.constraint.BallJointConstraint.getStaticType()
+
+    # Add ball joint constraint to the constraint solver
+    constraint_solver = world.getConstraintSolver()
+    constraint_solver.addConstraint(constraint)
+
+    # Check if the ball joint constraint is being satisfied
+    for _ in range(100):
+        world.step()
+        pos1 = bd1.getTransform().multiply(offset1)
+        pos2 = bd2.getTransform().multiply(offset2)
+        assert np.isclose(pos1, pos2).all()
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/dynamics/test_aspect.py

@@ -0,0 +1,15 @@
+import dartpy as dart
+import pytest
+
+
+def test_simple_frame():
+    shape_frame = dart.dynamics.SimpleFrame()
+    assert not shape_frame.hasVisualAspect()
+    assert shape_frame.getVisualAspect() is None
+    assert shape_frame.getVisualAspect(False) is None
+    visual = shape_frame.createVisualAspect()
+    assert visual is not None
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/dynamics/test_body_node.py

@@ -0,0 +1,65 @@
+import platform
+
+import dartpy as dart
+import numpy as np
+import pytest
+
+
+def test_basic():
+    urdfParser = dart.utils.DartLoader()
+    kr5 = urdfParser.parseSkeleton("dart://sample/urdf/KR5/KR5 sixx R650.urdf")
+    assert kr5 is not None
+
+    for i in range(kr5.getNumBodyNodes()):
+        body = kr5.getBodyNode(i)
+        body_force = body.getBodyForce()
+        assert body_force.size == 6
+        bodyPtr = body.getBodyNodePtr()
+        assert body == bodyPtr
+        assert body.getName() == bodyPtr.getName()
+        assert np.array_equal(np.array(body.getSpatialVelocity()), np.zeros(6)) is True
+        shape_nodes = body.getShapeNodes()
+        for shape_node in shape_nodes:
+            print(shape_node)
+            if shape_node.hasVisualAspect():
+                visual = shape_node.getVisualAspect()
+                visual.getRGBA()
+            if shape_node.hasCollisionAspect():
+                collision = shape_node.getCollisionAspect()
+            if shape_node.hasDynamicsAspect():
+                dynamics = shape_node.getDynamicsAspect()
+
+
+def test_get_child_methods():
+    urdfParser = dart.utils.DartLoader()
+    kr5 = urdfParser.parseSkeleton("dart://sample/urdf/KR5/KR5 sixx R650.urdf")
+    assert kr5 is not None
+
+    currentBodyNode = kr5.getRootBodyNode()
+    assert currentBodyNode is not None
+
+    for i in range(1, kr5.getNumBodyNodes()):
+        childBodyNode = currentBodyNode.getChildBodyNode(0)
+        childJoint = currentBodyNode.getChildJoint(0)
+
+        assert childBodyNode is not None
+        assert childJoint is not None
+        assert childBodyNode.getName() == kr5.getBodyNode(i).getName()
+        assert childJoint.getName() == kr5.getJoint(i).getName()
+
+        currentBodyNode = childBodyNode
+
+
+def test_get_inertia():
+    urdfParser = dart.utils.DartLoader()
+    kr5 = urdfParser.parseSkeleton("dart://sample/urdf/KR5/KR5 sixx R650.urdf")
+    assert kr5 is not None
+
+    inertias = [
+        kr5.getBodyNode(i).getInertia() for i in range(1, kr5.getNumBodyNodes())
+    ]
+    assert all([inertia is not None for inertia in inertias])
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/dynamics/test_inertia.py

@@ -0,0 +1,76 @@
+import math
+import platform
+
+import dartpy as dart
+import numpy as np
+import pytest
+
+
+def test_inertia_init():
+    """
+    Test basic functionality for the `dartpy.dynamics.Inertia` class.
+    """
+    # test default values
+    i1 = dart.dynamics.Inertia()
+    assert i1 is not None
+
+    # initialize with parameters
+    i2 = dart.dynamics.Inertia(0.1, [0, 0, 0], 1.3 * np.eye(3))
+    assert i1 is not None
+
+    newMass = 1.5
+    i2.setMass(newMass)
+    assert i2.getMass() == newMass
+
+    newCOM = np.array((0.1, 0, 0))
+    i2.setLocalCOM(newCOM)
+    assert np.allclose(i2.getLocalCOM(), newCOM)
+
+    newMoment = 0.4 * newMass * 0.1**2 * np.eye(3)
+    i2.setMoment(newMoment)
+    assert np.allclose(i2.getMoment(), newMoment)
+
+    i2.setSpatialTensor(0.3 * i2.getSpatialTensor())
+
+    assert i2.verify()
+
+    for i in range(10):  # based on the C++ tests
+        mass = np.random.uniform(0.1, 10.0)
+        com = np.random.uniform(-5, 5, 3)
+        I = np.random.rand(3, 3) - 0.5 + np.diag(np.random.uniform(0.6, 1, 3), 0)
+        I = (I + I.T) / 2
+
+        inertia = dart.dynamics.Inertia(mass, com, I)
+        assert inertia.verify()
+
+
+def test_inertia_static_methods():
+    """
+    Test the class methods `verifyMoment`and `verifySpatialTensor`.
+    """
+    assert dart.dynamics.Inertia.verifyMoment(np.eye(3), printWarnings=False)
+    for i in range(10):
+        I = np.random.rand(3, 3) - 0.5 + np.diag(np.random.uniform(1, 10, 3), 0)
+        I = (I + I.T) / 2
+        assert dart.dynamics.Inertia.verifyMoment(I)
+
+    assert dart.dynamics.Inertia.verifySpatialTensor(np.eye(6), printWarnings=False)
+
+
+def test_failing_moment_and_spatial():
+    """
+    Test some failure cases of the verify methods.
+    """
+
+    for i in range(10):
+        I = np.random.rand(3, 3) - 0.5 - np.diag(np.random.uniform(1, 10, 3), 0)
+        assert not dart.dynamics.Inertia.verifyMoment(I, printWarnings=False)
+
+    # fails e.g. due to off diagonal values in translational part.
+    assert not dart.dynamics.Inertia.verifySpatialTensor(
+        np.random.rand(6, 6), printWarnings=False
+    )
+
+
+if __name__ == "__main__":
+    pytest.main()

tests/unit/dynamics/test_inverse_kinematics.py

@@ -0,0 +1,98 @@
+import math
+import platform
+
+import dartpy as dart
+import numpy as np
+import pytest
+
+
+def test_solve_for_free_joint():
+    """
+    Very simple test of InverseKinematics module, applied to a FreeJoint to
+    ensure that the target is reachable
+    """
+
+    skel = dart.dynamics.Skeleton()
+    [joint0, body0] = skel.createFreeJointAndBodyNodePair()
+
+    ik = body0.getOrCreateIK()
+    assert ik.isActive()
+
+    tf = dart.math.Isometry3()
+    tf.set_translation([0, 0, 0.8])
+    tf.set_rotation(dart.math.AngleAxis(math.pi / 8.0, [0, 1, 0]).to_rotation_matrix())
+    ik.getTarget().setTransform(tf)
+
+    error_method = ik.getErrorMethod()
+    assert error_method.getMethodName() == "TaskSpaceRegion"
+    [lb, ub] = error_method.getBounds()
+    assert len(lb) is 6
+    assert len(ub) is 6
+    error_method.setBounds(np.ones(6) * -1e-8, np.ones(6) * 1e-8)
+    [lb, ub] = error_method.getBounds()
+    assert lb == pytest.approx(-1e-8)
+    assert ub == pytest.approx(1e-8)
+
+    solver = ik.getSolver()
+    solver.setNumMaxIterations(100)
+
+    prob = ik.getProblem()
+
+    tf_actual = ik.getTarget().getTransform().matrix()
+    tf_expected = body0.getTransform().matrix()
+    assert not np.isclose(tf_actual, tf_expected).all()
+
+    success = solver.solve()
+    assert success
+
+    tf_actual = ik.getTarget().getTransform().matrix()
+    tf_expected = body0.getTransform().matrix()
+    assert np.isclose(tf_actual, tf_expected).all()
+
+
+class FailingSolver(dart.optimizer.Solver):
+    def __init__(self, constant):
+        super(FailingSolver, self).__init__()
+        self.constant = constant
+
+    def solve(self):
+        problem = self.getProblem()
+        if problem is None:
+            print(
+                "[FailingSolver::solve] Attempting to solve a nullptr problem! We will return false."
+            )
+            return False
+
+        dim = problem.getDimension()
+        wrong_solution = np.ones(dim) * self.constant
+        problem.setOptimalSolution(wrong_solution)
+
+        return False
+
+    def getType(self):
+        return "FailingSolver"
+
+    def clone(self):
+        return FailingSolver(self.constant)
+
+
+def test_do_not_apply_solution_on_failure():
+    skel = dart.dynamics.Skeleton()
+    [joint, body] = skel.createFreeJointAndBodyNodePair()
+
+    ik = body.getIK(True)
+    solver = FailingSolver(10)
+    ik.setSolver(solver)
+
+    dofs = skel.getNumDofs()
+    skel.resetPositions()
+
+    assert not ik.solveAndApply(allowIncompleteResult=False)
+    assert np.isclose(skel.getPositions(), np.zeros(dofs)).all()
+
+    assert not ik.solveAndApply(allowIncompleteResult=True)
+    assert not np.isclose(skel.getPositions(), np.zeros(dofs)).all()
+
+
+if __name__ == "__main__":
+    pytest.main()