DependencyViewer Class Reference

Inheritance diagram for DependencyViewer:

Collaboration diagram for DependencyViewer:

Public Member Functions
def	__init__ (self, store_arrays_with_dependencies_JSON)
def	create (self)
def	show (self)

Public Attributes
	store_arrays_with_dependencies_JSON
	A JSON from the processing of dependencies.
	random_name
	Part of the name representing the object for javascript.
	element_name
	The name representing the object for javascript.
	d3_include_string
	Tenplate for the include string.
	d3_element_string
	Template for the element itself.
	style_template
	Template for the style.
	nodes_template
	Template for inserting the node JSON.
	viewer_template
	Template for the full HTML.

Detailed Description

Show the dependencies in a nice and fancy way :-)

Definition at line 171 of file viewer.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			store_arrays_with_dependencies_JSON
	)

Create a new dependency viewer.

Definition at line 174 of file viewer.py.

    def __init__(self, store_arrays_with_dependencies_JSON):
        """Create a new dependency viewer."""
        
        self.store_arrays_with_dependencies_JSON = store_arrays_with_dependencies_JSON
 
        
        self.random_name = ''.join(random.choice(string.ascii_letters) for _ in range(10))
        
        self.element_name = "dependencies_" + self.random_name
 
        
        self.d3_include_string = """<script src="https://d3js.org/d3.v3.min.js" charset="utf-8"></script>"""
 
        
        self.d3_element_string = """<div id="{element_name}"></div>""".format(element_name=self.element_name)
 
        
        self.style_template = """<style>
        /* d3 related settings */
        .node {
          font: 300 14px "Helvetica Neue", Helvetica, Arial, sans-serif;
          fill: #bbb;
          cursor: pointer;
        }
 
        .node:hover {
          fill: #000;
        }
 
        .link {
          stroke: rgba(20, 166, 255, 0.3);
          stroke-width: 2px;
          fill: none;
          pointer-events: none;
        }
 
        .node:hover,
        .node--source,
        .node--target {
          font-weight: 700;
        }
 
        .node--source {
          fill: #2ca02c;
        }
 
        .node--target {
          fill: #d62728;
        }
 
        .link--source,
        .link--target {
          stroke-opacity: 1;
          stroke-width: 4px;
        }
 
        .link--source {
          stroke: #d62728;
        }
 
        .link--target {
          stroke: #2ca02c;
        }
        </style>"""
 
        
        self.nodes_template = """<script>var test_nodes = JSON.parse('{nodes_json}');</script>""".format(
            nodes_json=self.store_arrays_with_dependencies_JSON)
 
        
        self.viewer_template = self.d3_include_string + self.nodes_template + self.d3_element_string + self.style_template + """
            <script>
            var diameter = 960;
            var radius = diameter / 2;
            var innerRadius = radius - 120;
 
            var cluster = d3.layout.cluster()
                .size([360, innerRadius])
                .sort(null)
                .value(function(d) { return d.size; });
 
            var bundle = d3.layout.bundle();
 
            var line = d3.svg.line.radial()
                .interpolate("bundle")
                .tension(.85)
                .radius(function(d) { return d.y; })
                .angle(function(d) { return d.x / 180 * Math.PI; });
 
            var svg = d3.select("#""" + self.element_name + """").append("svg")
                .attr("width", diameter)
                .attr("height", diameter)
                .append("g")
                    .attr("transform", "translate(" + radius + "," + radius + ")");
 
            var link = svg.append("g").selectAll(".link");
            var node = svg.append("g").selectAll(".node");
 
            var nodes = cluster.nodes(test_nodes);
            var links = relations(nodes);
 
            link = link
                .data(bundle(links))
                .enter()
                    .append("path")
                    .each(function(d) { d.source = d[0], d.target = d[d.length - 1]; })
                    .attr("class", "link")
                    .attr("d", line);
 
            node = node
                .data(nodes.filter(function(n) { return !n.children; }))
                .enter()
                    .append("text")
                    .attr("class", "node")
                    .attr("dy", ".31em")
                    .attr("transform", function(d) {
                            return "rotate(" + (d.x - 90) +
                                   ")translate(" + (d.y + 8) + ",0)"
                                   + (d.x < 180 ? "" : "rotate(180)");})
                    .style("text-anchor", function(d) { return d.x < 180 ? "start" : "end"; })
                    .text(function(d) { return d.key; })
                    .on("mouseover", mouseovered)
                    .on("mouseout", mouseouted);
 
            function mouseovered(d) {
                node.each(function(n) { n.target = n.source = false; });
 
                link.classed("link--target", function(l) { if (l.target === d) return l.source.source = true; })
                    .classed("link--source", function(l) { if (l.source === d) return l.target.target = true; })
                    .filter(function(l) { return l.target === d || l.source === d; })
                    .each(function() { this.parentNode.appendChild(this); });
 
                node.classed("node--target", function(n) { return n.target; })
                    .classed("node--source", function(n) { return n.source; });
            }
 
            function mouseouted(d) {
                link.classed("link--target", false)
                    .classed("link--source", false);
 
                node.classed("node--target", false)
                    .classed("node--source", false);
            }
 
            d3.select(self.frameElement).style("height", diameter + "px");
 
            // Return a list of imports for the given array of nodes.
            function relations(nodes) {
                var map = {},
                relation = [];
 
                // Compute a map from name to node.
                nodes.forEach(function(d) {
                    map[d.name] = d;
                });
 
                // For each import, construct a link from the source to target node.
                nodes.forEach(function(d) {
                    if (d.relation) d.relation.forEach(function(i) {
                        relation.push({source: map[d.name], target: map[i]});
                    });
                });
 
                return relation;
            }
            </script>
            """
 

Member Function Documentation

create()

def create

(

self

)

Create the widget.

Reimplemented from IPythonWidget.

Definition at line 342 of file viewer.py.

show()

def show (   self )

inherited

Show the widget

Reimplemented in ProgressBarViewer.

Definition at line 24 of file viewer.py.

    def show(self):
        """
        Show the widget
        """
        from IPython.core.display import display
 
        a = self.create()
        display(a)
 
 

---

The documentation for this class was generated from the following file:

• framework/scripts/hep_ipython_tools/ipython_handler_basf2/viewer.py