SoftwareDevice: Define deserialised functions in a namespace with __file__ set to the name

of the device, so that a lyse.Run will use this as the results group name.

Requires lyse pull request #72

Author: chrisjbillington

SoftwareDevice/blacs_workers.py

@@ -26,14 +26,20 @@
 GREEN = '#A6E22E'
 GREY = '#75715E' 
 
-def deserialise_function_table(function_table):
+def deserialise_function_table(function_table, device_name):
     table = []
     for t, name, source, args, kwargs in function_table:
         if t == -np.inf:
             t = 'start'
         elif t == np.inf:
             t = 'stop'
-        function, args, kwargs = deserialise_function(name, source, args, kwargs)
+        # We deserialise the functions in a namespace with the given __name__ and
+        # __file__ so that if the user instantiates a lyse.Run object, that the results
+        # will automatically be saved to a results group with the name of this
+        # SoftwareDevice, since lyse.Run inspects the filename to determine this.
+        function, args, kwargs = deserialise_function(
+            name, source, args, kwargs, __name__=device_name, __file__=device_name
+        )
         table.append((t, name, function, args, kwargs))
     return table
 
@@ -59,7 +65,9 @@ def transition_to_buffered(self, device_name, h5_file, initial_values, fresh):
                 return {}
             function_table = group['FUNCTION_TABLE'][:]
 
-        self.function_table = deserialise_function_table(function_table)
+        self.function_table = deserialise_function_table(
+            function_table, self.device_name
+        )
         self.shot_context = ShotContext(h5_file, self.device_name)
         if self.function_table[0][0] != 'start':
             rich_print("no start functions", color=GREY)
@@ -70,7 +78,7 @@ def transition_to_buffered(self, device_name, h5_file, initial_values, fresh):
             if t != 'start':
                 break
             del self.function_table[0]
-            rich_print(f"  t={t}: {name}()",color=BLUE)
+            rich_print(f"  t={t}: {name}()", color=BLUE)
             function(self.shot_context, t, *args, **kwargs)
         rich_print("[finished start functions]", color=PURPLE)
         return {}
@@ -96,3 +104,6 @@ def shutdown(self):
 
     def abort_buffered(self):
         return self.transition_to_manual()
+
+    def abort_transition_to_buffered(self):
+        return True

SoftwareDevice/labscript_devices.py

@@ -21,12 +21,13 @@ def add_function(self, t, function, *args, **kwargs):
         instantiating this device to control the relative order that its 'start' and
         'stop' functions run compared to the transition_to_manual and
         transition_to_buffered functions of other devices. Multiple functions added to
-        run at the same time will be run in the order added.
+        run at the same time will be run in the order added. Running functions mid-shot
+        in software time is yet to be implemented.
 
         The function must have a call signature like the following:
 
-        def func(shot_context, t, ...):
-            ...
+            def func(shot_context, t, ...):
+                ...
 
         When it is called, a ShotContext instance will be passed in as the first
         argument, and the time at which the function was requested to run as the second
@@ -45,12 +46,25 @@ def func(shot_context, t, ...):
         - self.h5_file: the filepath to the shot's HDF5 file
         - self.device_name: the name of this SoftwareDevice
 
-        If you want to save data to the HDF5 file at the end of a shot, the recommended
-        place to do it is within the group 'data/<device_name>', for example:
+        If you want to save raw data to the HDF5 file at the end of a shot, the
+        recommended place to do it is within the group 'data/<device_name>', for
+        example:
 
-        with h5py.File(self.h5_file) as f:
-            data_group = f['data'].create_group(self.device_name)
-            # save datasets/attributes within this group
+            with h5py.File(self.h5_file) as f:
+                data_group = f['data'].create_group(self.device_name)
+                # save datasets/attributes within this group
+
+        Or, if you are doing analysis and want to save results that will be accessible
+        to lyse analysis routines in the usual way, you can instantiate a lyse.Run
+        object and call Run.save_result() etc:
+
+            import lyse
+            run = lyse.Run(shot_context.h5_file)
+            run.save_result('x', 7)
+
+        The group that the results will be saved to, which is usually the filename of
+        the lyse analysis routine, will instead be the device name of the
+        SoftwareDevice.
 
         The use case for which this device was implemented was to update runmanager's
         globals immediately after a shot, based on measurement data, such that

SoftwareDevice/testing/test.py

@@ -10,6 +10,9 @@
 
 def foo(shot_context, t, arg):
     print(f"hello, {arg}!")
+    import lyse
+    run = lyse.Run(shot_context.h5_file)
+    run.save_result('x', 7)
 
 
 software_device.add_function('start', foo, 'world')

SoftwareDevice/utils.py

@@ -45,10 +45,15 @@ def serialise_function(function, *args, **kwargs):
     return function.__name__, source, args, kwargs
 
 
-def deserialise_function(name, source, args, kwargs):
+def deserialise_function(
+    name, source, args, kwargs, __name__=None, __file__='<string>'
+):
+    """Deserialise a function that was serialised by serialise_function. Optional
+    __name__ and __file__ arguments set those attributes in the namespace that the
+    function will be defined."""
     args = deserialise(args)
     kwargs = deserialise(kwargs)
     code = compile(source, '<string>', 'exec', dont_inherit=True,)
-    namespace = {'__name__': None, '__file__': '<string>'}
+    namespace = {'__name__': __name__, '__file__': __file__}
     exec(code, namespace)
     return namespace[name], args, kwargs