Add to provenance log

starfish/__init__.py

@@ -22,6 +22,9 @@
 # NOTE: if we move to python 3.7, we can produce this value at call time via __getattr__
 __version__ = pkg_resources.require("starfish")[0].version
 
+# Variable to be set by release process
+__release_tag__ = None
+
 
 if __name__ == "__main__":
     starfish()

starfish/imagestack/imagestack.py

@@ -60,7 +60,7 @@
     PhysicalCoordinateTypes,
     STARFISH_EXTRAS_KEY
 )
-from starfish.util.JSONenocder import LogEncoder
+from starfish.util import logging
 from ._mp_dataarray import MPDataArray
 from .dataorder import AXES_DATA, N_AXES
 
@@ -952,7 +952,13 @@ def update_log(self, class_instance) -> None:
         ----------
         class_instance: The instance of a class being applied to the imagestack
         """
-        entry = {"method": class_instance.__class__.__name__, "arguments": class_instance.__dict__}
+        entry = {"method": class_instance.__class__.__name__,
+                 "arguments": class_instance.__dict__,
+                 "os": logging.get_os_info(),
+                 "dependencies": logging.get_core_dependency_info(),
+                 "release tag": logging.get_release_tag(),
+                 "starfish version": logging.get_dependency_version('starfish')
+                 }
         self._log.append(entry)
 
     @property
@@ -1087,7 +1093,7 @@ def export(self,
 
         """
         # Add log data to extras
-        self._tile_data.extras[STARFISH_EXTRAS_KEY] = LogEncoder().encode({LOG: self.log})
+        self._tile_data.extras[STARFISH_EXTRAS_KEY] = logging.LogEncoder().encode({LOG: self.log})
         tileset = TileSet(
             dimensions={
                 Axes.ROUND,

starfish/pipeline/algorithmbase.py

@@ -2,7 +2,7 @@
 from starfish.intensity_table.intensity_table import IntensityTable
 from starfish.types import LOG
 from starfish.types._constants import STARFISH_EXTRAS_KEY
-from starfish.util.JSONenocder import LogEncoder
+from starfish.util.logging import LogEncoder
 
 
 class AlgorithmBaseType(type):

starfish/types/__init__.py

@@ -3,6 +3,7 @@
 from ._constants import (
     Axes,
     Coordinates,
+    CORE_DEPENDENCIES,
     Features,
     LOG,
     PHYSICAL_COORDINATE_DIMENSION,

starfish/types/_constants.py

@@ -34,6 +34,10 @@ class Coordinates(AugmentedEnum):
 """
 This is name of the provenance log attribute stored on the IntensityTable
 """
+CORE_DEPENDENCIES = {'numpy', 'scikit-image', 'pandas', 'scikit-learn', 'scipy', 'xarray', 'sympy'}
+"""
+The set of dependencies whose versions are are logged for each starfish session
+"""
 
 
 class PhysicalCoordinateTypes(AugmentedEnum):

starfish/util/logging.py

@@ -0,0 +1,49 @@
+import platform
+from functools import lru_cache
+from json import JSONEncoder
+from typing import Mapping
+
+import pkg_resources
+
+import starfish
+from starfish.types import CORE_DEPENDENCIES
+
+
+@lru_cache(maxsize=1)
+def get_core_dependency_info() -> Mapping[str, str]:
+    dependency_info = dict()
+    for dependency in CORE_DEPENDENCIES:
+        version = get_dependency_version(dependency)
+        dependency_info[dependency] = version
+    return dependency_info
+
+
+def get_dependency_version(dependency: str) -> str:
+    return pkg_resources.get_distribution(dependency).version
+
+
+@lru_cache(maxsize=1)
+def get_release_tag() -> str:
+    if not starfish.__release_tag__:
+        return "Running starfish from source"
+    return starfish.__release_tag__
+
+
+@lru_cache(maxsize=1)
+def get_os_info() -> Mapping[str, str]:
+    return {"Platform": platform.system(),
+            "Version:": platform.version(),
+            "Python Version": platform.python_version()}
+
+
+class LogEncoder(JSONEncoder):
+    """
+    JSON encodes the List[Dict] pipeline provence log. For simple
+    objects use default JSON encoding. For more complex objects
+    (ex. Imagestack, Codebook) encode the repr of the object.
+    """
+    def default(self, o):
+        try:
+            return super(LogEncoder, self).default(o)
+        except TypeError:
+            return JSONEncoder().encode(repr(o))