agx-openplx 0.15.1__cp39-cp39-win_amd64.whl → 0.15.2__cp39-cp39-win_amd64.whl

openplx/__init__.py

@@ -1,51 +1,55 @@
-# pylint: disable=C0103 # name doesn't conform to snake_case naming style
+# pylint: disable=invalid-name
 """
 __init__ module for OpenPLX package
 """
 import os
 import sys
-__AGXVERSION__ = "2.38.0.2"
-__version__ = "0.15.1"
-
-# pylint doesn't like bare excepts, but we need to catch all exceptions here
-# pylint: disable=W0702 # bare-except
-# pylint doesn't like below errors which is normally ok, but this file is copied to the right place during build
-# pylint: disable=E0402 # Attempted relative import beyond top-level
-# pylint: disable=E0611 # Missing name in module
-# pylint: disable=W0611 # Unused import
-# pylint: disable=W0401 # Wildcard import
+import traceback
+# Use agx_env if available
+import importlib.util
+if importlib.util.find_spec("agx_env"):
+    import agx_env # pylint: disable=unused-import
+__AGXVERSION__ = "2.39.0.1"
+__version__ = "0.15.2"
 
 try:
     import agx
     if agx.__version__ != __AGXVERSION__:
         print(f"This version of agx-openplx is compiled for AGX {__AGXVERSION__} and may crash with your {agx.__version__} version, "+
               "update agx-openplx or AGX to make sure the versions are suited for eachother")
-except:
+except Exception as e: # pylint: disable=broad-exception-caught
+    traceback.print_exc()
     print("Failed finding AGX Dynamics, have you run setup_env?")
     sys.exit(255)
 
 if "DEBUG_AGXOPENPLX" in os.environ:
     print("#### Using Debug build ####")
     try:
+        # pylint: disable=relative-beyond-top-level, wildcard-import, unused-import, no-name-in-module
         from .debug.api import *
         from .debug import Core
         from .debug import Math
         from .debug import Physics
         from .debug import Simulation
-    except:
+        # pylint: enable=relative-beyond-top-level, wildcard-import, unused-import, no-name-in-module
+    except Exception as e: # pylint: disable=broad-exception-caught
+        traceback.print_exc()
         print("Failed finding OpenPLX modules or libraries, did you set PYTHONPATH correctly? "+
-              "Should point to where OpenPLX directory with binaries are located")
+              "Should point to where OpenPLX directory with binaries are located.")
         print("Also, make sure you are using the same Python version the libraries were built for.")
         sys.exit(255)
 else:
     try:
+        # pylint: disable=relative-beyond-top-level, wildcard-import, unused-import, no-name-in-module
         from .api import *
         from . import Core
         from . import Math
         from . import Physics
         from . import Simulation
-    except:
+        # pylint: enable=relative-beyond-top-level, wildcard-import, unused-import, no-name-in-module
+    except Exception as e: # pylint: disable=broad-exception-caught
+        traceback.print_exc()
         print("Failed finding OpenPLX modules or libraries, did you set PYTHONPATH correctly? "+
-              "Should point to where OpenPLX directory with binaries are located")
+              "Should point to where OpenPLX directory with binaries are located.")
         print("Also, make sure you are using the same Python version the libraries were built for.")
         sys.exit(255)

openplx/api.py

@@ -407,117 +407,126 @@ class AgxToOpenPlxMapper(object):
 # Register AgxToOpenPlxMapper in _AgxOpenPlxPyApi:
 _AgxOpenPlxPyApi.AgxToOpenPlxMapper_swigregister(AgxToOpenPlxMapper)
 
-class Signals(object):
-    r"""Proxy of C++ agxopenplx::Signals class."""
+class InputSignalQueue(object):
+    r"""Proxy of C++ agxopenplx::InputSignalQueue class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
     __repr__ = _swig_repr
 
     @staticmethod
-    def popInputSignals():
-        r"""popInputSignals() -> Physics_Signals_InputSignal_Vector"""
-        return _AgxOpenPlxPyApi.Signals_popInputSignals()
+    def create():
+        r"""create() -> std::shared_ptr< agxopenplx::InputSignalQueue >"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_create()
 
