Oops, store the serialized Experiment in state not self.info.

[hooke.git] / hooke / curve.py

diff --git a/hooke/curve.py b/hooke/curve.py
index 34fb34e0135c53f58704fa04f4f889c4c833ae22..75fbf75ce2f394bb9d03dcf39e29ca69bf0419ef 100644 (file)
--- a/hooke/curve.py
+++ b/hooke/curve.py
@@ -20,10 +20,13 @@
 storing force curves.
 """
 
+import logging
 import os.path
+
 import numpy
 
 from .command_stack import CommandStack
+from . import experiment
 
 
 class NotRecognized (ValueError):
@@ -39,6 +42,7 @@ class NotRecognized (ValueError):
             super(NotRecognized, self).__init__(msg)
             self.curve = data
 
+
 class Data (numpy.ndarray):
     """Stores a single, continuous data set.
 
@@ -162,16 +166,65 @@ class Curve (object):
     """
     def __init__(self, path, info=None):
         #the data dictionary contains: {name of data: list of data sets [{[x], [y]}]
-        self.path = path
+        self.name = None
+        self.set_path(path)
         self.driver = None
         self.data = None
         if info == None:
             info = {}
         self.info = info
-        self.name = os.path.basename(path)
         self.command_stack = CommandStack()
         self._hooke = None  # Hooke instance for Curve.load()
 
+    def __str__(self):
+        return str(self.__unicode__())
+
+    def __unicode__(self):
+        return u'<%s %s>' % (self.__class__.__name__, self.name)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def set_path(self, path):
+        self.path = path
+        if self.name == None and path != None:
+            self.name = os.path.basename(path)
+
+    def __getstate__(self):
+        state = dict(self.__dict__)      # make a copy of the attribute dict.
+        state['info'] = dict(self.info)  # make a copy of the info dict too.
+        del(state['_hooke'])
+        dc = state['command_stack']
+        if hasattr(dc, '__getstate__'):
+            state['command_stack'] = dc.__getstate__()
+        if state['info'].get('experiment', None) != None:
+            e = state['info']['experiment']
+            assert isinstance(e, experiment.Experiment), type(e)
+            # HACK? require Experiment classes to be defined in the
+            # experiment module.
+            state['info']['experiment'] = e.__class__.__name__
+        return state
+
+    def __setstate__(self, state):
+        self.name = self._hooke = None
+        for key,value in state.items():
+            if key == 'path':
+                self.set_path(value)
+                continue
+            elif key == 'info':
+                if 'experiment' not in value:
+                    value['experiment'] = None
+                elif value['experiment'] != None:
+                    # HACK? require Experiment classes to be defined in the
+                    # experiment module.
+                    cls = getattr(experiment, value['experiment'])
+                    value['experiment'] = cls()
+            elif key == 'command_stack':
+                v = CommandStack()
+                v.__setstate__(value)
+                value = v
+            setattr(self, key, value)
+
     def set_hooke(self, hooke=None):
         if hooke != None:
             self._hooke = hooke
@@ -201,15 +254,22 @@ class Curve (object):
         :meth:`hooke.command_stack.CommandStack.execute`.
         """
         self.set_hooke(hooke)
+        log = logging.getLogger('hooke')
+        log.debug('loading curve %s with driver %s' % (self.name, self.driver))
         data,info = self.driver.read(self.path, self.info)
         self.data = data
         for key,value in info.items():
             self.info[key] = value
-        if self.hooke != None:
-            # TODO: set 'curve' argument explicitly for CurveCommands
-            self.command_stack.execute(self.hooke)
+        if self._hooke != None:
+            self.command_stack.execute(self._hooke)
+        elif len(self.command_stack) > 0:
+            log.warn(
+                'could not execute command stack for %s without Hooke instance'
+                % self.name)
 
     def unload(self):
         """Release memory intensive :attr:`.data`.
         """
+        log = logging.getLogger('hooke')
+        log.debug('unloading curve %s' % self.name)
         self.data = None