working, simple and inflexible serving so far

Author: Brett Graham

.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+build/*
+dist/*
+*.swp

collustro/__init__.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+import converters
+import server
+import templates
+
+__all__ = ['converters', 'server', 'templates']
+
+
+structure_map = {
+        'tree': converters.heirarchy.convert,
+        'treemap': converters.heirarchy.convert,
+        'pack': converters.heirarchy.convert,
+        'partition': converters.heirarchy.convert,
+        'cluster': converters.heirarchy.convert,
+        'heirarchy': converters.heirarchy.convert,
+        }
+
+
+def raise_structure_map_error(layout):
+    raise Exception("Unknown layout: %s" % layout)
+
+
+def explore(obj, layout, *args, **kwargs):
+    """
+    layout lookup
+    """
+    # load template (from layout)
+    template_filename = templates.find_template(layout)
+
+    # convert object to correct structure (from layout)
+    data = structure_map.get(layout, raise_structure_map_error)(obj)
+
+    # serve it all up
+    app = server.render_data(template_filename, data)
+
+    app.run(*args, **kwargs)

collustro/converters/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+import heirarchy
+
+__all__ = ['heirarchy']

collustro/converters/heirarchy.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+
+# for d3 layouts:
+#  1) Tree
+#  2) Treemap
+#  3) Pack
+#  4) Partition
+#  5) Cluster
+#  6) Heirarchy
+
+import json
+
+import utils
+
+
+def raise_convert_error(obj):
+    raise utils.ConvertException(obj, 'heirarchy')
+
+
+def convert(obj):
+    """
+    Try to convert an object to a json heirarchy object like (from d3):
+    {
+      "name": "flare",
+      "children": [
+        {
+          "name": "analytics",
+          "children": [
+            {"name": "AgglomerativeCluster", "size": 3938},
+            {"name": "CommunityStructure", "size": 3812},
+            {"name": "MergeEdge", "size": 743}
+          ]
+        },
+        {
+          "name": "graph",
+          "children": [
+            {"name": "BetweennessCentrality", "size": 3534},
+            {"name": "LinkDistance", "size": 5731}
+          ]
+        }
+      ]
+    }
+    """
+    return {
+        dict: from_dict,
+        list: from_list,
+    }.get(type(obj), raise_convert_error)(obj)
+
+
+def from_dict(d):
+    """
+    format:
+    {'main name': {children....}}
+
+    where children are of type:
+    {'name': <value or children>}
+    """
+    children = from_dict_to_children(d)
+    if len(children) == 1:
+        return json.dumps(children[0])
+    else:
+        # TODO make this a more informative error
+        raise Exception("Invalid conversion")
+
+
+def from_dict_to_children(d):
+    children = []
+    for k, v in d.iteritems():
+        if type(v) == dict:
+            children.append({'name': k, \
+                    'children': from_dict_to_children(v)})
+        else:
+            children.append({'name': k, 'size': v})
+    return children
+
+
+def from_list(l):
+    """
+    format:
+    [ [1, [2,3,4], 5] ]
+
+    should be a list of lists with the dimension 0 len 1
+    so that the main_name can be set correctly
+    """
+    if len(l) != 1:
+        return from_dict(list_to_dict([l]))
+    else:
+        return from_dict(list_to_dict(l))
+
+
+def list_to_dict(l, level=''):
+    """
+    Use a numbered heirarchy
+    1, 1.1, 1.2, 1.2.1
+    """
+    d = {}
+    for (i, v) in enumerate(l):
+        nl = '%s%i' % (level, i)
+        if type(v) == list:
+            d[nl] = list_to_dict(v, nl + '.')
+        else:
+            d[nl] = v
+    return d

collustro/converters/utils.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+
+class ConvertException(Exception):
+    def __init__(self, obj, target):
+        message = 'Cannot convert %s to %s' % \
+                (str(obj), str(target))
+        Exception.__init__(self, message)

collustro/templates/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+import os
+
+
+def find_template(layout):
+    template_dir = os.path.join(os.path.dirname(__file__), 'defaults')
+    template_filename = os.path.join(template_dir, layout + '.html')
+    if not os.path.exists(template_filename):
+        raise OSError("Template %s not found in %s" % \
+                (layout, template_dir))
+    return template_filename

collustro/templates/defaults/tree.html

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta http-equiv="content-type" content="text/html;charset=utf-8">
+        <title>Tree Layout</title>
+        <script src="//ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"></script>
+        <script type="text/javascript" src="http://mbostock.github.com/d3/d3.v2.js?2.8.1"></script>
+        <style type="text/css">
+            .node circle {
+              fill: #fff;
+              stroke: steelblue;
+              stroke-width: 1.5px;
+            }
+
+            .node {
+              font: 10px sans-serif;
+            }
+
+            .link {
+              fill: none;
+              stroke: #ccc;
+              stroke-width: 1.5px;
+            }
+        </style>
+        <script type="text/javascript">
+        </script>
+    </head>
+    <body>
+        <script type="text/javascript">
+            var data = null;
+            $.ajaxSetup ({ cache: false });
+            $(document).ready(function () {
+                $.getJSON('data', {}, function (received) {
+                    data = received;
+                    render('#graph', data);
+                });
+            });
+            function render(graphid, data) {
+                var r = 960 / 2;
+                var tree = d3.layout.tree()
+                    .size([360, r - 120])
+                    .separation(function(a, b) { return (a.parent == b.parent ? 1 : 2) / a.depth; });
+
+                var diagonal = d3.svg.diagonal.radial()
+                    .projection(function(d) { return[d.y, d.x / 180 * Math.PI]; });
+
+                var vis = d3.select(graphid).append("svg")
+                    .attr("width", r * 2)
+                    .attr("height", r * 2 - 150)
+                  .append("g")
+                    .attr("transform", "translate(" + r + "," + r + ")");
+
+                var nodes = tree.nodes(data);
+
+                var link = vis.selectAll("path.link")
+                    .data(tree.links(nodes))
+                  .enter().append("path")
+                    .attr("class", "link")
+                    .attr("d", diagonal);
+
+                var node = vis.selectAll("g.node")
+                    .data(nodes)
+                  .enter().append("g")
+                    .attr("class", "node")
+                    .attr("transform", function(d) { return "rotate(" + (d.x - 90) + ")translate(" + d.y + ")"; });
+
+                node.append("circle")
+                    .attr("r", 4.5);
+
+                node.append("text")
+                    .attr("dx", function(d) { return d.x < 180 ? 8 : -8; })
+                    .attr("dy", ".31em")
+                    .attr("text-anchor", function(d) { return d.x < 180 ? "start" : "end"; })
+                    .attr("transform", function(d) { return d.x < 180 ? null : "rotate(180"; })
+                    .text(function(d) { return d.name; });
+            };
+        </script>
+        <div class='tree' id='graph'>
+        </div>
+    </body>
+</html>

notes

@@ -0,0 +1,27 @@
+Show me data!
+
+in python:
+  data, stuff, things
+
+take those things, and show them to me in pretty ways
+
+pipeline
+
+mongo <-> python(stuff) <-> flask (to web) <-> javascript <-> d3 <-> d3 layouts
+
+Not all of thes parts are necessary (like mongo)
+
+First usecase
+
+#!/usr/bin/env python
+data_dict = {'a': {'b': 10, 'c': 10}, 'd': {'e' : 70, 'f': 5}, 'g': 5}
+explore(data_dict, tree)
+
+this will take the data_dictionary, push it to javascript,
+convert it to json that fits a heirarchy layout
+show it as a tree layout
+
+To do this:
+1) convert data dictionary to json object (of a certain structure)
+2) serve up a template that requests for the data (ajax)
+3) display template and data