codegrapher 0.3.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1 @@
+from .script import cli

cli/script.py

@@ -0,0 +1,58 @@
+import os
+import re
+
+import click
+
+from codegrapher.graph import FunctionGrapher
+from codegrapher.parser import FileObject
+
+
+@click.command()
+@click.argument('code', type=click.Path())
+@click.option('-r', '--recursive', default=False, is_flag=True,
+              help='Treat code argument as a directory and parse all files in directory, recursively')
+@click.option('--printed', default=False, is_flag=True, help='Pretty prints the call tree for each class in the file')
+@click.option('--ignore', default=False, is_flag=True, help='Use a .cg_ignore file to ignore functions in call tree')
+@click.option('--remove-builtins', default=False, is_flag=True, help='Removes builtin functions from call trees')
+@click.option('--output', help='Graphviz output file name')
+@click.option('--output-format', default='pdf', help='File type for graphviz output file')
+def cli(code, recursive, printed, ignore, remove_builtins, output, output_format):
+    """
+    Parses a file.
+    codegrapher [file_name]
+    """
+    file_list = []
+    if recursive:
+        for dirpath, dirnames, filenames in os.walk(code):
+            for filename in filenames:
+                if re.search(r'\.py$', filename):
+                    file_list.append(os.sep.join([dirpath, filename]))
+    else:
+        file_list.append(code)
+
+    graph = None
+    for file_name in file_list:
+        file_object = FileObject(file_name)
+        file_object.visit()
+        if remove_builtins:
+            file_object.remove_builtins()
+        if ignore:
+            file_object.add_ignore_file()
+            file_object.ignore_functions()
+        if printed:
+            click.echo('Classes in file {}:'.format(file_name))
+            for class_object in file_object.classes:
+                click.echo('=' * 80)
+                click.echo(class_object.name)
+                click.echo(class_object.pprint())
+                click.echo('')
+        if output:
+            try:
+                graph.add_file_to_graph(file_object)
+            except AttributeError:
+                graph = FunctionGrapher()
+                graph.add_file_to_graph(file_object)
+    if output:
+        graph.name = output
+        graph.format = output_format
+        graph.render()

codegrapher/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.3.0'

codegrapher/graph.py