-    @staticmethod
-    def sendInputSignal(signal):
+    def send(self, signal):
         r"""
-        sendInputSignal(agxopenplx::InputSignalPtr signal) -> bool
+        send(InputSignalQueue self, agxopenplx::InputSignalPtr signal)
 
         Parameters
         ----------
         signal: agxopenplx::InputSignalPtr
 
         """
-        return _AgxOpenPlxPyApi.Signals_sendInputSignal(signal)
+        return _AgxOpenPlxPyApi.InputSignalQueue_send(self, signal)
 
-    @staticmethod
-    def getOutputSignals():
-        r"""getOutputSignals() -> Physics_Signals_OutputSignal_Vector"""
-        return _AgxOpenPlxPyApi.Signals_getOutputSignals()
+    def getSignals(self):
+        r"""getSignals(InputSignalQueue self) -> Physics_Signals_InputSignal_Vector"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_getSignals(self)
 
-    @staticmethod
-    def sendOutputSignal(signal):
-        r"""
-        sendOutputSignal(agxopenplx::OutputSignalPtr signal) -> bool
+    def popSignals(self):
+        r"""popSignals(InputSignalQueue self) -> Physics_Signals_InputSignal_Vector"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_popSignals(self)
 
-        Parameters
-        ----------
-        signal: agxopenplx::OutputSignalPtr
+    def clear(self):
+        r"""clear(InputSignalQueue self)"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_clear(self)
 
-        """
-        return _AgxOpenPlxPyApi.Signals_sendOutputSignal(signal)
+    def size(self):
+        r"""size(InputSignalQueue self) -> size_t"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_size(self)
 
-    @staticmethod
-    def clearOutputSignals():
-        r"""clearOutputSignals()"""
-        return _AgxOpenPlxPyApi.Signals_clearOutputSignals()
+    def empty(self):
+        r"""empty(InputSignalQueue self) -> bool"""
+        return _AgxOpenPlxPyApi.InputSignalQueue_empty(self)
+    __swig_destroy__ = _AgxOpenPlxPyApi.delete_InputSignalQueue
 
-    def __init__(self):
-        r"""__init__(Signals self) -> Signals"""
-        _AgxOpenPlxPyApi.Signals_swiginit(self, _AgxOpenPlxPyApi.new_Signals())
-    __swig_destroy__ = _AgxOpenPlxPyApi.delete_Signals
+# Register InputSignalQueue in _AgxOpenPlxPyApi:
+_AgxOpenPlxPyApi.InputSignalQueue_swigregister(InputSignalQueue)
 
-# Register Signals in _AgxOpenPlxPyApi:
-_AgxOpenPlxPyApi.Signals_swigregister(Signals)
+def InputSignalQueue_create():
+    r"""InputSignalQueue_create() -> std::shared_ptr< agxopenplx::InputSignalQueue >"""
+    return _AgxOpenPlxPyApi.InputSignalQueue_create()
 
-def Signals_popInputSignals():
-    r"""Signals_popInputSignals() -> Physics_Signals_InputSignal_Vector"""
-    return _AgxOpenPlxPyApi.Signals_popInputSignals()
+class OutputSignalQueue(object):
+    r"""Proxy of C++ agxopenplx::OutputSignalQueue class."""
 
-def Signals_sendInputSignal(signal):
-    r"""
-    Signals_sendInputSignal(agxopenplx::InputSignalPtr signal) -> bool
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 
-    Parameters
-    ----------
-    signal: agxopenplx::InputSignalPtr
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
+    __repr__ = _swig_repr
 
-    """
-    return _AgxOpenPlxPyApi.Signals_sendInputSignal(signal)
+    @staticmethod
+    def create():
+        r"""create() -> std::shared_ptr< agxopenplx::OutputSignalQueue >"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_create()
 
-def Signals_getOutputSignals():
-    r"""Signals_getOutputSignals() -> Physics_Signals_OutputSignal_Vector"""
-    return _AgxOpenPlxPyApi.Signals_getOutputSignals()
+    def send(self, signal):
+        r"""
+        send(OutputSignalQueue self, agxopenplx::OutputSignalPtr signal)
 
