Get rid of unused imports.

Author: ericmjl

pyjviz/fstriplestore.py

@@ -1,4 +1,3 @@
-# import ipdb
 import os
 import os.path
 import textwrap

pyjviz/nb_utils.py

@@ -1,8 +1,6 @@
 import graphviz
 import IPython.display
-import rdflib
 
-from . import viz
 
 def show_method_chain(dot_code):
     gvz = graphviz.Source(dot_code)
@@ -12,15 +10,15 @@ def show_method_chain(dot_code):
     # and note that no temp files in current dirctory are visible
     if 1:
         print("gvz:", type(gvz))
-        #print(dir(gvz))
+        # print(dir(gvz))
         IPython.display.display_png(gvz)
     else:
-        gvz.render(format = 'png')
+        gvz.render(format="png")
         print("gvz:", type(gvz))
-        #print("filename:", gvz.filename)
-        #image = IPython.display.Image(filename = gvz.filename + '.png')
+        # print("filename:", gvz.filename)
+        # image = IPython.display.Image(filename = gvz.filename + '.png')
         image = gvz.view()
         print("image:", type(image), image[:20])
-        #scale = 0.3
-        #image = image.resize(( int(image.width * scale), int(image.height * scale)))
+        # scale = 0.3
+        # image = image.resize(( int(image.width * scale), int(image.height * scale)))
         IPython.display.display_png(image)

pyjviz/nested_call.py

@@ -1,27 +1,38 @@
-#import ipdb
-import sys, contextlib
+import sys
 from . import obj_tracking
 from . import obj_utils
 from . import wb_stack
 from . import fstriplestore
 from . import rdf_node
 
+
 class profile_objs:
     def __init__(self):
         self.collected_ids = set()
 
     def collect_obj_ids(self, frame, event, arg):
         trs = obj_tracking.tracking_store
 
-        #print(frame.f_code.co_name)
         gs = frame.f_globals
-        #global_ids = [trs.get_obj_uuid(id(gs.get(x))) for x in frame.f_code.co_names if x in gs]
-        global_ids = [(trs.get_uuid(id(gs.get(x))), trs.get_last_obj_state_uri(id(gs.get(x)))) for x in frame.f_code.co_names if x in gs]
+        global_ids = [
+            (
+                trs.get_uuid(id(gs.get(x))),
+                trs.get_last_obj_state_uri(id(gs.get(x))),
+            )
+            for x in frame.f_code.co_names
+            if x in gs
+        ]
         self.collected_ids.update(global_ids)
 
         ls = frame.f_locals
-        #local_ids = [trs.get_obj_uuid(id(ls.get(x))) for x in frame.f_code.co_varnames if x in ls]
-        local_ids = [(trs.get_uuid(id(ls.get(x))),trs.get_last_obj_state_uri(id(ls.get(x)))) for x in frame.f_code.co_varnames if x in ls]
+        local_ids = [
+            (
+                trs.get_uuid(id(ls.get(x))),
+                trs.get_last_obj_state_uri(id(ls.get(x))),
+            )
+            for x in frame.f_code.co_varnames
+            if x in ls
+        ]
         self.collected_ids.update(local_ids)
 
         sys.setprofile(self.collect_obj_ids)
@@ -39,7 +50,10 @@ def dump_nested_call_refs(self, nested_call_uri):
 
         for _, ref_obj_state_uri in self.collected_ids:
             if ref_obj_state_uri:
-                ts.dump_triple(nested_call_uri, "<nested-call-ref>", ref_obj_state_uri)
+                ts.dump_triple(
+                    nested_call_uri, "<nested-call-ref>", ref_obj_state_uri
+                )
+
 
 class NestedCall(rdf_node.RDFNode):
     """
@@ -50,38 +64,43 @@ class NestedCall(rdf_node.RDFNode):
     ```
 
     Corresponding NestedCall objects are:
-    
+
     ```python
     NestedCall(arg_name = 'date_as_obj', arg_func = lambda x: pd.to_datetime(x.date_string))
     NestedCall(arg_name = 'description', arg_func = lambda x: x.description.lower)
     ```
 
-    During method handling (`assign` in example above, see MethodCall.handle_start_method_call) the arguments which are isfunction(arg) == True will be converted to NestedCall object. 
+    During method handling (`assign` in example above, see MethodCall.handle_start_method_call) the arguments which are isfunction(arg) == True will be converted to NestedCall object.
     The code then proceed and causes controlled call of `nested_call_func` via __call__ implementation. Results are saved as self.ret and later used by MethodCall.handle_end_method_call
     """
+
     def __init__(self, arg_name, arg_func):
-        super().__init__(rdf_type = "NestedCall", label = f"nested_call({arg_name})")
+        super().__init__(
+            rdf_type="NestedCall", label=f"nested_call({arg_name})"
+        )
         rdfl = fstriplestore.triple_store
         parent_uri = wb_stack.wb_stack.stack_entries__[-1].uri
         rdfl.dump_triple(self.uri, "<part-of>", parent_uri)
-        
-        #ipdb.set_trace()
+
+        # ipdb.set_trace()
         self.arg_name = arg_name
         self.arg_func = arg_func
         self.ret = None