@@ -0,0 +1,168 @@
+from graphviz import Digraph
+
+
+class FilenameNotSpecifiedException(Exception):
+    """ An exception raised when a file name is not specified in a :class:`FunctionGrapher` instance before calling
+    :func:`FunctionGrapher.render` on it.
+    """
+    pass
+
+
+class Node(object):
+    """ A class to more easily handle manipulations needed to properly display nodes in a graph.
+    Optimized to handle nodes that represent functions in a program.
+
+    Attributes:
+        tuple (tuple): Contains the namespace, class, and function name for the current node. If namespace is an empty
+            string, this contains just the class and function names. If a string is provided to the constructor this
+            is a tuple containing just the function name.
+    """
+    def __init__(self, input_node):
+        if isinstance(input_node, tuple):
+            if input_node[0] == '':
+                self.tuple = input_node[1:]
+            else:
+                self.tuple = input_node
+        else:
+            self.tuple = (input_node,)
+
+    @property
+    def represent(self):
+        """ Provides a string representation of the current node
+
+        Returns:
+            (string): Dotted form of current node, as in `namespace.class.function_name`.
+        """
+        return '.'.join(self.tuple)
+
+    def __str__(self):
+        return '.'.join(self.tuple)
+
+    def __repr__(self):
+        return "<Node: {}>".format(self.tuple)
+
+    def __hash__(self):
+        return hash('.'.join(self.tuple))
+
+    def __eq__(self, other):
+        return self.tuple == other.tuple
+
+
+class FunctionGrapher(object):
+    """ `FunctionGrapher` is a class for producing `graphviz <http://www.graphviz.org/>`_ graphs showing the call
+    graph for sets of classes.
+
+    Attributes:
+        name (string): Name to be used when a graph is made.
+        nodes (set): Graphviz nodes to be graphed.
+        edges (set): Directional edges connecting one node to another.
+        format (string): File format for graph. Default is `pdf`.
+    """
+    def __init__(self):
+        self.name = ''
+        self.dot_file = Digraph()
+        self.nodes = set()
+        self.edges = set()
+
+    @property
+    def format(self):
+        return self.dot_file.format
+
+    @format.setter
+    def format(self, value):
+        self.dot_file.format = value
+
+    def add_file_to_graph(self, file_object):
+        """ When given a :class:`codegrapher.parser.FileObject` object, this adds all classes to the current graph.
+
+        Arguments:
+            file_object (:class:`codegrapher.parser.FileObject`): Visitor objects to have all its classes added to the
+              current graph.
+        """
+        class_namespace = dict((cls.name, file_object.relative_namespace) for cls in file_object.classes)
+        for cls in file_object.classes:
+            self.add_dict_to_graph(class_namespace, cls.call_tree, file_object.relative_namespace)
+        self.add_classes_to_graph(file_object.classes, file_object.relative_namespace)
+
+    def add_dict_to_graph(self, class_names, dictionary, relative_namespace):
+        """ Creates a list of nodes and edges to be rendered. Deduplicates input.
+
+        Arguments:
+            class_names (list): List of class names to be recognized by the graph as `class_name.__init__` nodes.
+            dictionary (dict): `ClassObject.call_tree` dict to be added to graph nodes and edges.
+            relative_namespace (string): Relative namespace for the current class, i.e. where the current class is
+                located relative to the root, in dotted path notation.
+        """
+        # todo: better handle project hierarchy by looking at imports
+        # add nodes
+        for origin in dictionary:
+            self.nodes.add(Node(origin))
+            for destination in dictionary[origin]:
+                if destination[0] in class_names:
+                    destination = Node((relative_namespace, destination[0], '__init__'))
+                else:
+                    destination = Node(destination)
+                self.nodes.add(destination)
+
+        # add edges
+        for origin in dictionary:
+            for destination in dictionary[origin]:
+                # if destination is a class name, it is a constructor
+                if destination[0] in class_names:
+                    destination = (relative_namespace, destination[0], '__init__')
+                else:
+                    destination = destination
+                self.edges.add((Node(origin), Node(destination)))
+
+    def add_classes_to_graph(self, classes, relative_namespace):
+        """ Adds classes with constructors to the set.
+        This adds edges between a class constructor and the methods called on those items.
+
+        Arguments:
+            classes (list): list of :class:`codegrapher.parser.ClassObject` items.
+            relative_namespace (string): namespace of the current class.
+        """
+        for cls in classes:
+            # If a class is here, add it as a node
+            self.nodes.add(Node((relative_namespace, cls.name)))
+
+            if not all((fcn.is_classmethod for fcn in cls.functions)):
+                # for case where there is at least one non-classmethod, assume implied (or explicit) __init__
+
+                # make a node between the class name and __init__
+                self.nodes.add(Node((relative_namespace, cls.name, '__init__')))
+                self.edges.add((Node((relative_namespace, cls.name)), Node((relative_namespace, cls.name, '__init__'))))
+                for fcn in cls.functions:
+                    # skip classmethods and case where init would refer back to itself
+                    if not fcn.is_classmethod and not fcn.name == '__init__':
+                        self.edges.add((Node((relative_namespace, cls.name, '__init__')),
+                                        Node((relative_namespace, cls.name, fcn.name))))
+                    elif fcn.is_classmethod:
+                        self.edges.add((Node((relative_namespace, cls.name)),
+                                        Node((relative_namespace, cls.name, fcn.name))))
+
+            else:
+                # for the case where there are only classmethods defined
+                for fcn in cls.functions:
+                    self.edges.add((Node((relative_namespace, cls.name)),
+                                    Node((relative_namespace, cls.name, fcn.name))))
+
+    def render(self, name=None):
+        """ Renders the current graph. `Graphviz <http://www.graphviz.org/>`_ must be installed for the graph to be
+            rendered.
+
+        Arguments:
+            name (string): filename to override `self.name`.
+
+        Raises:
+            FilenameNotSpecifiedException: If `FunctionGrapher.name` is not specified.
+        """
+        for node in self.nodes:
+            self.dot_file.node(node.represent)
+        for edge in self.edges:
+            self.dot_file.edge(edge[0].represent, edge[1].represent)
+        if name is None:
+            if not self.name:
+                raise FilenameNotSpecifiedException
+            name = self.name
+        self.dot_file.render(name)

