Explicit reference semantics.

Author: tbenthompson

testbook/client.py

@@ -39,17 +39,13 @@ def ref(self, name: str) -> Union[TestbookObjectReference, Any]:
 
         # Check if exists
         self.inject(name, pop=True)
-        try:
-            self.inject(f"import cloudpickle; cloudpickle.dumps({name})", pop=True)
-            return self.value(name)
-        except Exception:
-            return TestbookObjectReference(self, name)
+        return TestbookObjectReference(self, name)
 
     def get(self, item):
-        return self.ref(item)
+        return self.value(item)
 
     def __getitem__(self, item):
-        return self.ref(item)
+        return self.value(item)
 
     @staticmethod
     def _construct_call_code(
@@ -251,9 +247,6 @@ def value(self, code: str) -> Any:
         """
         Execute given code in the kernel and returns the serializeable result.
 
-        This error object will also contain an attribute called `save_varname` which
-        can be used to create a reference object with :meth:`ref`.
-
         Parameters
         ----------
         code: str
@@ -276,14 +269,17 @@ def value(self, code: str) -> Any:
             raise TestbookExecuteResultNotFoundError(
                 'code provided does not produce execute_result'
             )
+            
+        save_varname = random_varname()
 
         import tempfile
         with tempfile.NamedTemporaryFile() as tmp:
             try: 
                 inject_code = f"""
                     import cloudpickle
+                    {save_varname} = get_ipython().last_execution_result.result
                     with open('{tmp.name}', 'wb') as f:
-                        cloudpickle.dump(get_ipython().last_execution_result.result, f)
+                        cloudpickle.dump({save_varname}, f)
                 """
                 outputs = self.inject(inject_code, pop=True).outputs
                 if len(outputs) > 0 and outputs[0].output_type == "error":
@@ -294,7 +290,9 @@ def value(self, code: str) -> Any:
                 with open(tmp.name, 'rb') as f:
                     return cloudpickle.load(f) 
             except TestbookRuntimeError:
-                raise TestbookSerializeError('could not serialize output')
+                e = TestbookSerializeError('could not serialize output')
+                e.save_varname = save_varname
+                raise e
 
     @contextmanager
     def patch(self, target, **kwargs):

testbook/tests/test_reference.py

@@ -12,28 +12,28 @@ def notebook():
 
 def test_create_reference(notebook):
     a = notebook.ref("a")
-    assert repr(a) == "[1, 2, 3]"
+    assert repr(a) == "'[1, 2, 3]'"
 
 
-def test_create_reference_getitem(notebook):
-    a = notebook["a"]
-    assert repr(a) == "[1, 2, 3]"
+def test_create_reference_resolve(notebook):
+    a = notebook.ref("a")
+    assert a.resolve() == [1, 2, 3]
 
 
-def test_create_reference_get(notebook):
+def test_notebook_get_value(notebook):
     a = notebook.get("a")
-    assert repr(a) == "[1, 2, 3]"
+    assert a == [1, 2, 3]
 
 
 def test_eq_in_notebook(notebook):
     a = notebook.ref("a")
     a.append(4)
-    assert a == [1, 2, 3, 4]
+    assert a.resolve() == [1, 2, 3, 4]
 
 
 def test_eq_in_notebook_ref(notebook):
     a, b = notebook.ref("a"), notebook.ref("b")
-    assert a == b
+    assert a.resolve()[:3] == b
 
 
 def test_function_call(notebook):
@@ -43,8 +43,9 @@ def test_function_call(notebook):
 
 def test_function_call_with_ref_object(notebook):
     double, a = notebook.ref("double"), notebook.ref("a")
-
-    assert double(a) == [2, 4, 6]
+    # a.append(4) above applied to the referenced "a" and therefore is
+    # reflected here
+    assert double(a) == [2, 4, 6, 8]
 
 
 def test_nontrivial_pickling(notebook):