def main(size=None, depth=3):
    graphcommons = GraphCommons('sk_IDfGvifqeRuvQ7HnCcAEsg')
    if size is None:
        G = read_generated_grid_edgelist()
    else:
        G = generate_grid_edgelist(size, depth)
    signals = [
        Signal(action="node_create", name=node, type=data['type'])
        for (node, data) in G.nodes(data=True)
    ]
    signals.extend([
        Signal(action="edge_create",
               from_name=source,
               from_type=G.node[source]['type'],
               to_name=target,
               to_type=G.node[target]['type'],
               name=data['type'],
               weight=1) for source, target, data in G.edges(data=True)
    ])
    created_graph = new_graph(graphcommons,
                              signals=signals,
                              name="NPM Dependency Graph",
                              description="NPM Dependency Graph")
    print('Created Graph URL:')
    print('https://graphcommons.com/graphs/%s' % created_graph.id)
def main():

    data = 'dependencies_data.json'

    with open(data, 'r') as data_file:
        json_data = json.load(data_file)

        for package, dependencies in json_data.items():
            print(package, dependencies)

        # build dependency graph
        graph = DiGraph()
        build_graph_from_dict(graph, json_data)

        # create graph on graph commons
        graphcommons_client = GraphCommons(access_token)
        graph_id = create_graph_visualization(graphcommons_client, graph,
                                              "300 Starts")
        print('graph id:', graph_id)
def main(access_token, package_name, max_depth):
    graph = DiGraph()
    graphcommons = GraphCommons(access_token)
    import_package_dependencies(graph, package_name, max_depth=max_depth)

    signals = []

    for (node, data) in graph.nodes(data=True):

        if data['type'] == 'PACKAGE':
            reference = "https://www.npmjs.com/package/%s" % node
        else:
            reference = 'https://www.npmjs.com/~%s' % node

        signals.append(
            Signal(action="node_create",
                   name=node,
                   type=data['type'],
                   reference=reference))

    for source, target, data in graph.edges(data=True):

        signals.append(
            Signal(action="edge_create",
                   from_name=source,
                   from_type=graph.node[source]['type'],
                   to_name=target,
                   to_type=graph.node[target]['type'],
                   name=data['type'],
                   weight=1))

    created_graph = graphcommons.new_graph(
        name="Dependency Network of %s" % package_name,
        description="Dependency Network of %s Package" % package_name,
        signals=signals)

    print 'Created Graph URL:'
    print 'https://graphcommons.com/graphs/%s' % created_graph.id
def test():
    package_name = "/package/web3"
    dependency_tree_depth = 5

    # import package dependencies
    dependencies_dict = {}
    import_package_dependencies(package_name, dependencies_dict,
                                dependency_tree_depth, 0)

    # print out dependency dictionary
    for k, v in dependencies_dict.items():
        print(k, v)

    # build graph from dependency dict
    graph = DiGraph()
    build_graph_from_dict(graph, dependencies_dict)

    # create graph on graph commons
    graphcommons_client = GraphCommons(access_token)
    package_name = package_name.replace('/package/', '')
    graph_id = create_graph_visualization(graphcommons_client, graph,
                                          package_name)
    print('graph id:', graph_id)