codegrapher/parser.py

@@ -0,0 +1,380 @@
+import ast
+import copy
+import os
+from pprint import pformat
+
+
+class FileObject:
+    """Class for keeping track of files.
+
+    Attributes:
+        modules (dict): dict of current modules with `alias: module_name`, `key:value pairs`.
+        aliases (dict): dict of current modules with `alias: original_name`, `key:value pairs`.
+        node (:mod:`ast.AST`): AST node for entire file.
+        name (string): File name.
+        classes (list): :class:`ClassObject` items defined in the current file.
+        relative_namespace (string): The namespace for the current file,
+            taken from the relative path of the current file
+        ignore (set): Functions to be ignored, as defined in a `.cg_ignore` text file.
+    """
+    def __init__(self, file_name, modules=None, aliases=None):
+        self.modules = copy.deepcopy(modules) if modules else {}
+        self.aliases = copy.deepcopy(aliases) if aliases else {}
+        self.name = file_name
+        self.full_path = os.path.abspath(file_name)
+        with open(self.full_path, 'r') as input_file:
+            self.node = ast.parse(input_file.read(), filename=self.name)
+        self.classes = []
+        self.relative_namespace = os.path.splitext(self.name)[0].replace(os.path.sep, '.')
+        self.ignore = set()
+
+    def visit(self):
+        """Visits all the nodes within the current file AST node.
+
+        Updates `self.classes` for the current instance.
+        """
+        file_visitor = FileVisitor(aliases=self.aliases, modules=self.modules)
+        file_visitor.visit(self.node)
+        self.modules = file_visitor.modules
+        self.aliases = file_visitor.aliases
+        self.classes = file_visitor.classes
+        self.namespace()
+
+    def remove_builtins(self):
+        """Removes builtins from each class in a `FileObject` instance."""
+        for class_object in self.classes:
+            class_object.remove_builtins()
+
+    def add_ignore_file(self):
+        """Use a file `.cg_ignore` to ignore a list of functions from the call graph
+        """
+        if os.path.isfile('.cg_ignore'):
+            with open('.cg_ignore', 'r') as ignore_file:
+                for line in ignore_file:
+                    if line.strip() and line.strip()[0] != '#':
+                        self.ignore.add(line.strip())
+
+    def ignore_functions(self):
+        """Ignore all functions in the current class which are present in the instance's `ignore` attribute.
+        """
+        for class_object in self.classes:
+            class_object.ignore_functions(self.ignore)
+
+    def namespace(self):
+        """Programmatically change the name of items in the call tree so they have relative path information
+        """
+
+        for class_object in self.classes:
+            class_object.namespace(self.relative_namespace)
+
+
+class ClassObject:
+    """Class for keeping track of classes in code.
+
+    Attributes:
+        modules (dict): dict of current modules with `alias: module_name`, `key:value pairs`.
+        aliases (dict): dict of current modules with `alias: original_name`, `key:value pairs`.
+        node (:mod:`ast.AST`): AST node for entire class.
+        name (string): Class name.
+        functions (list): :class:`FunctionObject` items defined in the current class.
+        call_tree (dict): dict with `key:value` pairs `(module, FunctionObject.name): (module, identifier)`.
+
+    """
+    def __init__(self, node=None, aliases=None, modules=None):
+        self.modules = copy.deepcopy(modules) if modules else {}
+        self.aliases = copy.deepcopy(aliases) if aliases else {}
+        self.node = node
+        self.name = node.name if node else ''
+        self.functions = []
+        self.call_tree = {}
+
+    def visit(self):
+        """Visits all the nodes within the current class AST node.
+
+        Updates `self.functions` and `self.call_tree` for the current instance.
+        """
+        function_visitor = FunctionVisitor(aliases=self.aliases, modules=self.modules)
+        function_visitor.visit(self.node)
+        self.functions = function_visitor.functions
+        self.call_tree = dict(((self.name, k), v) for k, v in function_visitor.calls.items())
+
+    def remove_builtins(self):
+        """For many classes, we may not want to include builtin functions in the graph.
+        Remove builtins from the call tree and from called functions list.
+        """
+        self.call_tree = {caller: [call for call in call_list if not self.is_builtin(call[0])]
+            for caller, call_list in self.call_tree.items()}
+
+    def ignore_functions(self, ignore_set):
+        """Ignores all functions matching those specified in a pre-defined ignore set.
+
+         Args:
+            ignore_set (set): Functions whose calls should be removed (ignored) in the class call tree.
+        """
+        new_call_tree = {}
+        for caller, call_list in self.call_tree.items():
+            new_call_list = []
+            for call in call_list:
+                if call[-1] not in ignore_set:
+                    new_call_list.append(call)
+            new_call_tree[caller] = new_call_list
+
+        self.call_tree = new_call_tree
+
+    def namespace(self, relative_namespace):
+        """Take the relative namespace for the class and prepend it to each item defined in the current class.
+
+        Args:
+            relative_namespace (string): Namespace to be prepended to each item in the call tree.
+        """
+        new_call_tree = {}
+        for caller in self.call_tree:
+            new_call_tree[(relative_namespace, caller[0], caller[1])] = self.call_tree[caller]
+        self.call_tree = new_call_tree
+
+    def pprint(self):
+        """Pretty print formatter for class object.
+
+        Returns:
+            string
+        """
+        return pformat(self.call_tree)
+
+    @staticmethod
+    def is_builtin(fn):
+        """Checks if a """
+        if isinstance(fn, str):
+            return fn in __builtins__
+        return False
+
+    def __repr__(self):
+        return "ClassObject {}".format(self.name)
+
+    def __str__(self):
+        functions = [fcn.name for fcn in self.functions]
+        return "Class {}\nDefined functions: {}".format(self.name, functions)
+
+
+class FunctionObject:
+    """Object that stores information within a single function definition
+
+    attributes:
+        modules: dict of current modules with `alias: module_name`, `key:value pairs`.
+        aliases: dict of current modules with `alias: original_name`, `key:value pairs`.
+        node (:mod:`ast.AST`): AST node for entire function.
+        name (string): function name.
+        calls (list): `(module, identifier)` tuples describing items called within current node,
+                      with identifiers decoded form current alias, and modules expanded to their full import paths.
+        decorator_list (list): list of decorators, by name as a string, applied to the current function definition.
+        is_classmethod (bool): True if the current function is designated as a classmethod by a decorator.
+
+    """
+    def __init__(self, node=None, aliases=None, modules=None):
+        self.modules = copy.deepcopy(modules) if modules else {}
+        self.aliases = copy.deepcopy(aliases) if aliases else {}
+        self.node = node
+        self.name = node.name if node else ''
+        self.calls = []
+        self.decorator_list = []
+        self.is_classmethod = False
+
+    @classmethod
+    def _extract_decorators(cls, node):
+        """Pulls out strings for each item in a decorator list on a FunctionDef node
+
+        Args:
+            node (:mod:`ast.AST`): Node from which `decorator_list` will be extracted
+        Returns:
+            (list): List of decorator strings
+        """
+        decorator_list = []
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name):
+                decorator_list.append(decorator.id)
+            elif isinstance(decorator, ast.Attribute):
+                # this catches things like attr.setter
+                decorator_list.append('.'.join([decorator.attr, decorator.value.id]))
+        return decorator_list
+
+    def visit(self):
+        """Visits all the nodes within the current function object's AST node.
+
+        Updates `self.calls`, `self.modules`, and `self.aliases` for the current instance.
+        """
+        visitor = CallVisitor(aliases=self.aliases, modules=self.modules)
+        visitor.visit(self.node)
+        self.decorator_list = FunctionObject._extract_decorators(self.node)
+        if 'classmethod' in self.decorator_list:
+            self.is_classmethod = True
+        self.calls = visitor.calls
+        self.modules.update(visitor.modules)
+        self.aliases.update(visitor.aliases)
+
+
+class CallInspector(ast.NodeVisitor):
+    """Within a call, a Name or Attribute will provide the function name currently in use.
+
+    Identifies `Name` nodes, which are called as ``name(args)``, and `Attribute` nodes, which are called as
+    ``object.attr(args)``
+
+    Attributes:
+        module (string): Current module name on which the current call is made.
+        identifier (string): Name of the function called.
+    """
+    def __init__(self):
+        self.module = ''
+        self.identifier = ''
+
+    def visit_Name(self, node):
+        self.identifier = node.id
+
+    def visit_Attribute(self, node):
+        # todo: pull out item for the attr to determine whether node defines a classmethod
+        # currently does not handle multiple chaining of attr items
+        if hasattr(node.value, 'id'):
+            self.module = node.value.id
+        self.identifier = node.attr
+
+
+class ImportVisitor(ast.NodeVisitor):
+    """For import related calls, store the source modules and aliases used.
+    Designed to be inherited by other classes that need to know about imports in their current scope.
+
+    Attributes:
+        modules (dict): dict of current modules with `alias: module_name`, `key:value pairs`.
+        aliases (dict): dict of current modules with `alias: original_name`, `key:value pairs`.
+    """
+    def __init__(self, aliases=None, modules=None):
+        self.modules = copy.deepcopy(modules) if modules else {}
+        self.aliases = copy.deepcopy(aliases) if aliases else {}
+
+    def continue_parsing(self, node):
+        super(ImportVisitor, self).generic_visit(node)
+
+    def visit_Import(self, node):
+        for item in node.names:
+            asname = item.asname if item.asname else item.name
+            self.aliases[asname] = item.name
+            self.modules[asname] = None
+
+    def visit_ImportFrom(self, node):
+        module = node.module
+        for item in node.names:
+            asname = item.asname if item.asname else item.name
+            self.aliases[asname] = item.name
+            self.modules[asname] = module
+
+
+class CallVisitor(ImportVisitor):
+    """Finds all calls present in the current scope and inspect them.
+
+    Attributes:
+        call_names (set): set of :class:`CallInspector.identifier` items within current AST node.
+        calls (list): `(module, identifier)` items called within current AST node,
+                      with identifiers decoded form current alias, and modules expanded to their full import paths.
+    """
+    def __init__(self, **kwargs):
+        super(CallVisitor, self).__init__(**kwargs)
+        self.call_names = set()
+        self.calls = []
+
+    def continue_parsing(self, node):
+        super(CallVisitor, self).generic_visit(node)
+
+    def visit_Call(self, node):
+        call_visitor = CallInspector()
+        call_visitor.visit(node.func)
+
+        # handles calls within function calls
+        for arg in node.args:
+            self.continue_parsing(arg)
+            if isinstance(arg, ast.Call):
+                arg_visitor = CallVisitor(aliases=self.aliases, modules=self.modules)
+                arg_visitor.visit(arg)
+                self.call_names.update(arg_visitor.call_names)
+                self.calls.extend(arg_visitor.calls)
+
+        self.call_names.add(call_visitor.identifier)
+
+        # if names are aliased, pull out aliased name
+        if call_visitor.identifier in self.aliases:
+            identifier = self.aliases[call_visitor.identifier]
+        else:
+            identifier = call_visitor.identifier
+
+        if call_visitor.module in self.modules:
+            # module is imported and called by attr
+            if self.modules[call_visitor.module]:
+                module = '.'.join([self.modules[call_visitor.module], self.aliases[call_visitor.module]])
+            else:
+                module = self.aliases[call_visitor.module]
+        elif call_visitor.identifier in self.modules:
+            # module is imported, but not called by attr
+            module = self.modules[call_visitor.identifier]
+        else:
+            # no module specified
+            module = None
+
+        if module:
+            call = (module, identifier)
+        else:
+            call = (identifier,)
+
+        self.calls.append(call)
+
+
+class FunctionVisitor(ImportVisitor):
+    """Function definitions are where the function is defined, and the call is where the ast for that function exists.
+
+    This only looks for items that are called within the scope of a function, and associates those items
+    with the function.
+
+    Attributes:
+        defined_functions (set): names of functions found by function visitor instance.
+        functions (list): :class:`FunctionObject` instances found by function visitor instance.
+        calls (dict): mapping from function names defined to calls within that function definition.
+    """
+    def __init__(self, **kwargs):
+        super(FunctionVisitor, self).__init__(**kwargs)
+        self.defined_functions = set()
+        self.functions = []
+        self.calls = {}
+
+    def continue_parsing(self, node):
+        super(FunctionVisitor, self).generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self.defined_functions.add(node.name)
+        function_def = FunctionObject(node=node, aliases=self.aliases, modules=self.modules)
+        function_def.visit()
+        self.calls[function_def.name] = function_def.calls
+        self.functions.append(function_def)
+
+
+class FileVisitor(ImportVisitor):
+    """First visitor that should be called on the file level.
+
+    Attributes:
+        classes (list): list of :class:`ClassObject` instances defined in the current file.
+    """
+    def __init__(self, **kwargs):
+        super(FileVisitor, self).__init__(**kwargs)
+        self.classes = []
+
+    def continue_parsing(self, node):
+        super(FileVisitor, self).generic_visit(node)
+
+    def visit_Module(self, node):
+        self.continue_parsing(node)
+
+    def visit_ClassDef(self, node):
+        # once a class is found, create a class object for it and traverse the ast with its visitor
+        new_class = ClassObject(node=node, aliases=self.aliases, modules=self.modules)
+        new_class.visit()
+        self.classes.append(new_class)
+
+    def remove_builtins(self):
+        """Removes builtins from each class in a `FileVisitor` instance.
+        """
+        for class_object in self.classes:
+            class_object.remove_builtins()

