feat: Look up any instrument by name, and ensure name is unique

qcodes/instrument/base.py

@@ -73,6 +73,8 @@ class Instrument(Metadatable, DelegateAttributes, NestedAttrAccess):
 
     shared_kwargs = ()
 
+    _all_instruments = {}
+
     def __new__(cls, *args, server_name='', **kwargs):
         """Figure out whether to create a base instrument or proxy."""
         if server_name is None:
@@ -207,16 +209,35 @@ def record_instance(cls, instance):
         """
         Record (a weak ref to) an instance in a class's instance list.
 
+        Also records the instance in list of *all* instruments, and verifies
+        that there are no other instruments with the same name.
+
         Args:
             instance (Union[Instrument, RemoteInstrument]): Note: we *do not*
                 check that instance is actually an instance of ``cls``. This is
                 important, because a ``RemoteInstrument`` should function as an
                 instance of the instrument it proxies.
+
+        Raises:
+            KeyError: if another instance with the same name is already present
         """
+        wr = weakref.ref(instance)
+        name = instance.name
+
+        # First insert this instrument in the record of *all* instruments
+        # making sure its name is unique
+        existing_wr = cls._all_instruments.get(name)
+        if existing_wr and existing_wr():
+            raise KeyError('Another instrument has the name: {}'.format(name))
+
+        cls._all_instruments[name] = wr
+
+        # Then add it to the record for this specific subclass, using ``_type``
+        # to make sure we're not recording it in a base class instance list
         if getattr(cls, '_type', None) is not cls:
             cls._type = cls
             cls._instances = []
-        cls._instances.append(weakref.ref(instance))
+        cls._instances.append(wr)
 
     @classmethod
     def instances(cls):
@@ -251,6 +272,74 @@ def remove_instance(cls, instance):
         if wr in cls._instances:
             cls._instances.remove(wr)
 
+        # remove from all_instruments too, but don't depend on the
+        # name to do it, in case name has changed or been deleted
+        all_ins = cls._all_instruments
+        for name, ref in list(all_ins.items()):
+            if ref is wr:
+                del all_ins[name]
+
+    @classmethod
+    def find_instrument(cls, name, instrument_class=None):
+        """
+        Find an existing instrument by name.
+
+        Args:
+            name (str)
+            instrument_class (Optional[class]): The type of instrument
+                you are looking for.
+
+        Returns:
+            Union[Instrument, RemoteInstrument]
+
+        Raises:
+            KeyError: if no instrument of that name was found, or if its
+                reference is invalid (dead).
+            TypeError: if a specific class was requested but a different
+                type was found
+        """
+        ins = cls._all_instruments[name]()
+
+        if ins is None:
+            del cls._all_instruments[name]
+            raise KeyError('Instrument {} has been removed'.format(name))
+
+        if instrument_class is not None:
+            if not isinstance(ins, instrument_class):
+                raise TypeError(
+                    'Instrument {} is {} but {} was requested'.format(
+                        name, type(ins), instrument_class))
+
+        return ins
+
+    @classmethod
+    def find_component(cls, name_attr, instrument_class=None):
+        """
+        Find a component of an existing instrument by name and attribute.
+
+        Args:
+            name_attr (str): A string in nested attribute format:
+                <name>.<attribute>[.<subattribute>] and so on.
+                For example, <attribute> can be a parameter name,
+                or a method name.
+            instrument_class (Optional[class]): The type of instrument
+                you are looking for this component within.
+
+        Returns:
+            Any: The component requested.
+        """
+
+        if '.' in name_attr:
+            name, attr = name_attr.split('.', 1)
+            ins = cls.find_instrument(name, instrument_class=instrument_class)
+            return ins.getattr(attr)
+
+        else:
+            # allow find_component to return the whole instrument,
+            # if no attribute was specified, for maximum generality.
+            return cls.find_instrument(name_attr,
+                                       instrument_class=instrument_class)
+
     def add_parameter(self, name, parameter_class=StandardParameter,
                       **kwargs):
         """

qcodes/instrument/remote.py

@@ -62,9 +62,11 @@ def __init__(self, *args, instrument_class=None, server_name='',
         self._args = args
         self._kwargs = kwargs
 
-        instrument_class.record_instance(self)
         self.connect()
 
+        # must come after connect() because that sets self.name
+        instrument_class.record_instance(self)
+
     def connect(self):
         """Create the instrument on the server and replicate its API here."""
 
@@ -181,6 +183,23 @@ def instances(self):
         """
         return self._instrument_class.instances()
 