-def Signals_sendOutputSignal(signal):
-    r"""
-    Signals_sendOutputSignal(agxopenplx::OutputSignalPtr signal) -> bool
+        Parameters
+        ----------
+        signal: agxopenplx::OutputSignalPtr
 
-    Parameters
-    ----------
-    signal: agxopenplx::OutputSignalPtr
+        """
+        return _AgxOpenPlxPyApi.OutputSignalQueue_send(self, signal)
 
-    """
-    return _AgxOpenPlxPyApi.Signals_sendOutputSignal(signal)
+    def getSignals(self):
+        r"""getSignals(OutputSignalQueue self) -> Physics_Signals_OutputSignal_Vector"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_getSignals(self)
 
-def Signals_clearOutputSignals():
-    r"""Signals_clearOutputSignals()"""
-    return _AgxOpenPlxPyApi.Signals_clearOutputSignals()
+    def popSignals(self):
+        r"""popSignals(OutputSignalQueue self) -> Physics_Signals_OutputSignal_Vector"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_popSignals(self)
 
+    def clear(self):
+        r"""clear(OutputSignalQueue self)"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_clear(self)
 
-def findAllOutputs(openplx_scene):
-    r"""
-    findAllOutputs(openplx::Core::ObjectPtr const & openplx_scene) -> Physics_Signals_Output_Vector
+    def size(self):
+        r"""size(OutputSignalQueue self) -> size_t"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_size(self)
 
-    Parameters
-    ----------
-    openplx_scene: openplx::Core::ObjectPtr const &
+    def empty(self):
+        r"""empty(OutputSignalQueue self) -> bool"""
+        return _AgxOpenPlxPyApi.OutputSignalQueue_empty(self)
+    __swig_destroy__ = _AgxOpenPlxPyApi.delete_OutputSignalQueue
+
+# Register OutputSignalQueue in _AgxOpenPlxPyApi:
+_AgxOpenPlxPyApi.OutputSignalQueue_swigregister(OutputSignalQueue)
+
+def OutputSignalQueue_create():
+    r"""OutputSignalQueue_create() -> std::shared_ptr< agxopenplx::OutputSignalQueue >"""
+    return _AgxOpenPlxPyApi.OutputSignalQueue_create()
 
-    """
-    return _AgxOpenPlxPyApi.findAllOutputs(openplx_scene)
 class InputSignalListener(agxSDK.StepEventListener):
     r"""Proxy of C++ agxopenplx::InputSignalListener class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, assembly):
+    def __init__(self, assembly, input_queue):
         r"""
-        __init__(InputSignalListener self, Assembly assembly) -> InputSignalListener
+        __init__(InputSignalListener self, Assembly assembly, std::shared_ptr< agxopenplx::InputSignalQueue > input_queue) -> InputSignalListener
 
         Parameters
         ----------
         assembly: agxSDK::Assembly *
+        input_queue: std::shared_ptr< agxopenplx::InputSignalQueue >
 
         """
 
@@ -525,7 +534,7 @@ class InputSignalListener(agxSDK.StepEventListener):
             assembly = assembly.get()
 
 
-        _AgxOpenPlxPyApi.InputSignalListener_swiginit(self, _AgxOpenPlxPyApi.new_InputSignalListener(assembly))
+        _AgxOpenPlxPyApi.InputSignalListener_swiginit(self, _AgxOpenPlxPyApi.new_InputSignalListener(assembly, input_queue))
 
     def preCollide(self, time):
         r"""
@@ -558,14 +567,15 @@ class OutputSignalListener(agxSDK.StepEventListener):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, assembly, openplx_scene):
+    def __init__(self, assembly, openplx_scene, output_queue):
         r"""
-        __init__(OutputSignalListener self, Assembly assembly, std::shared_ptr< openplx::Core::Object > const & openplx_scene) -> OutputSignalListener
+        __init__(OutputSignalListener self, Assembly assembly, std::shared_ptr< openplx::Core::Object > const & openplx_scene, std::shared_ptr< agxopenplx::OutputSignalQueue > output_queue) -> OutputSignalListener
 
         Parameters
         ----------
         assembly: agxSDK::Assembly *
         openplx_scene: std::shared_ptr< openplx::Core::Object > const &