-        
+
     def __call__(self, *args, **kwargs):
         ts = fstriplestore.triple_store
         print("NestedCall called")
 
         ctx = profile_objs()
-        #ctx = contextlib.nullcontext()
+        # ctx = contextlib.nullcontext()
         with ctx:
             self.ret = self.arg_func(*args, **kwargs)
 
         ctx.dump_nested_call_refs(self.uri)
 
-        ret_t_obj, obj_found = obj_tracking.tracking_store.get_tracking_obj(self.ret)
+        ret_t_obj, obj_found = obj_tracking.tracking_store.get_tracking_obj(
+            self.ret
+        )
         if not obj_found:
             ret_t_obj = obj_utils.dump_obj_state(self.ret)
         return self.ret

pyjviz/obj_tracking.py

@@ -2,35 +2,44 @@
 import uuid
 from . import fstriplestore
 
+
 def obj_del_cb(ref):
     print("obj deleted", ref)
-    
+
+
 class TrackingObj:
     def __init__(self, obj):
         self.obj_wref = weakref.ref(obj, obj_del_cb)
         self.uuid = uuid.uuid4()
         self.pyid = id(obj)
         self.last_version_num = 0
         self.last_obj_state_uri = None
-        
+
         self.uri = f"<Obj#{self.uuid}>"
 
         fstriplestore.triple_store.dump_triple(self.uri, "rdf:type", "<Obj>")
-        fstriplestore.triple_store.dump_triple(self.uri, "<obj-type>", f'"{type(obj).__name__}"')
-        fstriplestore.triple_store.dump_triple(self.uri, "<obj-uuid>", f'"{self.uuid}"')
-        fstriplestore.triple_store.dump_triple(self.uri, "<obj-pyid>", f'{self.pyid}')
-        
+        fstriplestore.triple_store.dump_triple(
+            self.uri, "<obj-type>", f'"{type(obj).__name__}"'
+        )
+        fstriplestore.triple_store.dump_triple(
+            self.uri, "<obj-uuid>", f'"{self.uuid}"'
+        )
+        fstriplestore.triple_store.dump_triple(
+            self.uri, "<obj-pyid>", f"{self.pyid}"
+        )
+
     def is_alive(self):
         return not self.obj_wref() is None
 
     def incr_version(self):
         ret = self.last_version_num
         self.last_version_num += 1
         return ret
-    
+
+
 class TrackingStore:
     def __init__(self):
-        self.tracking_objs = {} # id(obj) -> TrackingObj
+        self.tracking_objs = {}  # id(obj) -> TrackingObj
 
     def get_uuid(self, obj_pyid):
         t_obj = self.tracking_objs.get(obj_pyid)
@@ -39,12 +48,12 @@ def get_uuid(self, obj_pyid):
     def get_last_obj_state_uri(self, obj_pyid):
         t_obj = self.tracking_objs.get(obj_pyid)
         return t_obj.last_obj_state_uri if t_obj and t_obj.is_alive() else None
-    
+
     def find_tracking_obj(self, obj):
-        t_obj, obj_found = self.get_tracking_obj(obj, add_missing = False)
+        t_obj, obj_found = self.get_tracking_obj(obj, add_missing=False)
         return t_obj
-        
-    def get_tracking_obj(self, obj, add_missing = True):
+
+    def get_tracking_obj(self, obj, add_missing=True):
         obj_found = False
         obj_pyid = id(obj)
         tracking_obj = None
@@ -59,4 +68,5 @@ def get_tracking_obj(self, obj, add_missing = True):
 
         return tracking_obj, obj_found
 
+
 tracking_store = TrackingStore()

pyjviz/obj_utils.py

@@ -1,86 +1,106 @@
-#import ipdb
 import textwrap
 import pandas as pd
-import io, base64
+import io
+import base64
 
 from . import fstriplestore
 from . import obj_tracking
 from . import wb_stack
 
 random_id = 0
+
+
 def dump_obj_state(obj):
     caller_stack_entry = wb_stack.wb_stack.get_parent_of_current_entry()
-    stack_entry = wb_stack.wb_stack.get_top()    
+    stack_entry = wb_stack.wb_stack.get_top()
     t_obj, obj_found = obj_tracking.tracking_store.get_tracking_obj(obj)
 
     global random_id
-    obj_state_uri = f"<ObjState#{random_id}>"; random_id += 1
-    fstriplestore.triple_store.dump_triple(obj_state_uri, "rdf:type", "<ObjState>")
+    obj_state_uri = f"<ObjState#{random_id}>"
+    random_id += 1
+    fstriplestore.triple_store.dump_triple(
+        obj_state_uri, "rdf:type", "<ObjState>"
+    )
     fstriplestore.triple_store.dump_triple(obj_state_uri, "<obj>", t_obj.uri)