codegrapher-0.3.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: codegrapher
+Version: 0.3.0
+Summary: Code that graphs code
+Project-URL: Homepage, https://github.com/LaurEars/codegrapher
+Project-URL: Repository, https://github.com/LaurEars/codegrapher
+Project-URL: Issues, https://github.com/LaurEars/codegrapher/issues
+Author: Laura Rupprecht
+License: The MIT License (MIT)
+        
+        Copyright (c) 2026 Laura Rupprecht
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+        documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+        persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+        Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+        WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+        COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+        OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Keywords: ast,call-graph,code,documentation,graph,graphviz
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Requires-Dist: click>=7.0
+Requires-Dist: graphviz>=0.4.2
+Provides-Extra: dev
+Requires-Dist: coverage>=5.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/x-rst
+
+codegrapher
+===========
+
+.. image:: https://github.com/LaurEars/codegrapher/actions/workflows/main.yaml/badge.svg
+    :target: https://github.com/LaurEars/codegrapher/actions/workflows/main.yaml
+
+
+Code that graphs code
+---------------------
+Uses the python `AST <https://docs.python.org/3/library/ast.html>`_ to parse Python source code and build a call graph.
+
+
+Output
+------
+An example of the current output of the parser parsing itself.
+
+.. image:: docs/codegrapher.png
+    :target: docs/codegrapher.png
+    :align: center
+    :width: 100 %
+    :alt: parser.py
+
+
+Installation
+------------
+
+.. code:: bash
+
+    pip install codegrapher
+
+
+To generate graphs, `graphviz <http://www.graphviz.org/Download.php>`_ must be installed.
+
+
+Usage
+-----
+
+At the command line
+~~~~~~~~~~~~~~~~~~~
+To parse a file and output results to the console:
+
+.. code:: bash
+
+    codegrapher path/to/file.py --printed
+
+
+To parse a file and output results to a file:
+
+.. code:: bash
+
+    codegrapher path/to/file.py --output output_file_name --output-type png
+
+To analyze a directory of files, along with all files it contains:
+
+.. code:: bash
+
+    codegrapher -r path/to/directory --output multiple_file_analysis
+
+And if you have a list of functions that aren't useful in your graph, add it to a `.cg_ignore` file:
+
+::
+
+    # cg_ignore file
+    # all lines beginning with '#' are ignored
+
+    # every function calls this, so it's not helpful in my graph:
+    log_error
+
+    # I don't want to see this in my graph:
+    parse
+    lower
+
+Then add the `--ignore` flag to your command. Using the flag `--remove-builtins` provides the same functionality
+for ignoring items found in `__builtins__`.
+
+As a Python module
+~~~~~~~~~~~~~~~~~~
+
+To easily parse code in Python :
+
+.. code:: python
+
+    from codegrapher.parser import FileObject
+
+    file_object = FileObject('path/to/file.py')
+    file_object.visit()
+
+And then to add that code to a graph and render it (using graphviz):
+
+.. code:: python
+
+    from codegrapher.graph import FunctionGrapher
+
+    graph = FunctionGrapher()
+    graph.add_file_to_graph(file_object)
+    graph.name = 'name.gv'
+    graph.format = 'png'
+    graph.render()
+
+Which will produce your code as a png file, `name.gv.png`, along with a
+`dot file <http://en.wikipedia.org/wiki/DOT_%28graph_description_language%29>`_ `name.gv`
+
+More documentation for the Python module can be found at
+`Read the Docs <http://codegrapher.readthedocs.org/en/latest/>`_.

