refactor(api): Move old module package into legacy_api

api/opentrons/__init__.py

@@ -25,15 +25,17 @@
 if ff.use_protocol_api_v2():
     import protocol_api
     from protocol_api.back_compat\
-        import robot, reset as bcreset, instruments, containers, labware
+        import robot, reset as bcreset, instruments, containers, labware,\
+        modules
 
     def reset():
         ctx = protocol_api.ProtocolContext()
         bcreset(ctx)
 
 else:
-    from .legacy_api.api import robot, reset, instruments, containers, labware
+    from .legacy_api.api\
+        import robot, reset, instruments, containers, labware, modules
 
 
 __all__ = ['containers', 'instruments', 'labware', 'robot', 'reset',
-           '__version__']
+           '__version__', 'modules']

api/opentrons/legacy_api/api.py

@@ -1,13 +1,15 @@
-from . import robot, instruments as inst, containers as cnt
+from . import robot, instruments as inst, containers as cnt, modules
 from .instruments import pipette_config
 
 # Ignore the type here because well, this is exactly why this is the legacy_api
 robot = robot.Robot()  # type: ignore
+modules.provide_singleton(robot)
 
 
 def reset():
     global robot
     robot = robot.Robot()
+    modules.provide_singleton(robot)
     return robot
 
 
@@ -259,5 +261,7 @@ def _retrieve_version_number(self, mount, expected_model_substring):
 instruments = InstrumentsWrapper(robot)
 containers = ContainersWrapper(robot)
 labware = ContainersWrapper(robot)
+modules.provide_labware(labware)
 
-__all__ = ['containers', 'instruments', 'labware', 'robot', 'reset']
+
+__all__ = ['containers', 'instruments', 'labware', 'robot', 'reset', 'modules']

api/opentrons/modules/__init__.py → api/opentrons/legacy_api/modules/__init__.py

@@ -2,9 +2,8 @@
 import logging
 import re
 import asyncio
-from opentrons.modules.magdeck import MagDeck
-from opentrons.modules.tempdeck import TempDeck
-from opentrons import robot, labware
+from .magdeck import MagDeck
+from .tempdeck import TempDeck
 
 log = logging.getLogger(__name__)
 
@@ -25,11 +24,25 @@ class AbsentModuleError(Exception):
     pass
 
 
+_mod_robot = None
+_mod_labware = None
+
+
+def provide_singleton(robot):
+    global _mod_robot
+    _mod_robot = robot
+
+
+def provide_labware(lw):
+    global _mod_labware
+    _mod_labware = lw
+
+
 def load(name, slot):
     module_instance = None
     if name in SUPPORTED_MODULES:
-        if robot.is_simulating():
-            labware_instance = labware.load(name, slot)
+        if _mod_robot.is_simulating():
+            labware_instance = _mod_labware.load(name, slot)
             module_class = SUPPORTED_MODULES.get(name)
             module_instance = module_class(lw=labware_instance)
         else:
@@ -39,13 +52,13 @@ def load(name, slot):
             # accessor would then load the correct disambiguated module
             # instance via the module's serial
             matching_modules = [
-                module for module in robot.modules if isinstance(
+                module for module in _mod_robot.modules if isinstance(
                     module, SUPPORTED_MODULES.get(name)
                 )
             ]
             if matching_modules:
                 module_instance = matching_modules[0]
-                labware_instance = labware.load(name, slot)
+                labware_instance = _mod_labware.load(name, slot)
                 module_instance.labware = labware_instance
             else:
                 raise AbsentModuleError(

api/opentrons/protocol_api/back_compat.py

@@ -42,6 +42,14 @@ def list(self, *args, **kwargs):
         pass
 
 
+class BCModules:
+    def __init__(self, ctx: 'papi.ProtocolContext') -> None:
+        self._ctx = ctx
+
+    def load(self, *args, **wargs):
+        pass
+
+
 def reset(api: 'papi.ProtocolContext'):
     global robot
     global labware