agx-openplx 0.15.0__cp39-cp39-macosx_12_0_arm64.whl → 0.15.2__cp39-cp39-macosx_12_0_arm64.whl

openplx/migrations.py

@@ -25,9 +25,8 @@ def migration(from_version: str, to_version: str, order: int = 0):
 
     return decorator
 
-
-@migration("0.9.2", "0.9.3")
-def snakecaseify_methods(documents):
+@migration("0.9.3", "0.10.0")
+def snakecaseify_methods_093(documents): # pylint: disable=too-many-statements
     ops = []
     ops.extend(RefactorToolkit.renameMethod(documents, "Math.Vec3.fromXYZ", "from_xyz"))
     ops.extend(
@@ -118,13 +117,6 @@ def snakecaseify_methods(documents):
     ops.extend(
         RefactorToolkit.renameMethod(documents, "Math.Line.fromPoints", "from_points")
     )
-
-    return [ReplaceOp(op) for op in ops]
-
-
-@migration("0.9.3", "0.10.0")
-def snakecaseify_methods_093(documents):
-    ops = []
     # ValueOutputSignal
     ops.extend(
         RefactorToolkit.renameMethod(
@@ -450,6 +442,185 @@ def migrations_for_0_13_1(documents):
 
     return [ReplaceOp(op) for op in ops]
 
+@migration("0.14.0", "0.15.0")
+def rename_from_brick_to_openplx(document_path):
+
+    return ChangeExtensionOp(Path(document_path), ".openplx")
+
+
+@migration("0.15.1", "0.15.2")
+def migrations_for_0_15_1(documents):
+    ops = []
+    ops.extend(
+        RefactorToolkit.renameModel(
+            documents,
+            "Robotics.Joints.TorqueDriveTrain",
+            "FlexibleJointDriveTrain",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameModel(
+            documents,
+            "Robotics.Joints.AngularVelocityDriveTrain",
+            "FlexibleJointDriveTrain",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.HingeAngularVelocityOutput",
+            "Physics.Signals",
+            "AngularVelocity1DOutput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.HingeAngularVelocityOutput.hinge", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "DriveTrain.Signals.TorqueMotorInput",
+            "Physics.Signals",
+            "Torque1DInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "DriveTrain.Signals.TorqueMotorInput.motor", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.LinearSpringPositionInput",
+            "Physics.Signals",
+            "Position1DInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.LinearSpringPositionInput.spring", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.TorsionSpringAngleInput",
+            "Physics.Signals",
+            "AngleInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.TorsionSpringAngleInput.spring", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.RigidBodyRPYOutput",
+            "Physics3D.Signals",
+            "RPYOutput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.RigidBodyRPYOutput.rigid_body", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.RigidBodyPositionOutput",
+            "Physics3D.Signals",
+            "Position3DOutput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.RigidBodyPositionOutput.rigid_body", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Interactions.VelocityMotor.desired_speed", "target_speed"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics1D.Interactions.VelocityMotor.desired_speed", "target_speed"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.RotationalVelocityMotorVelocityInput",
+            "Physics.Signals",
+            "AngularVelocity1DInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.RotationalVelocityMotorVelocityInput.motor", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics1D.Signals.RotationalVelocityMotor1DVelocityInput",
+            "Physics.Signals",
+            "AngularVelocity1DInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics1D.Signals.RotationalVelocityMotor1DVelocityInput.motor", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics3D.Signals.LinearVelocityMotorVelocityInput",
+            "Physics.Signals",
+            "LinearVelocity1DInput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics3D.Signals.LinearVelocityMotorVelocityInput.motor", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics1D.Signals.RotationalBodyAngularVelocityOutput",
+            "Physics.Signals",
+            "AngularVelocity1DOutput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics1D.Signals.RotationalBodyAngularVelocityOutput.body", "source"
+        )
+    )
+    ops.extend(
+        RefactorToolkit.moveAndRenameModel(
+            documents,
+            "Physics1D.Signals.RotationalBodyAngleOutput",
+            "Physics.Signals",
+            "AngleOutput",
+        )
+    )
+    ops.extend(
+        RefactorToolkit.renameAttribute(
+            documents, "Physics1D.Signals.RotationalBodyAngleOutput.body", "source"
+        )
+    )
+
+    return [ReplaceOp(op) for op in ops]
+
 
 def split_version(v):
     match = re.match(r"^(\d+)\.(\d+)\.(\d+)", v)
@@ -482,6 +653,17 @@ class MigrateOp(ABC):  # pylint: disable=R0903 # Too few public methods
         pass
 
 
+class ChangeExtensionOp(MigrateOp):
+    def __init__(self, path: Path, new_extension: str):
+        self.path = path
+        self.new_extension = new_extension
+
+    def __str__(self):
+        return f"{{ {self.path}, {self.new_extension} }}"
+
+    def apply_to(self, _lines, _offset):
+        self.path.rename(self.path.with_suffix(self.new_extension))
+
 class ReplaceOp(MigrateOp):
     def __init__(self, op: RefactorReplaceOp):
         self.path = Path(op.source_id)

openplx/openplx_application.py

@@ -12,7 +12,7 @@ from openplxbundles import bundle_path
 # Import useful utilities to access the current simulation, graphics root and application
 from agxPythonModules.utils.environment import init_app, simulation, application, root
 
-from openplx import InputSignalListener, OutputSignalListener, OsgClickAdapter
+from openplx import InputSignalQueue, OutputSignalQueue, InputSignalListener, OutputSignalListener, OsgClickAdapter
 from openplx import load_from_file, OptParams, addVisuals, addDeformableVisualUpdaters, __version__, set_log_level, add_file_changed_listener
 from openplx.versionaction import VersionAction
 
@@ -21,6 +21,7 @@ def dummy_build_scene():
 
 class AgxHelpAction(Action):
     def __call__(self, parser, namespace, values, option_string=None):
+        sys.argv.append("--usage")
         OpenPlxApplication(dummy_build_scene).start_agx()
         sys.exit(0)
 
@@ -38,7 +39,7 @@ class OpenPlxApplication:
         self.build_scene_file = sys.modules[self.build_scene.__module__].__file__ if build_scene_file is None else build_scene_file
 
     @staticmethod
-    def parse_args(openplxfile = None):
+    def setup_args_parser(openplxfile = None):
         parser = ArgumentParser(description="View OpenPLX models", formatter_class=ArgumentDefaultsHelpFormatter)
         if openplxfile is None:
             parser.add_argument("openplxfile", help="the .openplx file to load")
@@ -58,20 +59,20 @@ class OpenPlxApplication:
                             default="info")
         parser.add_argument("--modelname", help="The model to load (defaults to last model in file)", metavar="<name>", default=None)
         parser.add_argument("--reload-on-update", help="Reload scene automatically when source is updated", action="store_true", default=SUPPRESS)
-        parser.add_argument("--usage", help="Show AGX specific help", action=AgxHelpAction, nargs=0, default=SUPPRESS)
+        parser.add_argument("--agxhelp", help="Show AGX specific help", action=AgxHelpAction, nargs=0, default=SUPPRESS)
         parser.add_argument("--version", help="Show version", action=VersionAction, nargs=0, default=SUPPRESS)
-        return parser.parse_known_args()
+        return parser
 
     @staticmethod
-    def prepareScene(openplxfile = None): # pylint: disable=invalid-name
-        args, extra_args = OpenPlxApplication.parse_args(openplxfile)
+    def prepare_scene(openplxfile = None):
+        args, extra_args = OpenPlxApplication.setup_args_parser(openplxfile).parse_known_args()
         set_log_level(args.loglevel)
         if extra_args:
             print(f"Passing these args to AGX: {(' ').join(extra_args)}")
 
         opt_params = OptParams()
         if args.modelname is not None:
-            opt_params.with_model_name(args.modelname)
+            opt_params = opt_params.with_model_name(args.modelname)
 
         result = load_from_file(simulation(), args.openplxfile if openplxfile is None else openplxfile, args.bundle_path, opt_params)
 
@@ -79,8 +80,10 @@ class OpenPlxApplication:
         openplx_scene = result.scene()
 
         # Add signal listeners so that signals are picked up from inputs
-        input_signal_listener = InputSignalListener(assembly)
-        output_signal_listener = OutputSignalListener(assembly, openplx_scene)
+        input_queue = InputSignalQueue.create()
+        output_queue = OutputSignalQueue.create()
+        input_signal_listener = InputSignalListener(assembly, input_queue)
+        output_signal_listener = OutputSignalListener(assembly, openplx_scene, output_queue)
 
         simulation().add(input_signal_listener, InputSignalListener.RECOMMENDED_PRIO)
         simulation().add(output_signal_listener, OutputSignalListener.RECOMMENDED_PRIO)
@@ -97,13 +100,14 @@ class OpenPlxApplication:
 
         if "enable_click" in args:
             click_adapter = globals()["click_adapter"]
-            click_adapter.add_listeners(application(), simulation(), args.click_addr, openplx_scene, output_signal_listener)
+            click_adapter.add_listeners(application(), simulation(), args.click_addr, openplx_scene,
+                                        input_queue, output_queue, output_signal_listener)
 
         if not addVisuals(result, root(), args.debug_render_frames):
             application().setEnableDebugRenderer(True)
         simulation().add(assembly.get())
         addDeformableVisualUpdaters(result, root())
-        return openplx_scene
+        return openplx_scene, input_queue, output_queue
 
     @staticmethod
     def ctrl_break_handler(_signum, _frame):
@@ -123,11 +127,12 @@ class OpenPlxApplication:
     def start_agx(self):
         # Tell AGX where build_scene is located
         sys.argv[0] = self.build_scene_file
-        # pylint: disable=W0612 # Unused variable 'init'
         # Use __main__ otherwise AGX will just skip the init
-        init = init_app(name="__main__", scenes=[(self.build_scene, "1")], autoStepping=True, onShutdown=self.on_shutdown)  # Default: False
+        # pylint: disable=unused-variable
+        init = init_app(name="__main__", scenes=[(self.build_scene, "1")], autoStepping=True, onShutdown=self.on_shutdown)
+        # pylint: enable=unused-variable
 
     def run(self):
         signal.signal(signal.SIGINT, self.ctrl_break_handler)
-        self.parse_args("")
+        self.setup_args_parser("").parse_known_args()
         self.start_agx()

openplx/openplx_validate.py

@@ -20,11 +20,11 @@ def parse_args():
                         metavar="<bundle_path>", default=bundle_path())
     parser.add_argument("--debug-render-frames", action='store_true', help="enable rendering of frames for mate connectors and rigid bodies.")
     parser.add_argument("--loglevel", choices=["trace", "debug", "info", "warn", "error", "critical", "off"], help="Set log level", default="warn")
-    parser.add_argument("--modelname", help="The model to load (defaults to last model in file)", metavar="<name>", default="")
+    parser.add_argument("--modelname", help="The model to load (defaults to last model in file)", metavar="<name>", default=None)
     parser.add_argument("--version", help="Show version", action=VersionAction, nargs=0, default=SUPPRESS)
     return parser.parse_args()
 
-class AllowCtrlBreakListener(agxOSG.ExampleApplicationListener):
+class AllowCtrlBreakListener(agxOSG.ExampleApplicationListener): # pylint: disable=too-few-public-methods
     pass
 
 def validate():
@@ -37,7 +37,7 @@ def validate():
 
     opt_params = OptParams()
     if args.modelname is not None:
-        opt_params.with_model_name(args.modelname)
+        opt_params = opt_params.with_model_name(args.modelname)
 
     result = load_from_file(simulation, args.openplxfile, args.bundle_path, opt_params)
 

openplx/openplx_view.py

@@ -5,7 +5,7 @@ Command line utility that loads OpenPLX files and loads them into an AGX Simulat
 from openplx.openplx_application import OpenPlxApplication
 
 def openplx_view_build_scene():
-    OpenPlxApplication.prepareScene()
+    OpenPlxApplication.prepare_scene()
 
 def run():
     OpenPlxApplication(openplx_view_build_scene).run()

agx_openplx-0.15.0.dist-info/METADATA

@@ -1,231 +0,0 @@
-Metadata-Version: 2.1
-Name: agx-openplx
-Version: 0.15.0
-Summary: AGX-OpenPLX python interface development
-Home-page: https://pub.algoryx.dev/openplx/
-License: Apache 2.0
-Author: Algoryx
-Author-email: algoryx@algoryx.com
-Requires-Python: >=3.8
-Classifier: Intended Audience :: Manufacturing
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Topic :: Scientific/Engineering :: Visualization
-Requires-Dist: agx (==2.38.0.2)
-Requires-Dist: openplx-bundles (>=0.15.0,<0.16.0)
-Requires-Dist: pclick (>=0.4.1,<0.5.0)
-Description-Content-Type: text/markdown
-
-# AGX OpenPLX
-
-The agx-openplx package implements all OpenPLX bundles such as Physics, Robotics, DriveTrain and Simulation using [AGX Dynamics Real-time multi-body simulation](https://www.algoryx.se/agx-dynamics/).
-The package contains python bindings and native libraries needed to load and run .openplx files.
-
-See [OpenPLX documentation](https://pub.algoryx.dev/openplx/) for more info on OpenPLX.
-
-## Prerequisites
-
-- Python 3.9 on Windows or OSX
-- Python 3.8 on Ubuntu 20.04
-- Python 3.10 on Ubuntu 22.04
-- [AGX Dynamics](https://www.algoryx.se/agx-dynamics/) 2.38.0.2 and an AGX Dynamics License
-
-At [OpenPLX documentation](https://pub.algoryx.dev/openplx/getopenplx/) you can find out which older version of OpenPLX matches which version of AGX.
-
-## Install
-
-To get the version corresponding to your AGX on Windows do:
-
-```bash
-setup_env.bat
-pip install %AGX_DATA_DIR%/agx-pypi
-pip install -U agx-openplx
-```
-
-To get the version corresponding to your AGX on OSX and Linux do:
-
-```bash
-source setup_env.sh
-pip3 install $AGX_DATA_DIR/agx-pypi
-pip3 install -U agx-openplx
-```
-
-## License
-
-[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)
-
-## Usage Examples
-
-Given the python file and openplx file below, run with:
-
-```bash
-python3 inverted_pendulum.py
-```
-
-To just simulate the openplx file without controllers, do:
-
-```bash
-openplx_view inverted_pendulum.openplx
-```
-
-or `python3 -m openplx.openplx_view inverted_pendulum.openplx`
-
-Store contents below in a new file named `inverted_pendulum.openplx`:
-
-```openplx
-Rod is Physics3D.Bodies.RigidBody:
-    inertia.mass: 10
-    geometry is Physics3D.Charges.Box:
-        size: Math.Vec3.from_xyz(0.1, 0.1, 1)
-    arrow is Physics3D.Charges.Box:
-        local_transform:
-            position.z: 0.5
-            rotation: Math.Quat.angleAxis(Math.PI / 4, Math.Vec3.Y_AXIS())
-        size: Math.Vec3.from_xyz(0.071, 0.1, 0.071)
-    mate_connector is Physics3D.Charges.MateConnector:
-        position.z: -geometry.size.z * 0.7
-        main_axis: Math.Vec3.Y_AXIS()
-        normal: Math.Vec3.Z_AXIS()
-
-Cart is Physics3D.Bodies.RigidBody:
-    inertia.mass: 10
-    geometry is Physics3D.Charges.Box:
-        size: Math.Vec3.from_xyz(0.1, 0.1, 0.1)
-    connector is Physics3D.Charges.MateConnector:
-        main_axis: Math.Vec3.X_AXIS()
-        normal: Math.Vec3.Z_AXIS()
-    rotated_connector is Physics3D.Charges.MateConnector:
-        main_axis: Math.Vec3.Y_AXIS()
-        normal: Math.Vec3.Z_AXIS()
-
-PendulumScene is Physics3D.System:
-    world_connector is Physics3D.Charges.MateConnector:
-        main_axis: Math.Vec3.X_AXIS()
-        normal: Math.Vec3.Z_AXIS()
-
-    cart is Cart
-    rod is Rod
-
-    prismatic is Physics3D.Interactions.Prismatic:
-        charges: [world_connector, cart.connector]
-
-    cart_motor is Physics3D.Interactions.LinearVelocityMotor:
-        desired_speed: 0
-        charges: prismatic.charges
-
-    hinge is Physics3D.Interactions.Hinge:
-        initial_angle: 0
-        charges: [cart.rotated_connector, rod.mate_connector]
-
-    motor_input is Physics3D.Signals.LinearVelocityMotorVelocityInput:
-        motor: cart_motor
-
-    hinge_angle_output is Physics3D.Signals.HingeAngleOutput:
-        hinge: hinge
-    hinge_angular_velocity_output is Physics3D.Signals.HingeAngularVelocityOutput:
-        hinge: hinge
-
-    cart_position_output is Physics3D.Signals.RigidBodyPositionOutput:
-        rigid_body: cart
-    cart_velocity_output is Physics3D.Signals.RigidBodyVelocityOutput:
-        rigid_body: cart
-```
-
-Store contents below in a new file named `inverted_pendulum.py`:
-
-```python
-import os
-import signal
-import agxOSG
-import agxSDK
-from openplxbundles import bundle_path
-
-# Import useful utilities to access the current simulation, graphics root and application
-from agxPythonModules.utils.environment import init_app, simulation, root
-
-from openplx import Math, Physics, Physics3D, Signals
-from openplx import InputSignalListener, OutputSignalListener, load_from_file
-
-def file_dir():
-    return os.path.dirname(os.path.abspath(__file__))
-
-def pendulum():
-    return f"{file_dir()}/inverted_pendulum.openplx"
-
-class PDController:
-    def __init__(self, kp, kd, goal):
-        self.kp = kp
-        self.kd = kd
-        self.goal = goal
-
-    def observe(self, x, xdot):
-        error = self.goal - x
-        return self.kp * error - self.kd * xdot
-
-
-class CartController(agxSDK.StepEventListener):
-    motor_input: Physics3D.Signals_LinearVelocityMotorVelocityInput
-    cart: PDController
-    pole: PDController
-
-    def __init__(self, motor_input: Physics3D.Signals_LinearVelocityMotorVelocityInput):
-        super().__init__()
-        self.motor_input = motor_input
-        self.cart = PDController(kp=10, kd=5, goal=0)
-        self.pole = PDController(kp=20, kd=5, goal=0)
-
-    def pre(self, time):
-        if time == 0.0:
-            hinge_angle = 0
-            hinge_angular_velocity = 0
-            cart_position = Math.Vec3.from_xyz(0,0,0)
-            cart_velocity = Math.Vec3.from_xyz(0,0,0)
-        else:
-            signal_values = {signal.source().getName():signal.value().value() for signal in Signals.getOutputSignals()}
-            hinge_angle = signal_values["PendulumScene.hinge_angle_output"]
-            hinge_angular_velocity = signal_values["PendulumScene.hinge_angular_velocity_output"]
-            cart_position = signal_values["PendulumScene.cart_position_output"]
-            cart_velocity = signal_values["PendulumScene.cart_velocity_output"]
-
-        u_cart = self.cart.observe(cart_position.x(), cart_velocity.x())
-        u_pole = self.pole.observe(hinge_angle, hinge_angular_velocity)
-
-        Signals.sendInputSignal(Physics.Signals_RealInputSignal.create(-u_cart - u_pole, self.motor_input))
-
-
-def buildScene():
-
-    result = load_from_file(simulation(), pendulum(), bundle_path(), "")
-    assembly = result.assembly()
-    openplx_scene = result.scene()
-    # Add a signal listener so that signals are picked up from inputs
-    input_signal_listener = InputSignalListener(assembly)
-    output_signal_listener = OutputSignalListener(assembly, openplx_scene)
-    simulation().add(input_signal_listener, InputSignalListener.RECOMMENDED_PRIO)
-    simulation().add(output_signal_listener, OutputSignalListener.RECOMMENDED_PRIO)
-    simulation().add(assembly.get())
-    agxOSG.createVisual(assembly.get(), root())
-
-    motor_input: Physics3D.Signals_LinearVelocityMotorVelocityInput = openplx_scene.getDynamic("motor_input").asObject()
-    controller = CartController(motor_input)
-    simulation().add(controller)
-
-
-def handler(_, __):
-    os._exit(0)
-
-signal.signal(signal.SIGINT, handler)
-
-init = init_app(name=__name__,
-                scenes=[(buildScene, '1')],
-                autoStepping=True,  # Default: False
-                onInitialized=lambda app: print('App successfully initialized.'),
-                onShutdown=lambda app: print('App successfully shut down.'))
-```
-

agx_openplx-0.15.0.dist-info/RECORD

@@ -1,41 +0,0 @@
-openplx/Core.py,sha256=8V0Y0pJANycjq8SpFEUmqb3cNiqQbFkRI8IagtcsMFE,270043
-openplx/DriveTrain.py,sha256=c7N8ivmXsfTeGnVSFaEM7-CzKpjOalZK7ZpQqxgjI1Y,418894
-openplx/Math.py,sha256=kTaoNjhQSmvVHmo1WV3z9GdjNvuzPSXFW6kd-UQpJAQ,188561
-openplx/Physics.py,sha256=A2TcVBtnpTh7WJjpRruH1Me70kTBKaIc2k0xCMZNtjs,1884436
-openplx/Physics1D.py,sha256=wix9M9SMRvmGSPrQyCKWdMM7IqdkkVI9Vi7eyrMrfIE,345906
-openplx/Physics3D.py,sha256=5YQwAXEAp-CMP8Ajqvj_QKgTj3Uvp7gWI9vyRsQ5D0A,2437851
-openplx/Robotics.py,sha256=NvqWJbCpk1jDZvJJVi0PijOwOpWZm2OZGZJ1_HegNj8,798979
-openplx/Simulation.py,sha256=mIuypCjz1O6c9_x4O_Ro6GLhOiXRzNlZlVjdgoGYq3U,46318
-openplx/Terrain.py,sha256=9CxizkDVf9UtPIyBumenXzfbxAL6yn2G_d0_ZWbv-JY,184884
-openplx/Urdf.py,sha256=JOryVyaFIROiyJ9V9OMrZAS3MoUwVmJW_2TTPSsRlH4,23780
-openplx/Vehicles.py,sha256=QmtdIawHlYcIRtJH4LotXSQNs06rCpxPl6e5gklUvWg,450074
-openplx/Visuals.py,sha256=lYBFzzPZvMeWaKzXQgzikmO-fuDshcgf5uCJJQ-WKTM,187052
-openplx/_AgxOpenPlxPyApi.cpython-39-darwin.so,sha256=UNT_6ZHQ7CTkFJ0JV0pNqqxTHIWvfH7I7b6k_w3HkuA,12442370
-openplx/_CorePythonSwig.cpython-39-darwin.so,sha256=AC1Au-yZE8eefWcZh4iQ0Oq2LWExqJswpmOLl8T_5rM,3234113
-openplx/_DriveTrainSwig.cpython-39-darwin.so,sha256=S7K59t90bLKImeeDcs6pFN5dCryqv64tNesbnxHjQU4,6557505
-openplx/_MathSwig.cpython-39-darwin.so,sha256=sayquEba_a8Dz4oTlrHuTJW1NqeirzqeetLbHT4YO7g,2121771
-openplx/_Physics1DSwig.cpython-39-darwin.so,sha256=PJm_3eoDi4OuU6hp6FM_sDxrckT8Z0kP8pl9HjasHdM,4094304
-openplx/_Physics3DSwig.cpython-39-darwin.so,sha256=h7NsNvuDGXHtL0iVsJ_kbchUnfzmoKtrCgSLEa9i-AI,16812448
-openplx/_PhysicsSwig.cpython-39-darwin.so,sha256=V2snA_N-So-EKgROP1wTMP_FXwc3A3dgP-MMY_Xah_4,12399070
-openplx/_RoboticsSwig.cpython-39-darwin.so,sha256=qzsEP-XNczq2XByPFPnV7Ov_0qPwbB4nFss7fq5Sk-s,9431775
-openplx/_SimulationSwig.cpython-39-darwin.so,sha256=GLM3sAMVORYN_y4kMfW-sL5jkojHt-TNAyyd9-78Wm8,2310593
-openplx/_TerrainSwig.cpython-39-darwin.so,sha256=bWJ0k3fM4JtS3W09lOpExQlZetx7KTMcRXRDFX1KwNY,4833198
-openplx/_UrdfSwig.cpython-39-darwin.so,sha256=Uo_6kWz6hNJHI-a_oU0fbTYMvzjQkjcj-BA7mTO3FX8,3854011
-openplx/_VehiclesSwig.cpython-39-darwin.so,sha256=lRCt62LggLFZGR1oF4xSDRIvipX_ChivunOLrV4TPCY,6575247
-openplx/_VisualsSwig.cpython-39-darwin.so,sha256=n4R9qwQ6Y3f_1QkzJHW-8tFZgi9oilF7kOSYo5milEA,2249374
-openplx/__init__.py,sha256=84JW4DGXG1xhGs6hL701s4_zXS_ksXBfgboChdrwBoE,2050
-openplx/agxtoopenplx.py,sha256=gxQgZ_Pgda_5scCCBBhyu8D-jjL1yxlE7bZLtxigKCs,2422
-openplx/anytoopenplx.py,sha256=qAZVnelFOVAQIpCQt3y9LlfCBHQcNmxUWXFbCZuNQUc,2274
-openplx/api.py,sha256=05ECQBudlYfrMh1OgAYbq8VDsj_UlZKlPxx31RGnES0,46915
-openplx/migrate.py,sha256=Lm3dyiAH-1NUV9xjtCCKOj1GldYkw5DggJM8GO_p4us,5602
-openplx/migration_hint.py,sha256=2Xs2OB_HikmiynDAk4xHKhmU5N4pqOnPFPpeIWhK37Y,603
-openplx/migrations.py,sha256=-j9it2oNK0A4Z-PCPyXRE0UYdU4kMpbVEVoEIjGxkFA,15094
-openplx/openplx_application.py,sha256=VDSsIGCDay8__omhsdKkSRaqmvY_vH6yLHQr3fTzyzA,6346
-openplx/openplx_serialize.py,sha256=Uul2-6_BwyJzg26JdgAz2MjR37mQJ6kWKjPbmE-sJzk,1456
-openplx/openplx_validate.py,sha256=pqBg9WBh7OUi63dOmmCpDWt_jTn8OhCSmtgL-nmb1XY,2055
-openplx/openplx_view.py,sha256=nUca0BVnTTcCzGoj8q2f3QVmZFpKd3PPptjuKqoHA18,350
-openplx/versionaction.py,sha256=Obj_q69dn5GnFMZs2as87ZScPMLaLAduPppmXUzLB6I,283
-agx_openplx-0.15.0.dist-info/METADATA,sha256=n0lbchTEYxII_StBn_BQjEzYA-X-z40E8jL7Yk8mfBg,7824
-agx_openplx-0.15.0.dist-info/WHEEL,sha256=O5AT1Qb1jPpISLjIwxiRxhUaN9TX1BFXuc9iRVvoPmk,104
-agx_openplx-0.15.0.dist-info/entry_points.txt,sha256=IyHBVBNuH_4ZhfWnB1ZVXYtpKG_QT7dwGIUMLWdyhrc,263
-agx_openplx-0.15.0.dist-info/RECORD,,