Is there someone here who knows a tool capable of analyzing the Python files of a project and gets the file dependencies graph? — This is to better understand the different imports and potential areas of improvement (moving some functions/classes/variables from one file/module to another).

Here's an example of what the tool can generate:

How the output might look like

I already found a tool called snakefood. The problem though is that it's not compatible with the recent versions of Python 3: It has some syntax errors and is using a library called compiler which is not supported in Python 3.

Godoc: https://godoc.org/github.com/autom8ter/dagger

Github: https://github.com/autom8ter/dagger

import "github.com/autom8ter/dagger"

Directed Graph

What is a directed Graph?

Design:

• flexibility
• global state
  • see primitive to manage graph state manually
• concurrency safe
• high performance
• simple api

Features

• [x] native graph objects(nodes/edges)
• [x] typed graph objects(ex: user/pet)
• [x] labelled nodes & edges
• [x] depth first search
• [x] breadth first search
• [x] concurrency safe
• [ ] import graph from JSON blob
• [ ] export graph to JSON blob

Example

   coleman = dagger.NewNode("user", fmt.Sprintf("cword_%v", time.Now().UnixNano()), map[string]interface{}{
   		"name": "coleman",
   	})
   	tyler = dagger.NewNode("user", fmt.Sprintf("twash_%v", time.Now().UnixNano()), map[string]interface{}{
   		"name": "tyler",
   	})
   	sarah = dagger.NewNode("user", fmt.Sprintf("swash_%v", time.Now().UnixNano()), map[string]interface{}{
   		"name": "sarah",
   	})
   	lacee = dagger.NewNode("user", fmt.Sprintf("ljans_%v", time.Now().UnixNano()), map[string]interface{}{
   		"name": "lacee",
   	})
   	// random id will be generated if one isn't provided
   	charlie = dagger.NewNode("dog", "", map[string]interface{}{
   		"name":   "charlie",
   		"weight": 25,
   	})
   
   	if err := coleman.Connect(tyler, "friend", true); err != nil {
   		exitErr(err)
   	}
   	if err := sarah.Connect(lacee, "friend", true); err != nil {
   		exitErr(err)
   	}
   	if err := coleman.Connect(lacee, "fiance", true); err != nil {
   		exitErr(err)
   	}
   	if err := tyler.Connect(sarah, "wife", true); err != nil {
   		exitErr(err)
   	}
   	if err := coleman.Connect(charlie, "pet", false); err != nil {
   		exitErr(err)
   	}
   	if err := lacee.Connect(charlie, "pet", false); err != nil {
   		exitErr(err)
   	}
   	if err := charlie.Connect(lacee, "owner", false); err != nil {
   		exitErr(err)
   	}
   	if err := charlie.Connect(colema

https://avarf.medium.com/code2graph-easily-visualize-a-projects-dependency-graph-fdebb22f6390

https://gitlab.com/avarf/code2graph

Hi.

I already wrote about this tool a month ago. Then he was still at the very beginning of his journey. And after a month, I want to show you a first stable version with a lot of new things.

New metrics

First of all, the list of metrics has expanded, now there are 9 of them. You can learn more about them in this part documentation.

1. Afferent couplings:
2. Efferent couplings:
3. Instability:
4. Abstractness;
5. Lack of Cohesion in Methods;
6. Lack of Cohesion in Methods 4 (or the number of connected components of the class);
7. Cyclomatic Complexity;
8. Count of magic numbers in functions and methods;
9. Count fully typed methods.

New graphs

Secondly, new dependency graphs, now with the ability to scale and move, and in a new style. You can learn more about them in this part documentation.

Now PhpStats allows you to build 8 types of graphs:

1. Class (or interface) dependencies;
2. Class (interface) extend and implementation dependencies;
3. Function or method dependencies;
4. Links within a class (or graph for the LCOM 4 metric);
5. Links between files (included in global and in functions);
6. Namespace dependencies graph;
7. Namespace structure graph;
8. Function reachability graph.

New relationship

Thirdly, there was an analysis of the relationship between symbols. So, for example, how are two classes related, whether they use methods, fields, or constants of each other. You can learn more about them in this part documentation.

Three types of links are currently supported:

1. For class-class relations:
   1. Whether one class extends another and vice versa;
   2. Whether the class implements the interface or vice versa;
   3. What methods, fields, and constants are used by one class used by another, and in which methods this happens.
2. For class-function relations:
   1. Function belong to class;
   2. The class is used inside the function;
   3. Used class members in functions;
   4. The function is used in the class (+ all methods where this function is used).
3. For function-function relations:
   1. Functions belong to the same class;
   2. Does the first function use the second and vice versa;

Hi, I have this huge project with multiple folders several layers deep. I need to start paring the thing down and getting rid of dependencies I don't need anymore. Can anyone point me to a good dependency graph generator I can use to arrange the source and header files in a fashion where I can understand how they interact and know where to cut?

I'm working on Linux. I prefer something ready to go as possible with has little monkeying around and compiling but I'll accept it if its the best way.

Hi,

I'm working on a behemoth of a state and I'm trying to understand why Terraform decides to destroy a resource that should not be in any way connected to the module that I'm trying to destroy. It was, at one time(the module I'm trying to remove had its certificate attached to the HTTPS listener of an ALB it now tries to destroy along with itself but I removed this attachment in the script and it no longer exists)

