├── .gitignore
├── LICENSE
├── README.md
├── function_call_main.py
├── main.py
├── playground
└── playground.ipynb
├── requirements.txt
├── testing-directories
├── analyzer.py
├── data_processor.py
├── main.py
└── utils.py
└── testing-files
└── basic_python.py
/.gitignore:
--------------------------------------------------------------------------------
1 | # Created by https://www.toptal.com/developers/gitignore/api/windows,python,macos,linux
2 | # Edit at https://www.toptal.com/developers/gitignore?templates=windows,python,macos,linux
3 |
4 | ### Linux ###
5 | *~
6 |
7 | # temporary files which can be created if a process still has a handle open of a deleted file
8 | .fuse_hidden*
9 |
10 | # KDE directory preferences
11 | .directory
12 |
13 | # Linux trash folder which might appear on any partition or disk
14 | .Trash-*
15 |
16 | # .nfs files are created when an open file is removed but is still being accessed
17 | .nfs*
18 |
19 | ### macOS ###
20 | # General
21 | .DS_Store
22 | .AppleDouble
23 | .LSOverride
24 |
25 | # Icon must end with two \r
26 | Icon
27 |
28 |
29 | # Thumbnails
30 | ._*
31 |
32 | # Files that might appear in the root of a volume
33 | .DocumentRevisions-V100
34 | .fseventsd
35 | .Spotlight-V100
36 | .TemporaryItems
37 | .Trashes
38 | .VolumeIcon.icns
39 | .com.apple.timemachine.donotpresent
40 |
41 | # Directories potentially created on remote AFP share
42 | .AppleDB
43 | .AppleDesktop
44 | Network Trash Folder
45 | Temporary Items
46 | .apdisk
47 |
48 | ### macOS Patch ###
49 | # iCloud generated files
50 | *.icloud
51 |
52 | ### Python ###
53 | # Byte-compiled / optimized / DLL files
54 | __pycache__/
55 | *.py[cod]
56 | *$py.class
57 |
58 | # C extensions
59 | *.so
60 |
61 | # Distribution / packaging
62 | .Python
63 | build/
64 | develop-eggs/
65 | dist/
66 | downloads/
67 | eggs/
68 | .eggs/
69 | lib/
70 | lib64/
71 | parts/
72 | sdist/
73 | var/
74 | wheels/
75 | share/python-wheels/
76 | *.egg-info/
77 | .installed.cfg
78 | *.egg
79 | MANIFEST
80 |
81 | # PyInstaller
82 | # Usually these files are written by a python script from a template
83 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
84 | *.manifest
85 | *.spec
86 |
87 | # Installer logs
88 | pip-log.txt
89 | pip-delete-this-directory.txt
90 |
91 | # Unit test / coverage reports
92 | htmlcov/
93 | .tox/
94 | .nox/
95 | .coverage
96 | .coverage.*
97 | .cache
98 | nosetests.xml
99 | coverage.xml
100 | *.cover
101 | *.py,cover
102 | .hypothesis/
103 | .pytest_cache/
104 | cover/
105 |
106 | # Translations
107 | *.mo
108 | *.pot
109 |
110 | # Django stuff:
111 | *.log
112 | local_settings.py
113 | db.sqlite3
114 | db.sqlite3-journal
115 |
116 | # Flask stuff:
117 | instance/
118 | .webassets-cache
119 |
120 | # Scrapy stuff:
121 | .scrapy
122 |
123 | # Sphinx documentation
124 | docs/_build/
125 |
126 | # PyBuilder
127 | .pybuilder/
128 | target/
129 |
130 | # Jupyter Notebook
131 | .ipynb_checkpoints
132 |
133 | # IPython
134 | profile_default/
135 | ipython_config.py
136 |
137 | # pyenv
138 | # For a library or package, you might want to ignore these files since the code is
139 | # intended to run in multiple environments; otherwise, check them in:
140 | # .python-version
141 |
142 | # pipenv
143 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
144 | # However, in case of collaboration, if having platform-specific dependencies or dependencies
145 | # having no cross-platform support, pipenv may install dependencies that don't work, or not
146 | # install all needed dependencies.
147 | #Pipfile.lock
148 |
149 | # poetry
150 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
151 | # This is especially recommended for binary packages to ensure reproducibility, and is more
152 | # commonly ignored for libraries.
153 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
154 | #poetry.lock
155 |
156 | # pdm
157 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
158 | #pdm.lock
159 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
160 | # in version control.
161 | # https://pdm.fming.dev/#use-with-ide
162 | .pdm.toml
163 |
164 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
165 | __pypackages__/
166 |
167 | # Celery stuff
168 | celerybeat-schedule
169 | celerybeat.pid
170 |
171 | # SageMath parsed files
172 | *.sage.py
173 |
174 | # Environments
175 | .env
176 | .venv
177 | env/
178 | venv/
179 | ENV/
180 | env.bak/
181 | venv.bak/
182 |
183 | # Spyder project settings
184 | .spyderproject
185 | .spyproject
186 |
187 | # Rope project settings
188 | .ropeproject
189 |
190 | # mkdocs documentation
191 | /site
192 |
193 | # mypy
194 | .mypy_cache/
195 | .dmypy.json
196 | dmypy.json
197 |
198 | # Pyre type checker
199 | .pyre/
200 |
201 | # pytype static type analyzer
202 | .pytype/
203 |
204 | # Cython debug symbols
205 | cython_debug/
206 |
207 | # PyCharm
208 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can
209 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
210 | # and can be added to the global gitignore or merged into this file. For a more nuclear
211 | # option (not recommended) you can uncomment the following to ignore the entire idea folder.
212 | #.idea/
213 |
214 | ### Python Patch ###
215 | # Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
216 | poetry.toml
217 |
218 | # ruff
219 | .ruff_cache/
220 |
221 | # LSP config files
222 | pyrightconfig.json
223 |
224 | ### Windows ###
225 | # Windows thumbnail cache files
226 | Thumbs.db
227 | Thumbs.db:encryptable
228 | ehthumbs.db
229 | ehthumbs_vista.db
230 |
231 | # Dump file
232 | *.stackdump
233 |
234 | # Folder config file
235 | [Dd]esktop.ini
236 |
237 | # Recycle Bin used on file shares
238 | $RECYCLE.BIN/
239 |
240 | # Windows Installer files
241 | *.cab
242 | *.msi
243 | *.msix
244 | *.msm
245 | *.msp
246 |
247 | # Windows shortcuts
248 | *.lnk
249 |
250 | # End of https://www.toptal.com/developers/gitignore/api/windows,python,macos,linux
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2024 Vishal Padia
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # CodeFlowMapper
2 |
3 | CodeFlowMapper is an open-source tool that generates 3D visualizations of Python codebases, helping developers quickly understand and navigate complex projects.
4 |
5 | ## How does it look?
6 | 
7 |
8 | ## Features
9 |
10 | - **3D Visualization**: Generate interactive 3D maps of your Python codebase.
11 | - **File and Function Mapping**: View files as parent nodes and functions as child nodes.
12 | - **Customizable Omissions**: Exclude specific directories from visualization.
13 | - **Obsidian-like Interface**: Familiar and intuitive visualization style.
14 |
15 | ## Quick Start
16 | To run CodeFlowMapper, you can use the following command-line interface:
17 | 1. Clone the repository and navigate to the project directory:
18 | ```bash
19 | $ git clone https://github.com/Vishal-Padia/CodeFlowMapper
20 | $ cd CodeFlowMapper
21 | ```
22 | 2. Create a virtual environment using the following command:
23 | ```bash
24 | $ python3 -m venv venv
25 | ```
26 | 3. Activate the virtual environment:
27 | ```bash
28 | $ source venv/bin/activate
29 | ```
30 | 4. Install the required dependencies:
31 | ```bash
32 | $ pip install -r requirements.txt
33 | ```
34 | 5. Run the CodeFlowMapper script:
35 | ```bash
36 | $ python main.py
37 | ```
38 | 6. Follow the prompts to input your project path and exclude directories.
39 |
40 | 7. Access the visualization at `http://localhost:5000`.
41 |
42 | **It takes some time to generate the visualization, so please be patient.**
43 | HAPPY VISUALIZING!
44 |
45 |
46 | ## Usage
47 |
48 | After launching, CodeFlowMapper will:
49 | - Download necessary models (first-time only).
50 | - Prompt for the path to your Python file or directory.
51 | - Ask for directories to exclude from the visualization.
52 | - Start a Flask server and generate the 3D visualization.
53 |
54 | ## Current Limitations
55 |
56 | - Python files and directories only
57 | - Basic Python feature support (no decorators or lambdas)
58 | - Static analysis only
59 |
60 | ## Roadmap
61 | - [ ] Add support for more programming languages
62 | - [ ] Enhance visualization with more features
63 | - [ ] Complex Python feature support
64 | - [x] AI-Powered Code Analysis
65 |
66 | ## Contributing
67 | We welcome contributions to CodeFlowMapper! If you have suggestions for improvements or bug fixes, please feel free to:
68 |
69 | - Fork the repository
70 | - Create a new branch `(git checkout -b feature/AmazingFeature)`
71 | - Commit your changes `(git commit -m 'Add some AmazingFeature')`
72 | - Push to the branch `(git push origin feature/AmazingFeature)`
73 | - Open a Pull Request
74 |
75 | ## License
76 | This project is licensed under the MIT License - see the LICENSE file for details.
77 |
78 | ## Contact
79 | Vishal Padia - vishalpadi9@gmail.com
80 |
81 | Project Link: https://github.com/Vishal-Padia/CodeFlowMapper
82 |
--------------------------------------------------------------------------------
/function_call_main.py:
--------------------------------------------------------------------------------
1 | import os
2 | import ast
3 | import flask
4 | import networkx as nx
5 | from flask import Flask, render_template_string, jsonify
6 |
7 | app = Flask(__name__)
8 |
9 | G = None
10 |
11 |
12 | def network_to_visjs(G):
13 | nodes = [
14 | {"id": node, "label": G.nodes[node].get("label", node)} for node in G.nodes()
15 | ]
16 | edges = [{"from": source, "to": target} for source, target in G.edges()]
17 | return {"nodes": nodes, "edges": edges}
18 |
19 |
20 | def parse_directory(directory_path: str, omit_dirs: list):
21 | python_files = []
22 | for root, dirs, files in os.walk(directory_path):
23 | dirs[:] = [d for d in dirs if d not in omit_dirs]
24 |
25 | for file in files:
26 | if file.endswith(".py"):
27 | python_files.append(os.path.join(root, file))
28 | return python_files
29 |
30 |
31 | def parse_file(file_path: str):
32 | with open(file_path, "r", encoding="utf-8") as f:
33 | tree = ast.parse(f.read())
34 | return tree
35 |
36 |
37 | def extract_functions_and_imports(tree):
38 | functions = {}
39 | imports = set()
40 | for node in ast.walk(tree):
41 | if isinstance(node, ast.FunctionDef):
42 | functions[node.name] = {"calls": [], "line": node.lineno, "file": None}
43 | elif isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom):
44 | for alias in node.names:
45 | imports.add(alias.name.split(".")[0]) # Add imported module names
46 | return functions, imports
47 |
48 |
49 | def analyze_function_calls(tree, functions):
50 | for node in ast.walk(tree):
51 | if isinstance(node, ast.Call):
52 | caller = None
53 | for parent in ast.walk(tree):
54 | if isinstance(parent, ast.FunctionDef) and node in ast.walk(parent):
55 | caller = parent.name
56 | break
57 | if caller and caller in functions:
58 | if isinstance(node.func, ast.Name):
59 | called_func = node.func.id
60 | functions[caller]["calls"].append(called_func)
61 | elif isinstance(node.func, ast.Attribute):
62 | called_func = node.func.attr
63 | if isinstance(node.func.value, ast.Name):
64 | object_name = node.func.value.id
65 | functions[caller]["calls"].append(
66 | f"{object_name}.{called_func}"
67 | )
68 | else:
69 | functions[caller]["calls"].append(called_func)
70 | else:
71 | if hasattr(node.func, "id"):
72 | functions[caller]["calls"].append(node.func.id)
73 | elif hasattr(node.func, "attr"):
74 | functions[caller]["calls"].append(node.func.attr)
75 |
76 |
77 | def create_graph_with_directory_structure(functions, imports, file_paths):
78 | G = nx.DiGraph()
79 |
80 | directory_nodes = {}
81 |
82 | for file_path in file_paths:
83 | directory = os.path.dirname(file_path)
84 | module_name = os.path.basename(file_path).replace(".py", "")
85 |
86 | # Add directory node
87 | if directory not in directory_nodes:
88 | G.add_node(directory, label=directory, shape="box", color="lightblue")
89 | directory_nodes[directory] = True
90 |
91 | # Add file node
92 | G.add_node(file_path, label=module_name, shape="ellipse", color="lightgreen")
93 | G.add_edge(directory, file_path)
94 |
95 | for func, data in functions.items():
96 | if data["file"] == file_path:
97 | G.add_node(func, module=module_name)
98 | G.add_edge(file_path, func)
99 | for call in data["calls"]:
100 | if call in functions:
101 | G.add_edge(func, call)
102 |
103 | for module in imports:
104 | G.add_node(module, module="import")
105 |
106 | return G
107 |
108 |
109 | @app.route("/")
110 | def index():
111 | return render_template_string(
112 | """
113 |
114 |
115 |
116 | Function Call Graph
117 |
118 |
125 |
126 |
127 |
128 |
171 |
172 |
173 | """
174 | )
175 |
176 |
177 | @app.route("/graph_data")
178 | def graph_data():
179 | return jsonify(network_to_visjs(G))
180 |
181 |
182 | def run_flask_app():
183 | print("Starting the web server.")
184 | print(
185 | "Please open a web browser and go to http://127.0.0.1:5000/ to view the graph."
186 | )
187 | app.run(debug=True)
188 |
189 |
190 | def create_graph_from_directory(directory_path, omit_dirs):
191 | global G
192 | python_files = parse_directory(directory_path, omit_dirs)
193 |
194 | functions = {}
195 | imports = set()
196 |
197 | for i, file_path in enumerate(python_files):
198 | tree = parse_file(file_path)
199 | file_functions, file_imports = extract_functions_and_imports(tree)
200 |
201 | for func_name, func_data in file_functions.items():
202 | func_data["file"] = file_path
203 |
204 | functions.update(file_functions)
205 | imports.update(file_imports)
206 | analyze_function_calls(tree, functions)
207 |
208 | G = create_graph_with_directory_structure(
209 | functions, imports, python_files[: i + 1]
210 | )
211 |
212 | print(
213 | f"Processing file {i+1}/{len(python_files)}: {os.path.basename(file_path)}"
214 | )
215 |
216 | print("Graph creation completed.")
217 |
218 |
219 | def main():
220 | directory_path = input("Enter the path to the directory: ")
221 | print(f"The input directory is: {directory_path}")
222 | omit_dirs = input("Enter the directories to omit (comma-separated): ").split(",")
223 | omit_list = [func.strip() for func in omit_dirs]
224 | create_graph_from_directory(directory_path, omit_list)
225 | run_flask_app()
226 |
227 |
228 | if __name__ == "__main__":
229 | main()
230 |
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | import os
2 | import ast
3 | import flask
4 | import networkx as nx
5 | from flask import Flask, render_template_string, jsonify, request
6 | from transformers import pipeline
7 |
8 | app = Flask(__name__)
9 |
10 | G = None
11 | code_contents = {}
12 |
13 | # Initialize the code explanation model
14 | explainer = pipeline("text2text-generation", model="facebook/bart-large-cnn")
15 |
16 |
17 | def network_to_visjs(G: nx.DiGraph):
18 | """
19 | Convert a NetworkX graph to a dictionary format that can be used by vis.js.
20 | """
21 | nodes = [
22 | {
23 | "id": node,
24 | "label": G.nodes[node].get("label", node),
25 | "color": G.nodes[node].get("color", "#FFFFFF"),
26 | "shape": G.nodes[node].get("shape", "dot"),
27 | "size": G.nodes[node].get("size", 10),
28 | }
29 | for node in G.nodes()
30 | ]
31 | edges = [
32 | {"from": source, "to": target, "color": "#FFFFFF"}
33 | for source, target in G.edges()
34 | ]
35 | return {"nodes": nodes, "edges": edges}
36 |
37 |
38 | def parse_directory(directory_path: str, omit_dirs: list):
39 | """
40 | Parse a directory and return a list of Python files in the directory.
41 | """
42 | python_files = []
43 | for root, dirs, files in os.walk(directory_path):
44 | dirs[:] = [d for d in dirs if d not in omit_dirs]
45 | for file in files:
46 | if file.endswith(".py"):
47 | python_files.append(os.path.join(root, file))
48 | return python_files
49 |
50 |
51 | def parse_file(file_path: str):
52 | """
53 | Parse a Python file and return the AST (Abstract Syntax Tree) representation of the code.
54 | """
55 | with open(file_path, "r", encoding="utf-8") as f:
56 | content = f.read()
57 | code_contents[file_path] = content
58 | tree = ast.parse(content)
59 | return tree
60 |
61 |
62 | def extract_functions_and_imports(tree: ast.AST):
63 | """
64 | Extract function definitions and imports from the AST of a Python file.
65 | Also track function calls for execution path visualization.
66 | """
67 | functions = {}
68 | imports = set()
69 | function_stack = []
70 | current_func = None
71 |
72 | for node in ast.walk(tree):
73 | if isinstance(node, ast.FunctionDef):
74 | current_func = node.name
75 | functions[node.name] = {"calls": [], "line": node.lineno, "file": None}
76 | function_stack.append(current_func)
77 |
78 | elif isinstance(node, ast.Call) and current_func:
79 | if isinstance(node.func, ast.Name):
80 | functions[current_func]["calls"].append(node.func.id)
81 |
82 | elif isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom):
83 | for alias in node.names:
84 | imports.add(alias.name.split(".")[0])
85 |
86 | elif isinstance(node, ast.Return):
87 | if function_stack:
88 | function_stack.pop()
89 | current_func = function_stack[-1] if function_stack else None
90 |
91 | return functions, imports
92 |
93 |
94 | def create_graph_with_directory_structure(
95 | functions: dict, imports: set, file_paths: list
96 | ):
97 | """
98 | Create a directed graph representing the directory structure of Python files, function calls, and imports.
99 | """
100 | G = nx.DiGraph()
101 |
102 | for file_path in file_paths:
103 | module_name = os.path.basename(file_path).replace(".py", "")
104 | G.add_node(file_path, label=module_name, color="#FF6B6B", shape="dot", size=15)
105 |
106 | for module in imports:
107 | G.add_node(module, label=module, color="#4ECDC4", shape="dot", size=10)
108 |
109 | for func_name, func_data in functions.items():
110 | G.add_node(func_name, label=func_name, color="#FFFFFF", shape="dot", size=7)
111 | if func_data["file"]:
112 | G.add_edge(func_data["file"], func_name)
113 |
114 | for called_func in func_data["calls"]:
115 | if called_func in functions:
116 | G.add_edge(func_name, called_func)
117 |
118 | return G
119 |
120 |
121 | @app.route("/")
122 | def index():
123 | """
124 | A web page displaying the graph with search and code execution path visualization.
125 | """
126 | return render_template_string(
127 | """
128 |
129 |
130 |
131 | Graph Visualization
132 |
133 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
# of connections: {len(adjacencies)}\")\n",
457 | "\n",
458 | " node_trace.marker.color = node_adjacencies\n",
459 | " node_trace.hovertext = node_text\n",
460 | "\n",
461 | " # Create edge traces with arrows\n",
462 | " edge_traces = []\n",
463 | " for edge in G.edges():\n",
464 | " start = layt[list(G.nodes()).index(edge[0])]\n",
465 | " end = layt[list(G.nodes()).index(edge[1])]\n",
466 | " x0, y0, z0 = start\n",
467 | " x1, y1, z1 = end\n",
468 | " \n",
469 | " # Calculate the direction vector\n",
470 | " dx, dy, dz = x1 - x0, y1 - y0, z1 - z0\n",
471 | " \n",
472 | " # Normalize the direction vector\n",
473 | " length = np.sqrt(dx**2 + dy**2 + dz**2)\n",
474 | " ux, uy, uz = dx/length, dy/length, dz/length\n",
475 | " \n",
476 | " # Calculate the midpoint\n",
477 | " mx, my, mz = (x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2\n",
478 | " \n",
479 | " # Create the line trace\n",
480 | " line_trace = go.Scatter3d(\n",
481 | " x=[x0, x1],\n",
482 | " y=[y0, y1],\n",
483 | " z=[z0, z1],\n",
484 | " mode='lines',\n",
485 | " line=dict(color='#888', width=2),\n",
486 | " hoverinfo='none'\n",
487 | " )\n",
488 | " \n",
489 | " # Create the arrow trace\n",
490 | " arrow_trace = go.Cone(\n",
491 | " x=[mx], y=[my], z=[mz],\n",
492 | " u=[ux], v=[uy], w=[uz],\n",
493 | " sizemode=\"absolute\",\n",
494 | " sizeref=0.15,\n",
495 | " showscale=False,\n",
496 | " colorscale=[[0, '#888'], [1, '#888']],\n",
497 | " anchor=\"tip\"\n",
498 | " )\n",
499 | " \n",
500 | " edge_traces.extend([line_trace, arrow_trace])\n",
501 | "\n",
502 | " # Create the figure\n",
503 | " fig = go.Figure(data=[*edge_traces, node_trace],\n",
504 | " layout=go.Layout(\n",
505 | " title='3D Function Call Graph',\n",
506 | " showlegend=False,\n",
507 | " hovermode='closest',\n",
508 | " margin=dict(b=0,l=0,r=0,t=0),\n",
509 | " scene=dict(\n",
510 | " xaxis=dict(showbackground=False, showline=False, zeroline=False, showgrid=False, showticklabels=False, title=''),\n",
511 | " yaxis=dict(showbackground=False, showline=False, zeroline=False, showgrid=False, showticklabels=False, title=''),\n",
512 | " zaxis=dict(showbackground=False, showline=False, zeroline=False, showgrid=False, showticklabels=False, title=''),\n",
513 | " ),\n",
514 | " annotations=[\n",
515 | " dict(\n",
516 | " showarrow=False,\n",
517 | " text=\"\",\n",
518 | " xref=\"paper\",\n",
519 | " yref=\"paper\",\n",
520 | " x=0,\n",
521 | " y=0.1,\n",
522 | " xanchor=\"left\",\n",
523 | " yanchor=\"bottom\",\n",
524 | " font=dict(size=14)\n",
525 | " )\n",
526 | " ]\n",
527 | " )\n",
528 | " )\n",
529 | "\n",
530 | " return fig"
531 | ]
532 | },
533 | {
534 | "cell_type": "code",
535 | "execution_count": 18,
536 | "metadata": {},
537 | "outputs": [],
538 | "source": [
539 | "def create_dash_app(G):\n",
540 | " \"\"\"\n",
541 | " Create a Dash app to serve the 3D graph visualization\n",
542 | " \n",
543 | " Args:\n",
544 | " G: A directed graph of the functions, their calls, and imports\n",
545 | " \n",
546 | " Returns:\n",
547 | " A Dash app object\n",
548 | " \"\"\"\n",
549 | " app = Dash(__name__)\n",
550 | " \n",
551 | " app.layout = html.Div([\n",
552 | " html.H1(\"3D Function Call Graph\"),\n",
553 | " dcc.Graph(id='3d-graph', figure=visualize_graph_3d(G)),\n",
554 | " ])\n",
555 | " \n",
556 | " return app"
557 | ]
558 | },
559 | {
560 | "cell_type": "code",
561 | "execution_count": 19,
562 | "metadata": {},
563 | "outputs": [
564 | {
565 | "name": "stdout",
566 | "output_type": "stream",
567 | "text": [
568 | "The input directory is: C:\\Users\\Vishal\\Github\\CodeFlowMapper\\testing-directories\n",
569 | "The functions to omit are: ['']\n",
570 | "Processing file 1/4: analyzer.py\n",
571 | "Processing file 2/4: data_processor.py\n",
572 | "Processing file 3/4: main.py\n",
573 | "Processing file 4/4: utils.py\n",
574 | "Starting the web server. Please open a web browser and go to http://127.0.0.1:8050/ to view the graph.\n"
575 | ]
576 | },
577 | {
578 | "data": {
579 | "text/html": [
580 | "\n",
581 | " \n",
589 | " "
590 | ],
591 | "text/plain": [
592 | ""
593 | ]
594 | },
595 | "metadata": {},
596 | "output_type": "display_data"
597 | }
598 | ],
599 | "source": [
600 | "def main():\n",
601 | " directory_path = input(\"Enter the path to the directory: \")\n",
602 | " print(f\"The input directory is: {directory_path}\")\n",
603 | " omit_list = input(\"Enter the functions to omit (comma-separated): \").split(',')\n",
604 | " print(f\"The functions to omit are: {omit_list}\")\n",
605 | "\n",
606 | " omit_list = [func.strip() for func in omit_list]\n",
607 | "\n",
608 | " python_files = parse_directory(directory_path)\n",
609 | "\n",
610 | " functions = {}\n",
611 | " imports = set()\n",
612 | " G = nx.DiGraph()\n",
613 | "\n",
614 | " for i, file_path in enumerate(python_files):\n",
615 | " tree = parse_file(file_path)\n",
616 | " file_functions, file_imports = extract_functions_and_imports(tree)\n",
617 | " \n",
618 | " for func_name, func_data in file_functions.items():\n",
619 | " func_data['file'] = file_path\n",
620 | " \n",
621 | " functions.update(file_functions)\n",
622 | " imports.update(file_imports)\n",
623 | " analyze_function_calls(tree, functions, omit_list)\n",
624 | "\n",
625 | " G = create_graph(functions, imports, python_files[:i+1], omit_list)\n",
626 | " \n",
627 | " print(f\"Processing file {i+1}/{len(python_files)}: {os.path.basename(file_path)}\")\n",
628 | "\n",
629 | " # Pause to simulate processing time (optional)\n",
630 | " time.sleep(0.5)\n",
631 | "\n",
632 | " # Create and run the Dash app\n",
633 | " app = create_dash_app(G)\n",
634 | " print(\"Starting the web server. Please open a web browser and go to http://127.0.0.1:8050/ to view the graph.\")\n",
635 | " app.run_server(debug=True)\n",
636 | "\n",
637 | "if __name__ == \"__main__\":\n",
638 | " main()"
639 | ]
640 | },
641 | {
642 | "cell_type": "markdown",
643 | "metadata": {},
644 | "source": [
645 | "# Visualizing the graph on the web"
646 | ]
647 | },
648 | {
649 | "cell_type": "code",
650 | "execution_count": 20,
651 | "metadata": {},
652 | "outputs": [],
653 | "source": [
654 | "import os\n",
655 | "import ast\n",
656 | "import time\n",
657 | "import flask\n",
658 | "import networkx as nx\n",
659 | "from flask import Flask, render_template_string, jsonify"
660 | ]
661 | },
662 | {
663 | "cell_type": "code",
664 | "execution_count": 21,
665 | "metadata": {},
666 | "outputs": [],
667 | "source": [
668 | "app = Flask(__name__)"
669 | ]
670 | },
671 | {
672 | "cell_type": "code",
673 | "execution_count": 22,
674 | "metadata": {},
675 | "outputs": [],
676 | "source": [
677 | "def network_to_visjs(G):\n",
678 | " nodes = [{\"id\": node, \"label\": node} for node in G.nodes()]\n",
679 | " edges = [{\"from\": source, \"to\": target} for source, target in G.edges()]\n",
680 | " return {\"nodes\": nodes, \"edges\": edges}"
681 | ]
682 | },
683 | {
684 | "cell_type": "code",
685 | "execution_count": 23,
686 | "metadata": {},
687 | "outputs": [],
688 | "source": [
689 | "def parse_directory(directory_path: str):\n",
690 | " \"\"\" \n",
691 | " Parse the directory and return all the python files in that directory\n",
692 | "\n",
693 | " Args:\n",
694 | " directory_path: The path to the directory\n",
695 | "\n",
696 | " Returns:\n",
697 | " A list of all the python files in the directory\n",
698 | " \"\"\"\n",
699 | " python_files = []\n",
700 | " for root, dirs, files in os.walk(directory_path):\n",
701 | " for file in files:\n",
702 | " if file.endswith(\".py\"):\n",
703 | " python_files.append(os.path.join(root, file))\n",
704 | " return python_files\n"
705 | ]
706 | },
707 | {
708 | "cell_type": "code",
709 | "execution_count": 24,
710 | "metadata": {},
711 | "outputs": [],
712 | "source": [
713 | "def parse_file(file_path: str):\n",
714 | " \"\"\"\n",
715 | " Parse the file and return the abstract syntax tree\n",
716 | "\n",
717 | " Args:\n",
718 | " file_path: The path to the file to be parsed\n",
719 | "\n",
720 | " Returns:\n",
721 | " The abstract syntax tree of the file\n",
722 | " \"\"\"\n",
723 | " with open(file_path, 'r', encoding='utf-8') as f:\n",
724 | " tree = ast.parse(f.read())\n",
725 | " return tree"
726 | ]
727 | },
728 | {
729 | "cell_type": "code",
730 | "execution_count": 25,
731 | "metadata": {},
732 | "outputs": [],
733 | "source": [
734 | "def extract_functions_and_imports(tree):\n",
735 | " \"\"\" \n",
736 | " Extract all the functions and imported modules from the abstract syntax tree\n",
737 | "\n",
738 | " Args:\n",
739 | " tree: The abstract syntax tree of the file\n",
740 | "\n",
741 | " Returns:\n",
742 | " A dictionary of functions and imports with the function name as the key and the function's data\n",
743 | " \"\"\"\n",
744 | " functions = {}\n",
745 | " imports = set()\n",
746 | " for node in ast.walk(tree):\n",
747 | " if isinstance(node, ast.FunctionDef):\n",
748 | " functions[node.name] = {\n",
749 | " \"calls\": [],\n",
750 | " 'line': node.lineno,\n",
751 | " 'file': None\n",
752 | " }\n",
753 | " elif isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom):\n",
754 | " for alias in node.names:\n",
755 | " imports.add(alias.name.split('.')[0]) # Add imported module names\n",
756 | " return functions, imports"
757 | ]
758 | },
759 | {
760 | "cell_type": "code",
761 | "execution_count": 26,
762 | "metadata": {},
763 | "outputs": [],
764 | "source": [
765 | "def analyze_function_calls(tree, functions, omit_list):\n",
766 | " \"\"\" \n",
767 | " Analyze the function calls in the abstract syntax tree and update the functions dictionary\n",
768 | "\n",
769 | " Args:\n",
770 | " tree: The abstract syntax tree of the file\n",
771 | " functions: The dictionary of functions with the function name as the key and the function's\n",
772 | " omit_list: A list of functions to omit from the analysis\n",
773 | "\n",
774 | " Returns:\n",
775 | " None\n",
776 | " \"\"\"\n",
777 | " for node in ast.walk(tree):\n",
778 | " if isinstance(node, ast.Call):\n",
779 | " caller = None\n",
780 | " for parent in ast.walk(tree):\n",
781 | " if isinstance(parent, ast.FunctionDef) and node in ast.walk(parent):\n",
782 | " caller = parent.name\n",
783 | " break\n",
784 | " if caller and caller in functions and caller not in omit_list:\n",
785 | " if isinstance(node.func, ast.Name):\n",
786 | " called_func = node.func.id\n",
787 | " if called_func not in omit_list:\n",
788 | " functions[caller]['calls'].append(called_func)\n",
789 | " elif isinstance(node.func, ast.Attribute):\n",
790 | " called_func = node.func.attr\n",
791 | " if isinstance(node.func.value, ast.Name):\n",
792 | " object_name = node.func.value.id\n",
793 | " if called_func not in omit_list:\n",
794 | " # Append the method call (e.g., object.method)\n",
795 | " functions[caller]['calls'].append(f\"{object_name}.{called_func}\")\n",
796 | " else:\n",
797 | " if called_func not in omit_list:\n",
798 | " functions[caller]['calls'].append(called_func)\n",
799 | " else:\n",
800 | " if hasattr(node.func, 'id') and node.func.id not in omit_list:\n",
801 | " functions[caller]['calls'].append(node.func.id)\n",
802 | " elif hasattr(node.func, 'attr') and node.func.attr not in omit_list:\n",
803 | " functions[caller]['calls'].append(node.func.attr)"
804 | ]
805 | },
806 | {
807 | "cell_type": "code",
808 | "execution_count": 27,
809 | "metadata": {},
810 | "outputs": [],
811 | "source": [
812 | "def create_graph(functions, imports, file_paths, omit_list):\n",
813 | " \"\"\" \n",
814 | " Create a directed graph of the functions, their calls, and imports\n",
815 | "\n",
816 | " Args:\n",
817 | " functions: The dictionary of functions with the function name as the key and the function's data\n",
818 | " imports: The set of imported modules\n",
819 | " file_paths: A list of file paths\n",
820 | " omit_list: A list of functions to omit from the analysis\n",
821 | "\n",
822 | " Returns:\n",
823 | " A directed graph of the functions, their calls, and imports\n",
824 | " \"\"\"\n",
825 | " G = nx.DiGraph()\n",
826 | " \n",
827 | " for file_path in file_paths:\n",
828 | " module_name = os.path.basename(file_path).replace('.py', '')\n",
829 | " for func, data in functions.items():\n",
830 | " if data['file'] == file_path and func not in omit_list:\n",
831 | " G.add_node(func, module=module_name)\n",
832 | " for call in data['calls']:\n",
833 | " if call in functions and call not in omit_list:\n",
834 | " G.add_edge(func, call)\n",
835 | "\n",
836 | " # Add imported modules as isolated nodes\n",
837 | " for module in imports:\n",
838 | " G.add_node(module, module='import')\n",
839 | " \n",
840 | " return G"
841 | ]
842 | },
843 | {
844 | "cell_type": "code",
845 | "execution_count": 29,
846 | "metadata": {},
847 | "outputs": [],
848 | "source": [
849 | "@app.route('/')\n",
850 | "def index():\n",
851 | " return render_template_string('''\n",
852 | " \n",
853 | " \n",
854 | " \n",
855 | " Function Call Graph\n",
856 | " \n",
857 | " \n",
864 | " \n",
865 | " \n",
866 | " \n",
867 | " \n",
904 | " \n",
905 | " \n",
906 | " ''')"
907 | ]
908 | },
909 | {
910 | "cell_type": "code",
911 | "execution_count": 30,
912 | "metadata": {},
913 | "outputs": [],
914 | "source": [
915 | "@app.route('/graph_data')\n",
916 | "def graph_data():\n",
917 | " return jsonify(network_to_visjs(G))"
918 | ]
919 | },
920 | {
921 | "cell_type": "code",
922 | "execution_count": 32,
923 | "metadata": {},
924 | "outputs": [],
925 | "source": [
926 | "def create_graph_from_directory(directory_path, omit_list):\n",
927 | " global G\n",
928 | " python_files = parse_directory(directory_path)\n",
929 | "\n",
930 | " functions = {}\n",
931 | " imports = set()\n",
932 | "\n",
933 | " for i, file_path in enumerate(python_files):\n",
934 | " tree = parse_file(file_path)\n",
935 | " file_functions, file_imports = extract_functions_and_imports(tree)\n",
936 | " \n",
937 | " for func_name, func_data in file_functions.items():\n",
938 | " func_data['file'] = file_path\n",
939 | " \n",
940 | " functions.update(file_functions)\n",
941 | " imports.update(file_imports)\n",
942 | " analyze_function_calls(tree, functions, omit_list)\n",
943 | "\n",
944 | " G = create_graph(functions, imports, python_files[:i+1], omit_list)\n",
945 | " \n",
946 | " print(f\"Processing file {i+1}/{len(python_files)}: {os.path.basename(file_path)}\")\n",
947 | "\n",
948 | " print(\"Graph creation completed.\")"
949 | ]
950 | },
951 | {
952 | "cell_type": "code",
953 | "execution_count": 33,
954 | "metadata": {},
955 | "outputs": [],
956 | "source": [
957 | "def run_flask_app():\n",
958 | " print(\"Starting the web server.\")\n",
959 | " print(\"Please open a web browser and go to http://127.0.0.1:5000/ to view the graph.\")\n",
960 | " app.run(debug=True)"
961 | ]
962 | },
963 | {
964 | "cell_type": "code",
965 | "execution_count": 34,
966 | "metadata": {},
967 | "outputs": [
968 | {
969 | "name": "stdout",
970 | "output_type": "stream",
971 | "text": [
972 | "The input directory is: C:\\Users\\Vishal\\Github\\CodeFlowMapper\\testing-directories\n",
973 | "The functions to omit are: ['']\n",
974 | "Processing file 1/4: analyzer.py\n",
975 | "Processing file 2/4: data_processor.py\n",
976 | "Processing file 3/4: main.py\n",
977 | "Processing file 4/4: utils.py\n",
978 | "Graph creation completed.\n",
979 | "Starting the web server.\n",
980 | "Please open a web browser and go to http://127.0.0.1:5000/ to view the graph.\n",
981 | " * Serving Flask app '__main__'\n",
982 | " * Debug mode: on\n"
983 | ]
984 | },
985 | {
986 | "ename": "SystemExit",
987 | "evalue": "1",
988 | "output_type": "error",
989 | "traceback": [
990 | "An exception has occurred, use %tb to see the full traceback.\n",
991 | "\u001b[1;31mSystemExit\u001b[0m\u001b[1;31m:\u001b[0m 1\n"
992 | ]
993 | }
994 | ],
995 | "source": [
996 | "if __name__ == \"__main__\":\n",
997 | " directory_path = input(\"Enter the path to the directory: \")\n",
998 | " print(f\"The input directory is: {directory_path}\")\n",
999 | " omit_list = input(\"Enter the functions to omit (comma-separated): \").split(',')\n",
1000 | " print(f\"The functions to omit are: {omit_list}\")\n",
1001 | "\n",
1002 | " omit_list = [func.strip() for func in omit_list]\n",
1003 | "\n",
1004 | " create_graph_from_directory(directory_path, omit_list)\n",
1005 | " run_flask_app()"
1006 | ]
1007 | },
1008 | {
1009 | "cell_type": "code",
1010 | "execution_count": null,
1011 | "metadata": {},
1012 | "outputs": [],
1013 | "source": []
1014 | }
1015 | ],
1016 | "metadata": {
1017 | "kernelspec": {
1018 | "display_name": "venv",
1019 | "language": "python",
1020 | "name": "python3"
1021 | },
1022 | "language_info": {
1023 | "codemirror_mode": {
1024 | "name": "ipython",
1025 | "version": 3
1026 | },
1027 | "file_extension": ".py",
1028 | "mimetype": "text/x-python",
1029 | "name": "python",
1030 | "nbconvert_exporter": "python",
1031 | "pygments_lexer": "ipython3",
1032 | "version": "3.11.9"
1033 | }
1034 | },
1035 | "nbformat": 4,
1036 | "nbformat_minor": 2
1037 | }
1038 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | asttokens==2.4.1
2 | attrs==24.2.0
3 | blinker==1.8.2
4 | certifi==2024.8.30
5 | charset-normalizer==3.3.2
6 | click==8.1.7
7 | colorama==0.4.6
8 | comm==0.2.2
9 | contourpy==1.2.1
10 | cycler==0.12.1
11 | dash==2.17.1
12 | dash-core-components==2.0.0
13 | dash-html-components==2.0.0
14 | dash-table==5.0.0
15 | debugpy==1.8.5
16 | decorator==5.1.1
17 | executing==2.0.1
18 | fastjsonschema==2.20.0
19 | filelock==3.15.4
20 | Flask==3.0.3
21 | fonttools==4.53.1
22 | fsspec==2024.6.1
23 | huggingface-hub==0.24.6
24 | idna==3.8
25 | igraph==0.11.6
26 | importlib_metadata==8.4.0
27 | ipykernel==6.29.5
28 | ipython==8.26.0
29 | itsdangerous==2.2.0
30 | jedi==0.19.1
31 | Jinja2==3.1.4
32 | jsonschema==4.23.0
33 | jsonschema-specifications==2023.12.1
34 | jupyter_client==8.6.2
35 | jupyter_core==5.7.2
36 | kiwisolver==1.4.5
37 | MarkupSafe==2.1.5
38 | matplotlib==3.9.2
39 | matplotlib-inline==0.1.7
40 | mpmath==1.3.0
41 | nbformat==5.10.4
42 | nest-asyncio==1.6.0
43 | networkx==3.3
44 | numpy==1.26.4
45 | packaging==24.1
46 | pandas==2.2.2
47 | parso==0.8.4
48 | pillow==10.4.0
49 | platformdirs==4.2.2
50 | plotly==5.23.0
51 | prompt_toolkit==3.0.47
52 | psutil==6.0.0
53 | pure_eval==0.2.3
54 | Pygments==2.18.0
55 | pyparsing==3.1.2
56 | python-dateutil==2.9.0.post0
57 | pytz==2024.1
58 | pywin32==306
59 | PyYAML==6.0.2
60 | pyzmq==26.1.0
61 | referencing==0.35.1
62 | regex==2024.7.24
63 | requests==2.32.3
64 | retrying==1.3.4
65 | rpds-py==0.20.0
66 | safetensors==0.4.4
67 | scipy==1.14.0
68 | six==1.16.0
69 | stack-data==0.6.3
70 | sympy==1.13.2
71 | tenacity==9.0.0
72 | texttable==1.7.0
73 | tokenizers==0.19.1
74 | torch==2.4.0
75 | torchaudio==2.4.0
76 | torchvision==0.19.0
77 | tornado==6.4.1
78 | tqdm==4.66.5
79 | traitlets==5.14.3
80 | transformers==4.44.2
81 | typing_extensions==4.12.2
82 | tzdata==2024.1
83 | urllib3==2.2.2
84 | wcwidth==0.2.13
85 | Werkzeug==3.0.4
86 | zipp==3.20.1
87 |
--------------------------------------------------------------------------------
/testing-directories/analyzer.py:
--------------------------------------------------------------------------------
1 | from .utils import log_message
2 | from .data_processor import preprocess_data
3 |
4 |
5 | def analyze_results(data):
6 | log_message("Analyzing results")
7 | preprocessed = preprocess_data(data)
8 | total = sum(preprocessed)
9 | average = total / len(preprocessed)
10 | return {"total": total, "average": average}
11 |
12 |
13 | def generate_report(results):
14 | log_message("Generating report")
15 | return f"Report: Total = {results['total']}, Average = {results['average']}"
16 |
--------------------------------------------------------------------------------
/testing-directories/data_processor.py:
--------------------------------------------------------------------------------
1 | from .utils import log_message, validate_data
2 |
3 | def process_data(data):
4 | log_message("Processing data")
5 | validate_data(data)
6 | return [x * 2 for x in data]
7 |
8 | def preprocess_data(data):
9 | log_message("Preprocessing data")
10 | return [x + 1 for x in data]
--------------------------------------------------------------------------------
/testing-directories/main.py:
--------------------------------------------------------------------------------
1 | from .data_processor import process_data
2 | from .analyzer import analyze_results
3 | from .utils import log_message
4 | from .analyzer import generate_report
5 |
6 |
7 | def main():
8 | log_message("Starting main process")
9 | data = [1, 2, 3, 4, 5]
10 | processed_data = process_data(data)
11 | results = analyze_results(processed_data)
12 | log_message(f"Analysis results: {results}")
13 | report = generate_report(results)
14 | log_message(f"Report: {report}")
15 |
16 |
17 | if __name__ == "__main__":
18 | main()
19 |
--------------------------------------------------------------------------------
/testing-directories/utils.py:
--------------------------------------------------------------------------------
1 | def log_message(message):
2 | print(f"[LOG] {message}")
3 |
4 |
5 | def validate_data(data):
6 | if not isinstance(data, list):
7 | raise ValueError("Data must be a list")
8 | if not all(isinstance(x, (int, float)) for x in data):
9 | raise ValueError("All elements must be numbers")
10 |
--------------------------------------------------------------------------------
/testing-files/basic_python.py:
--------------------------------------------------------------------------------
1 | def main():
2 | print("Starting the program...")
3 | data = get_data()
4 | processed_data = process_data(data)
5 | result = analyze_results(processed_data)
6 | display_results(result)
7 | print("Program completed.")
8 |
9 |
10 | def get_data():
11 | print("Fetching data...")
12 | data = [1, 2, 3, 4, 5]
13 | validate_data(data)
14 | return data
15 |
16 |
17 | def validate_data(data):
18 | print("Validating data...")
19 | if not data:
20 | raise ValueError("Data is empty")
21 | return True
22 |
23 |
24 | def process_data(data):
25 | print("Processing data...")
26 | return [x * 2 for x in data]
27 |
28 |
29 | def analyze_results(data):
30 | print("Analyzing results...")
31 | total = calculate_total(data)
32 | average = calculate_average(data)
33 | return {"total": total, "average": average}
34 |
35 |
36 | def calculate_total(data):
37 | return sum(data)
38 |
39 |
40 | def calculate_average(data):
41 | total = calculate_total(data)
42 | return total / len(data)
43 |
44 |
45 | def display_results(results):
46 | print("Displaying results...")
47 | print(f"Total: {results['total']}")
48 | print(f"Average: {results['average']}")
49 |
50 |
51 | if __name__ == "__main__":
52 | main()
53 |
--------------------------------------------------------------------------------