+    def find_instrument(self, name, instrument_class=None):
+        """
+        Find an existing instrument by name.
+
+        Args:
+            name (str)
+
+        Returns:
+            Union[Instrument, RemoteInstrument]
+
+        Raises:
+            KeyError: if no instrument of that name was found, or if its
+                reference is invalid (dead).
+        """
+        return self._instrument_class.find_instrument(
+            name, instrument_class=instrument_class)
+
     def close(self):
         """Irreversibly close and tear down the server & remote instruments."""
         if hasattr(self, '_manager'):

qcodes/instrument/server.py

@@ -113,6 +113,13 @@ def __init__(self, query_queue, response_queue, shared_kwargs):
         self.instruments = {}
         self.next_id = 0
 
+        # Ensure no references of instruments defined in the main process
+        # are copied to the server process. With the spawn multiprocessing
+        # method this is not an issue, as the class is reimported in the
+        # new process, but with fork it can be a problem ironically.
+        from qcodes.instrument.base import Instrument
+        Instrument._all_instruments = {}
+
         self.run_event_loop()
 
     def handle_new_id(self):

qcodes/tests/instrument_mocks.py

@@ -74,6 +74,23 @@ def meter_get(self, parameter):
         elif parameter[:5] == 'echo ':
             return self.fmt(float(parameter[5:]))
 
+    # alias because we need new names when we instantiate an instrument
+    # locally at the same time as remotely
+    def gateslocal_set(self, parameter, value):
+        return self.gates_set(parameter, value)
+
+    def gateslocal_get(self, parameter):
+        return self.gates_get(parameter)
+
+    def sourcelocal_set(self, parameter, value):
+        return self.source_set(parameter, value)
+
+    def sourcelocal_get(self, parameter):
+        return self.source_get(parameter)
+
+    def meterlocal_get(self, parameter):
+        return self.meter_get(parameter)
+
 
 class ParamNoDoc:
 
@@ -115,8 +132,8 @@ def add5(self, b):
 
 class MockGates(MockInstTester):
 
-    def __init__(self, model=None, **kwargs):
-        super().__init__('gates', model=model, delay=0.001, **kwargs)
+    def __init__(self, name='gates', model=None, **kwargs):
+        super().__init__(name, model=model, delay=0.001, **kwargs)
 
         for i in range(3):
             cmdbase = 'c{}'.format(i)
@@ -164,8 +181,8 @@ def slow_neg_set(self, val):
 
 class MockSource(MockInstTester):
 
-    def __init__(self, model=None, **kwargs):
-        super().__init__('source', model=model, delay=0.001, **kwargs)
+    def __init__(self, name='source', model=None, **kwargs):
+        super().__init__(name, model=model, delay=0.001, **kwargs)
 
         self.add_parameter('amplitude', get_cmd='ampl?',
                            set_cmd='ampl:{:.4f}', get_parser=float,
@@ -175,8 +192,8 @@ def __init__(self, model=None, **kwargs):
 
 class MockMeter(MockInstTester):
 
-    def __init__(self, model=None, **kwargs):
-        super().__init__('meter', model=model, delay=0.001, **kwargs)
+    def __init__(self, name='meter', model=None, **kwargs):
+        super().__init__(name, model=model, delay=0.001, **kwargs)
 
         self.add_parameter('amplitude', get_cmd='ampl?', get_parser=float)
         self.add_function('echo', call_cmd='echo {:.2f}?',