+        output_queue: std::shared_ptr< agxopenplx::OutputSignalQueue >
 
         """
 
@@ -573,7 +583,7 @@ class OutputSignalListener(agxSDK.StepEventListener):
             assembly = assembly.get()
 
 
-        _AgxOpenPlxPyApi.OutputSignalListener_swiginit(self, _AgxOpenPlxPyApi.new_OutputSignalListener(assembly, openplx_scene))
+        _AgxOpenPlxPyApi.OutputSignalListener_swiginit(self, _AgxOpenPlxPyApi.new_OutputSignalListener(assembly, openplx_scene, output_queue))
 
     def syncOutputSignals(self):
         r"""syncOutputSignals(OutputSignalListener self)"""
@@ -647,19 +657,20 @@ class ClickInputListener(object):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, server, openplx_scene, time_step, autostepping_enabled):
+    def __init__(self, server, openplx_scene, input_queue, time_step, autostepping_enabled):
         r"""
-        __init__(ClickInputListener self, std::shared_ptr< click::Server > & server, std::shared_ptr< openplx::Core::Object > const & openplx_scene, double time_step, bool autostepping_enabled) -> ClickInputListener
+        __init__(ClickInputListener self, std::shared_ptr< click::Server > & server, std::shared_ptr< openplx::Core::Object > const & openplx_scene, std::shared_ptr< agxopenplx::InputSignalQueue > input_queue, double time_step, bool autostepping_enabled) -> ClickInputListener
 
         Parameters
         ----------
         server: std::shared_ptr< click::Server > &
         openplx_scene: std::shared_ptr< openplx::Core::Object > const &
+        input_queue: std::shared_ptr< agxopenplx::InputSignalQueue >
         time_step: double
         autostepping_enabled: bool
 
         """
-        _AgxOpenPlxPyApi.ClickInputListener_swiginit(self, _AgxOpenPlxPyApi.new_ClickInputListener(server, openplx_scene, time_step, autostepping_enabled))
+        _AgxOpenPlxPyApi.ClickInputListener_swiginit(self, _AgxOpenPlxPyApi.new_ClickInputListener(server, openplx_scene, input_queue, time_step, autostepping_enabled))
     __swig_destroy__ = _AgxOpenPlxPyApi.delete_ClickInputListener
 
     def preFrame(self, arg2):
@@ -743,19 +754,20 @@ class OsgClickInputListener(ClickInputListener):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, server, openplx_scene, time_step, autostepping_enabled):
+    def __init__(self, server, openplx_scene, input_queue, time_step, autostepping_enabled):
         r"""
-        __init__(OsgClickInputListener self, std::shared_ptr< click::Server > & server, std::shared_ptr< openplx::Core::Object > const & openplx_scene, double time_step, bool autostepping_enabled) -> OsgClickInputListener
+        __init__(OsgClickInputListener self, std::shared_ptr< click::Server > & server, std::shared_ptr< openplx::Core::Object > const & openplx_scene, std::shared_ptr< agxopenplx::InputSignalQueue > input_queue, double time_step, bool autostepping_enabled) -> OsgClickInputListener
 
         Parameters
         ----------
         server: std::shared_ptr< click::Server > &
         openplx_scene: std::shared_ptr< openplx::Core::Object > const &
+        input_queue: std::shared_ptr< agxopenplx::InputSignalQueue >
         time_step: double
         autostepping_enabled: bool
 
         """
-        _AgxOpenPlxPyApi.OsgClickInputListener_swiginit(self, _AgxOpenPlxPyApi.new_OsgClickInputListener(server, openplx_scene, time_step, autostepping_enabled))
+        _AgxOpenPlxPyApi.OsgClickInputListener_swiginit(self, _AgxOpenPlxPyApi.new_OsgClickInputListener(server, openplx_scene, input_queue, time_step, autostepping_enabled))
 
     def preFrame(self, app):
         r"""
@@ -794,16 +806,17 @@ class ClickOutputListener(agxSDK.StepEventListener):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, server):
+    def __init__(self, server, output_queue):
         r"""
-        __init__(ClickOutputListener self, std::shared_ptr< click::Server > & server) -> ClickOutputListener
+        __init__(ClickOutputListener self, std::shared_ptr< click::Server > & server, std::shared_ptr< agxopenplx::OutputSignalQueue > output_queue) -> ClickOutputListener
 
         Parameters
         ----------
         server: std::shared_ptr< click::Server > &
+        output_queue: std::shared_ptr< agxopenplx::OutputSignalQueue >
 
         """
