def render(self, data):
# initiate output structure
results = ResultBlocks(title='user')
labels = DataTree.getPaths(data)
# iterate over all items at leaf
for path, branch in DataTree.getNodes(data, len(labels) - 2):
for key in Utils.TrackerKeywords:
if key in branch:
# add a result block
results.append(ResultBlock(branch[key],
title=path2str(path)))
return results
def __call__(self, *args, **kwargs):
try:
self.parseArguments(*args, **kwargs)
except:
self.error("%s: exception in parsing" % self)
return ResultBlocks(ResultBlocks(Utils.buildException("parsing")))
# collect no data if tracker is the empty tracker
# and go straight to rendering
try:
if self.tracker.getTracks() == ["empty"]:
# is instance does not work because of module mapping
# type(Tracker.Empty) == CGATReport.Tracker.Empty
# type(self.tracker) == Tracker.Empty
# if isinstance(self.tracker, Tracker.Empty):
result = self.renderer()
return ResultBlocks(result)
except AttributeError:
# for function trackers
pass
self.debug("profile: started: tracker: %s" % (self.tracker))
# collecting data
try:
self.collect()
except:
self.error("%s: exception in collection" % self)
return ResultBlocks(ResultBlocks(
Utils.buildException("collection")))
finally:
self.debug("profile: finished: tracker: %s" % (self.tracker))
if self.tree is None or len(self.tree) == 0:
self.info("%s: no data - processing complete" % self.tracker)
return None
data_paths = DataTree.getPaths(self.tree)
self.debug("%s: after collection: %i data_paths: %s" %
(self, len(data_paths), str(data_paths)))
# special Renderers - do not process data further but render
# directly. Note that no transformations will be applied.
if isinstance(self.renderer, Renderer.User):
results = ResultBlocks(title="main")
results.append(self.renderer(self.tree))
return results
elif isinstance(self.renderer, Renderer.Debug):
results = ResultBlocks(title="main")
results.append(self.renderer(self.tree))
return results
# merge all data to hierarchical indexed dataframe
self.data = DataTree.asDataFrame(self.tree)
self.debug("dataframe memory usage: total=%i,data=%i,index=%i,col=%i" %
(self.data.values.nbytes +
self.data.index.nbytes +
self.data.columns.nbytes,
self.data.values.nbytes,
self.data.index.nbytes,
self.data.columns.nbytes))
# if tracks are set by tracker, call tracker with dataframe
if self.indexFromTracker:
self.tracker.setIndex(self.data)
# transform data
try:
self.transform()
except:
self.error("%s: exception in transformation" % self)
return ResultBlocks(ResultBlocks(
Utils.buildException("transformation")))
# data_paths = DataTree.getPaths(self.data)
# self.debug("%s: after transformation: %i data_paths: %s" %
# (self, len(data_paths), str(data_paths)))
# restrict
try:
self.filterPaths(self.restrict_paths, mode="restrict")
except:
self.error("%s: exception in restrict" % self)
return ResultBlocks(ResultBlocks(
Utils.buildException("restrict")))
# data_paths = DataTree.getPaths(self.data)
# self.debug("%s: after restrict: %i data_paths: %s" %
# (self, len(data_paths), str(data_paths)))
# exclude
try:
self.filterPaths(self.exclude_paths, mode="exclude")
except:
self.error("%s: exception in exclude" % self)
return ResultBlocks(ResultBlocks(Utils.buildException("exclude")))
# data_paths = DataTree.getPaths(self.data)
# self.debug("%s: after exclude: %i data_paths: %s" %
# (self, len(data_paths), str(data_paths)))
# No pruning - maybe enable later as a user option
self.pruned = []
# try:
# self.prune()
# except:
# self.error("%s: exception in pruning" % self)
# return ResultBlocks(ResultBlocks(Utils.buildException("pruning")))
# data_paths = DataTree.getPaths(self.data)
# self.debug("%s: after pruning: %i data_paths: %s" %
# (self, len(data_paths), str(data_paths)))
try:
self.group()
except:
self.error("%s: exception in grouping" % self)
return ResultBlocks(ResultBlocks(Utils.buildException("grouping")))
# data_paths = DataTree.getPaths(self.data)
# self.debug("%s: after grouping: %i data_paths: %s" %
# (self, len(data_paths), str(data_paths)))
if self.renderer is not None:
self.debug("profile: started: renderer: %s" % (self.renderer))
try:
result = self.render()
except:
self.error("%s: exception in rendering" % self)
return ResultBlocks(ResultBlocks(
Utils.buildException("rendering")))
finally:
self.debug("profile: finished: renderer: %s" % (self.renderer))
else:
result = ResultBlocks(title="")
return result