codegrapher-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=T4hveAC4W-KBh3GWiedPiINl-iHT1ZhcSxqSE1MEwsw,24
+cli/script.py,sha256=a3SRMouuae1ae6OqZoeNgjmo0xIpH8dhIxNXP6Syzqw,2216
+codegrapher/__init__.py,sha256=3wVEs2QD_7OcTlD97cZdCeizd2hUbJJ0GeIO8wQIjrk,22
+codegrapher/graph.py,sha256=Teacm7Hd6w43nM9wiIMaJUJcL_0mZuXHHsoN6aXYoTg,7095
+codegrapher/parser.py,sha256=sjqfXp2H216mP-3W4liIANyvRFDyUe_mfUv8deyEy1E,15052
+codegrapher-0.3.0.dist-info/METADATA,sha256=JPi5u8DMmxMzL-jdW60FWWQ5J4uwMvfETZcIIohYp9k,4872
+codegrapher-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+codegrapher-0.3.0.dist-info/entry_points.txt,sha256=6SlRVjRRDdv0haGsEyWaY9XbORuQzNim3VE0_pVlJE0,40
+codegrapher-0.3.0.dist-info/licenses/LICENSE,sha256=6bfha4F6flqIqyfRSvW-0aXHFDPaMhERmkLBVLTLQiM,1081
+codegrapher-0.3.0.dist-info/RECORD,,

codegrapher-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codegrapher-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codegrapher = cli:cli

codegrapher-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,16 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Laura Rupprecht
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.