-        _AgxOpenPlxPyApi.ClickOutputListener_swiginit(self, _AgxOpenPlxPyApi.new_ClickOutputListener(server))
+        _AgxOpenPlxPyApi.ClickOutputListener_swiginit(self, _AgxOpenPlxPyApi.new_ClickOutputListener(server, output_queue))
 
     def post(self, prev_step):
         r"""
@@ -891,9 +904,9 @@ class OsgClickAdapter(object):
         r"""willSendResetMessage(OsgClickAdapter self) -> bool"""
         return _AgxOpenPlxPyApi.OsgClickAdapter_willSendResetMessage(self)
 
-    def add_listeners(self, app, simulation, click_server_addr, openplx_scene, output_signal_listener):
+    def add_listeners(self, app, simulation, click_server_addr, openplx_scene, input_queue, output_queue, output_signal_listener):
         r"""
-        add_listeners(OsgClickAdapter self, agxOSG::ExampleApplication * app, Simulation simulation, std::string const & click_server_addr, std::shared_ptr< openplx::Core::Object > const & openplx_scene, OutputSignalListener output_signal_listener)
+        add_listeners(OsgClickAdapter self, agxOSG::ExampleApplication * app, Simulation simulation, std::string const & click_server_addr, std::shared_ptr< openplx::Core::Object > const & openplx_scene, std::shared_ptr< agxopenplx::InputSignalQueue > input_queue, std::shared_ptr< agxopenplx::OutputSignalQueue > output_queue, OutputSignalListener output_signal_listener)
 
         Parameters
         ----------
@@ -901,23 +914,26 @@ class OsgClickAdapter(object):
         simulation: agxSDK::Simulation *
         click_server_addr: std::string const &
         openplx_scene: std::shared_ptr< openplx::Core::Object > const &
+        input_queue: std::shared_ptr< agxopenplx::InputSignalQueue >
+        output_queue: std::shared_ptr< agxopenplx::OutputSignalQueue >
         output_signal_listener: agxopenplx::OutputSignalListener *
 
         """
-        return _AgxOpenPlxPyApi.OsgClickAdapter_add_listeners(self, app, simulation, click_server_addr, openplx_scene, output_signal_listener)
+        return _AgxOpenPlxPyApi.OsgClickAdapter_add_listeners(self, app, simulation, click_server_addr, openplx_scene, input_queue, output_queue, output_signal_listener)
 
-    def createClickInputListener(self, openplx_scene, time_step, auto_stepping):
+    def createClickInputListener(self, openplx_scene, input_queue, time_step, auto_stepping):
         r"""
-        createClickInputListener(OsgClickAdapter self, std::shared_ptr< openplx::Core::Object > const & openplx_scene, double time_step, bool auto_stepping) -> std::shared_ptr< agxopenplx::ClickInputListener >
+        createClickInputListener(OsgClickAdapter self, std::shared_ptr< openplx::Core::Object > const & openplx_scene, std::shared_ptr< agxopenplx::InputSignalQueue > input_queue, double time_step, bool auto_stepping) -> std::shared_ptr< agxopenplx::ClickInputListener >
 
         Parameters
         ----------
         openplx_scene: std::shared_ptr< openplx::Core::Object > const &