I tried terraform graph but it spat out over 6k lines of edges, so the resulting SVG graph is not really readable.

My question is - is there a viewer of sorts that can help me make sense of that state and why TF finds it necessary to destroy half my infrastructure when I'm trying to remove only a small part of it? Or some kind of a script that can convert the file generated with terraform graph into a reduced tree, i.e. when providing a resource name It would produce only its dependencies(both descendants and ancestors)?

In a moment of naïvete, while waiting for Black to have it's first non-prerelease release, I wanted to see if I could help. Turns out the package is a 6000-line single-file beast. This got me thinking, if there would be a way to neatly visualise a script's structure and inner dependencies. My initial thought was that maybe I could find some groups of definitions in Black or other files, that could be easy to refactor into sub-modules, bringing the complexity down. The graphs could also reveal some bad design if they are too interconnected.

Enter Pyfactor (work in progress), a fresh library of mine for exactly that purpose. Parsing Python syntax trees proved easier than I thought, and I'm here to share the first fruit. Starting from simple examples, two ridiculously overcomplicated hello world applications can be found in the GitHub readme with code. Then moving on to some actual projects. The first other single-file project I could find was sphinx-autodoc-typehints, which generated a graph like this:

sphinx-autodoc-typehints

We can clearly see a central function and a hierarchy of other structures. The graph can be made clearer by removing imports from the picture.

sphinx-autodoc-typehints without imports

We can observe tightly separated trees under "format annotation" and "get all type hints", and a central logger instance, referred to by many other functions. For a first-time reader this is very insightful, at least it was for me. Compared to reading 400+ loc thouroughly, from this picture alone one can get a rough understanding of what's happening. Of course it's also thanks to great naming in the library.

Now onto Black, which was a different beast. Visualising with imports was a no-go. There's too much even without them. See for yourself.

Processing img ipg2ms9yau361...

I'm not here to diss Black or its contributors. I think 6000 lines does it regardless. There is some obvious structure, like caching functionality on the far right, and hub vari

Edit: solved. CMake version was outdated

So I have a project and I'm able to draw a nice graph of the targets built in the project, and their internal dependencies using:

cmake --graphviz=graph.dot .. 
dot graph.dot -Tpng -o graph.png

So this is nice. However, I have some external dependencies that I pull in using find_package. These are managed by conan. Conan can also create a nice graph if the external dependencies.

The thing is, the graph created by cmake does not show external dependencies that targets are linked to.

Is there some way I can achieve this? Ideally I'd like to have a nice way to see which targets in the project are using which external dependencies managed by conan.

Hello!

So I have two nuget packages from the repo, one is called AngouriMath, and the other one is AngouriMath.FSharp. If you look at the dependency graph, you will notice that it is trying to look for projects depending on AngouriMath.FSharp. I want it to look for those dependent on AngouriMath. How do I change it?

I recently made Game Dependency Graphs for Monkey Island 1, 2, & 3. I got some positive feedback on r/MonkeyIsland, and will now do a non-Monkey game next. Which would you like to see?

Links to previous posts:

The Secret of Monkey Island

Monkey Island 2: LeChuck's Revenge

The Curse of Monkey Island

(The games listed in the poll are those that I already know and that I can currently run on my system.)

View Poll

https://avarf.medium.com/code2graph-easily-visualize-a-projects-dependency-graph-fdebb22f6390

https://gitlab.com/avarf/code2graph

https://avarf.medium.com/code2graph-easily-visualize-a-projects-dependency-graph-fdebb22f6390

https://gitlab.com/avarf/code2graph

https://github.com/sueLan/cocoapods-dependency-graph

graph for pods

JSON for pods