-    fstriplestore.triple_store.dump_triple(obj_state_uri, "<part-of>", caller_stack_entry.uri)    
-    fstriplestore.triple_store.dump_triple(obj_state_uri, "<version>", f'"{t_obj.last_version_num}"')
+    fstriplestore.triple_store.dump_triple(
+        obj_state_uri, "<part-of>", caller_stack_entry.uri
+    )
+    fstriplestore.triple_store.dump_triple(
+        obj_state_uri, "<version>", f'"{t_obj.last_version_num}"'
+    )
     t_obj.last_obj_state_uri = obj_state_uri
     t_obj.last_version_num += 1
 
-    dump_obj_state_cc(obj_state_uri, obj, output_type = 'head')
+    dump_obj_state_cc(obj_state_uri, obj, output_type="head")
 
     return t_obj
-    
-def dump_obj_state_cc(obj_state_uri, obj, output_type = 'head'):        
+
+
+def dump_obj_state_cc(obj_state_uri, obj, output_type="head"):
     if isinstance(obj, pd.DataFrame):
         dump_DataFrame_obj_state_cc(obj_state_uri, obj, output_type)
     elif isinstance(obj, pd.Series):
         dump_Series_obj_state_cc(obj_state_uri, obj, output_type)
     else:
         raise Exception(f"unknown obj type at {obj_state_uri}")
 
+
 def dump_DataFrame_obj_state_cc(obj_state_uri, df, output_type):
     ts = fstriplestore.triple_store
     global random_id
-    obj_state_cc_uri = f"<ObjStateCC#{random_id}>"; random_id += 1
+    obj_state_cc_uri = f"<ObjStateCC#{random_id}>"
+    random_id += 1
 
     ts.dump_triple(obj_state_cc_uri, "rdf:type", "<ObjStateCC>")
     ts.dump_triple(obj_state_cc_uri, "<obj-state>", obj_state_uri)
 
-    if output_type == 'head':
+    if output_type == "head":
         ts.dump_triple(obj_state_cc_uri, "rdf:type", "<CCGlance>")
         ts.dump_triple(obj_state_cc_uri, "<shape>", f'"{df.shape}"')
-        df_head_html = df.head(10).applymap(lambda x: textwrap.shorten(str(x), 50)).to_html().replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;").replace("\n", "&#10;")
+        df_head_html = (
+            df.head(10)
+            .applymap(lambda x: textwrap.shorten(str(x), 50))
+            .to_html()
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+            .replace('"', "&quot;")
+            .replace("\n", "&#10;")
+        )
         ts.dump_triple(obj_state_cc_uri, "<df-head>", '"' + df_head_html + '"')
-    elif output_type == 'plot':
+    elif output_type == "plot":
         ts.dump_triple(obj_state_cc_uri, "rdf:type", "<CCBasicPlot>")
         ts.dump_triple(obj_state_cc_uri, "<shape>", f'"{df.shape}"')
         out_fd = io.BytesIO()
         fig = df.plot().get_figure()
         fig.savefig(out_fd)
-        #ipdb.set_trace()
-        im_s = base64.b64encode(out_fd.getvalue()).decode('ascii')
-        ts.dump_triple(obj_state_cc_uri, '<plot-im>', '"' + im_s + '"')
+        # ipdb.set_trace()
+        im_s = base64.b64encode(out_fd.getvalue()).decode("ascii")
+        ts.dump_triple(obj_state_cc_uri, "<plot-im>", '"' + im_s + '"')
     else:
         raise Exception(f"unknown output_type: {output_type}")
 
 
 def dump_Series_obj_state_cc(obj_state_uri, s, output_type):
     ts = fstriplestore.triple_store
     global random_id
-    obj_state_cc_uri = f"<ObjStateCC#{random_id}>"; random_id += 1
+    obj_state_cc_uri = f"<ObjStateCC#{random_id}>"
+    random_id += 1
 
     ts.dump_triple(obj_state_cc_uri, "rdf:type", "<ObjStateCC>")
     ts.dump_triple(obj_state_cc_uri, "<obj-state>", obj_state_uri)
 
-    if output_type == 'head':
+    if output_type == "head":
         ts.dump_triple(obj_state_cc_uri, "rdf:type", "<CCGlance>")
         ts.dump_triple(obj_state_cc_uri, "<shape>", f"{len(s)}")
         ts.dump_triple(obj_state_cc_uri, "<df-head>", '"NONE"')
-    elif output_type == 'plot':
-        ts.dump_triple(obj_state_cc_uri, "rdf:type", "<CCBasicPlot>")        
+    elif output_type == "plot":
+        ts.dump_triple(obj_state_cc_uri, "rdf:type", "<CCBasicPlot>")
         ts.dump_triple(obj_state_cc_uri, "<shape>", f"{len(s)}")
         out_fd = io.BytesIO()
         fig = s.plot().get_figure()
         fig.savefig(out_fd)
-        #ipdb.set_trace()
-        im_s = base64.b64encode(out_fd.getvalue()).decode('ascii')
-        ts.dump_triple(obj_state_cc_uri, '<plot-im>', '"' + im_s + '"')
+        # ipdb.set_trace()
+        im_s = base64.b64encode(out_fd.getvalue()).decode("ascii")
+        ts.dump_triple(obj_state_cc_uri, "<plot-im>", '"' + im_s + '"')
     else:
         raise Exception(f"unknown output_type: {output_type}")
-