+        input_queue: std::shared_ptr< agxopenplx::InputSignalQueue >
         time_step: double
         auto_stepping: bool
 
         """
-        return _AgxOpenPlxPyApi.OsgClickAdapter_createClickInputListener(self, openplx_scene, time_step, auto_stepping)
+        return _AgxOpenPlxPyApi.OsgClickAdapter_createClickInputListener(self, openplx_scene, input_queue, time_step, auto_stepping)
 
     def __init__(self):
         r"""__init__(OsgClickAdapter self) -> OsgClickAdapter"""

openplx/migrate.py

@@ -11,12 +11,12 @@ import urllib.request
 import zipfile
 from io import BytesIO
 from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter, SUPPRESS
+import agx
 from openplx import __version__, get_error_strings
 from openplx.Core import OpenPlxContext, parseFromFile, analyze, StringVector, DocumentVector
-from openplx.migrations import collect_migrations, ReplaceOp
+from openplx.migrations import collect_migrations, ReplaceOp, split_version
 from openplx.versionaction import VersionAction
 from openplx import register_plugins
-import agx
 
 def download_package_version(package_name, version):
     """Download a specific version of a package from PyPI."""
@@ -26,6 +26,7 @@ def download_package_version(package_name, version):
     data = json.loads(content)
     return data['urls'][0]['url']
 
+
 def unzip_package(url, extract_to):
     """Download and unzip a package."""
     with urllib.request.urlopen(url, timeout=32) as response:
@@ -62,20 +63,16 @@ def has_errors(openplx_context):
         return True
     return False
 
-def refactor_openplx_file(openplxfile, bundle_path_vec, from_version, to_version) -> bool: # pylint: disable=too-many-locals
+def refactor_openplx_file(migration, openplxfile, bundle_path_vec, from_version, to_version) -> bool: # pylint: disable=too-many-locals
     print(f"Migrating {openplxfile} from {from_version} to {to_version}")
-    migrations = collect_migrations(from_version, to_version)
-    print(f"Found {len(migrations)} migrations ", [m.__name__ for m in migrations])
-
     file_rename_migrations = []
-    for migration in [m for m in migrations if m.__name__ == "rename_from_brick_to_openplx"]:
+    if migration.__name__ == "rename_from_brick_to_openplx":
         file_rename_migrations.append(migration(openplxfile))
-    if (openplxfile.endswith("config.openplx") or openplxfile.endswith("config.brick")):
-        for m in file_rename_migrations:
-            m.apply_to(None, None)
-        return True
+        if openplxfile.endswith("config.openplx") or openplxfile.endswith("config.brick"):
+            for m in file_rename_migrations:
+                m.apply_to(None, None)
+            return True
 
-    migrations = [m for m in migrations if m.__name__ != "rename_from_brick_to_openplx"]
     openplx_context = OpenPlxContext(bundle_path_vec)
     register_plugins(openplx_context, None)
     documents = parse_and_analyze(openplxfile, openplx_context)
@@ -83,13 +80,11 @@ def refactor_openplx_file(openplxfile, bundle_path_vec, from_version, to_version
     if has_errors(openplx_context):
         return False
 
-    order_group = [(key, list(group)) for key, group in itertools.groupby(migrations, lambda m: m.openplx_order)]
-    order_group.sort(key=lambda pair: pair[0])
-
-    for _, migration_group in order_group:
-        ops = []
-        for migration in migration_group:
-            ops.extend(migration(documents))
+    if migration.__name__ == "rename_from_brick_to_openplx":
+        for m in file_rename_migrations:
+            m.apply_to(None, None)
+    else:
+        ops = migration(documents)
 
         for key, op_group in itertools.groupby(ops, lambda op: op.path):
             if Path(openplxfile).samefile(key):
@@ -100,20 +95,43 @@ def refactor_openplx_file(openplxfile, bundle_path_vec, from_version, to_version
                 with open(key, 'w', encoding="utf8") as file:
                     file.writelines(lines)
 
-    for m in file_rename_migrations:
-        m.apply_to(None, None)
-
     return True
 
-def run_openplx_migrate(args):
-
-    # NOTE: Depending on version, we need to change the package_name
-    package_name = 'brickbundles'
+def config_file_path(openplxfile, version):
+    config_file_name = 'config.openplx'
+    if split_version(version) < (0, 15, 0):
+        config_file_name = 'config.brick'
+    if os.path.isdir(openplxfile):
+        return os.path.join(openplxfile, config_file_name)
+    return os.path.join(os.path.dirname(openplxfile), config_file_name)
+
+def migrate_config_file_versions(config_path, from_version, to_version):
+    bundles = ["Math", "Physics", "Physics1D", "Physics3D",
+               "Robotics", "Urdf", "Terrain", "Vehicles",
+               "Simulation", "Visuals", "DriveTrain"]
+    add_versions = (split_version(from_version) < (0, 11, 0)
+                    and split_version(to_version) >= (0, 11, 0))
+    if os.path.exists(config_path):
+        with open(config_path, 'r', encoding="utf8") as file:
+            lines = file.readlines()
+        lines = list(map(lambda line: line.replace(f"=={from_version}", f"=={to_version}"), lines))
+        if add_versions:
+            for i in range(len(lines)): # pylint: disable=consider-using-enumerate
+                for bundle in bundles:
+                    lines[i] = lines[i].replace(f"\"{bundle}\"", f"\"{bundle}=={to_version}\"")
+        with open(config_path, 'w', encoding="utf8") as file:
+            file.writelines(lines)
+
+def run_openplx_migrate_from_version(migration, from_version, to_version, openplxfile): # pylint: disable=too-many-locals
+    package_name = 'openplx-bundles'
+
+    if split_version(from_version) < (0, 15, 0):
+        package_name = 'brickbundles'
 
     # Download the package
-    url = download_package_version(package_name, args.from_version)
+    url = download_package_version(package_name, from_version)
     if url is None:
-        print(f"Could not find the source distribution for {package_name}=={args.from_version}.")
+        print(f"Could not find the source distribution for {package_name}=={from_version}.")
         return
 
     # Create a temporary directory
@@ -121,8 +139,8 @@ def run_openplx_migrate(args):
         tmp_path = str(Path(os.path.realpath(tmpdirname)).absolute())
         print(f"Extracting to temporary directory: {tmp_path}")
         unzip_package(url, tmp_path)
-        print(f"Package {package_name}=={args.from_version} extracted to {tmp_path}")
-        bundle_path = str((Path(tmp_path) / package_name).absolute())
+        print(f"Package {package_name}=={from_version} extracted to {tmp_path}")
+        bundle_path = str((Path(tmp_path) / package_name.replace("-", "")).absolute())
 
         print(f'Using bundle path {bundle_path}')
         print(os.listdir(bundle_path))
@@ -131,22 +149,38 @@ def run_openplx_migrate(args):
         bundle_path_vec.push_back(bundle_path)
         success = True
         # Apply the refactoring
-        if os.path.isdir(args.openplxfile):
-            for root, _, files in os.walk(args.openplxfile):
+        if os.path.isdir(openplxfile):
+            for root, _, files in os.walk(openplxfile):
                 for file in files:
                     if file.endswith(".openplx") or file.endswith(".brick"):
                         openplxfile = os.path.join(root, file)
-                        if not refactor_openplx_file(openplxfile, bundle_path_vec, args.from_version, args.to_version):
+                        if not refactor_openplx_file(migration, openplxfile,
+                                                     bundle_path_vec, from_version, to_version):
                             success = False
         else:
-            if not refactor_openplx_file(args.openplxfile, bundle_path_vec, args.from_version, args.to_version):
+            if not refactor_openplx_file(migration, openplxfile,
+                                         bundle_path_vec, from_version, to_version):
                 success = False
         if success:
-            print(f"Refactor from {args.from_version} to {args.to_version} complete!")
+            print(f"Refactor from {from_version} to {to_version} complete!")
         else:
-            print(f"Refactor from {args.from_version} to {args.to_version} failed due to errors!")
+            print(f"Refactor from {from_version} to {to_version} failed due to errors!")
             print("Note, some files might have been partially migrated.")
 
+
+def run_openplx_migrate(args):
+    migrations = collect_migrations(args.from_version, args.to_version)
+    current_version = args.from_version
+    for migration in migrations:
+        migrate_config_file_versions(config_file_path(args.openplxfile, current_version),
+                                     current_version, migration.openplx_from_version)
+        run_openplx_migrate_from_version(migration, migration.openplx_from_version,
+                                         migration.openplx_to_version, args.openplxfile)
+        migrate_config_file_versions(
+            config_file_path(args.openplxfile, migration.openplx_from_version),
+            migration.openplx_from_version, migration.openplx_to_version)
+        current_version = migration.openplx_to_version
+
 def run():
     arguments, _ = parse_args()
     init = agx.AutoInit()  # pylint: disable=W0612 # Unused variable 'init'