digdep 0.0.3__py3-none-any.whl

digdep/__init__.py

@@ -0,0 +1,12 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+"""
+
+from .analyzer import DepAnalyzer, DepType
+from ._version import __version__
+
+

digdep/_version.py

@@ -0,0 +1,13 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+DigDep version
+"""
+
+__version__ = "0.0.3"
+
+

digdep/analyzer.py

@@ -0,0 +1,228 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+Core dependency analyzer
+"""
+
+import ast
+from pathlib import Path
+from rich.console import Console
+from enum import Flag, auto
+import sys
+from .visitors import DependencyVisitor
+from .utils import walkpath
+
+
+class DepType(Flag):
+    NONE = 0
+    STDLIB = auto()
+    THIRD_PARTY = auto()
+    LOCAL = auto()
+    UNKNOWN = auto()
+    ALL = STDLIB | THIRD_PARTY | LOCAL
+
+
+class DepAnalyzer:
+
+    def __init__(self, is_ascii: bool = False) -> None:
+        self._root: Path = None
+        self._filedep_tree = {}
+        self._depfile_tree = {}
+        self._dep_type_map: dict[str, DepType] = {}
+        self._ignorelist: set[str] = set()
+        self._path_dep_map: dict[Path, set[str]] = {}
+        self._is_ascii: bool = is_ascii
+        self._tree_prefix_char = (
+            "├──" if not self._is_ascii else "|__"
+        )
+        self._console = Console()
+
+    def ignore(self, ignorelist: list[str]) -> None:
+        """Adds files/directories to ignorelist"""
+        self._ignorelist = set(ignorelist)
+
+    def _get_file_deps(self, fpath: str) -> list[str]:
+        """Get dependencies in a file"""
+        try:
+            with open(fpath, "r", encoding="utf-8") as fh:
+                source = fh.read()
+                tree = ast.parse(source)
+                visitor = DependencyVisitor()
+                visitor.visit(tree)
+                return visitor.packages
+        except Exception as ex:
+            print(
+                (
+                    f"Failed to read: {fpath}\n"
+                    f"{ex.__class__.__name__} - {str(ex)}"
+                )
+            )
+        return []
+
+    def _get_deptype(self, dep: str) -> DepType:
+        """Get the dependency type"""
+        if dep in sys.stdlib_module_names:
+            return DepType.STDLIB
+        return DepType.THIRD_PARTY
+
+    def _update_deptype_map(self, deps: set[str]) -> None:
+        """Update dependency in dependency-type mapping"""
+        new_deps = deps.difference(self._dep_type_map.keys())
+        self._dep_type_map.update({
+            dep: self._get_deptype(dep) for dep in new_deps
+        })
+
+    def _reset_vars(self) -> None:
+        """Resets variables"""
+        self._filedep_tree = {}
+        self._depfile_tree = {}
+        self._dep_type_map = {}
+        self._path_dep_map = {}
+
+    def scan(self, root: str = ".") -> None:
+        """Scans a python file(s) in a directory/sub-directory"""
+        self._reset_vars()
+        self._root = Path(root)
+        for path in walkpath(root, self._ignorelist):
+            deps = self._get_file_deps(str(path.resolve()))
+            deps = set(deps) if deps else set()
+            relpath =  path.relative_to(self._root)
+            self._path_dep_map[relpath] = deps
+            self._update_deptype_map(deps)
+
+    def get_packages(self, filters: DepType = DepType.ALL) -> tuple[str]:
+        deps = self._get_filtered_deps(filters) 
+        return tuple(deps)
+
+    def show_packages(self, filters: DepType = DepType.ALL) -> None:
+        print("\n".join(dep for dep in self.get_packages(filters)))
+
+    def _tree_prefix(self, indent: int = 0) -> str:
+        """Generates tree prefix with indentation"""
+        spaces = " " * indent
+        return f"{spaces}{self._tree_prefix_char}"
+
+    def _vertical_spacer(self, indent: int = 0) -> str:
+        """Generates a vertical spacer"""
+        spaces = " " * indent
+        return f"{spaces}|"
+
+    def _print(self, text: str) -> None:
+        """Coloured print"""
+        self._console.print(text)
+
+    def _gen_filedeps_tree(self) -> None:
+        """Generate file dependency tree"""
+        if self._filedep_tree:
+            return self._filedep_tree
+        self._filedep_tree = {"files": []}
+        for path, deps in self._path_dep_map.items():
+            dirparts = path.parent.parts
+            branch = self._filedep_tree
+            for part in dirparts:
+                branch = branch.setdefault(part, {"files": []})
+            branch["files"].append((path.name, deps))
+
+    def _gen_depfiles_tree(self) -> None:
+        """Generate dependency file tree"""
+        if self._depfile_tree:
+            return self._depfile_tree
+        self._depfile_tree = {}
+        for path, deps in self._path_dep_map.items():
+            dirparts = path.parent.parts
+            for dep in deps:
+                branch = self._depfile_tree.setdefault(dep, {"files": []})
+                for part in dirparts:
+                    branch = branch.setdefault(part, {"files": []})
+                branch["files"].append(path.name)
+
+    def _get_filtered_deps(self, filters: DepType) -> set[str]:
+        """Filter dependencies by type"""
+        return {
+            dep
+            for dep, deptype in self._dep_type_map.items()
+            if filters & deptype
+        }
+
+    def get_filedep_tree(self, filters: DepType = DepType.ALL) -> dict:
+        """Get the file-dependency tree"""
+        self._gen_filedeps_tree()
+        return self._filedep_tree
+
+    def file_dependency_tree(self, filters: DepType = DepType.ALL) -> None:
+        """Show file and dependencies"""
+        self._gen_filedeps_tree()
+        relevant_deps = (
+            self._get_filtered_deps(filters) if filters else set()
+        )
+        def showdep(branch: dict, indent=0):
+            files = branch.get("files", [])
+            tree_prefix = self._tree_prefix(indent)
+            maxwidth = (
+                max(len(file) for file, _ in files) if files else 0
+            )
+            for file, deps in files:
+                deps = deps.intersection(relevant_deps)
+                deps = ", ".join(sorted(deps))
+                deps = f" → [bold cyan]{deps}[/bold cyan]" if deps else ""
+                self._print(f"{tree_prefix} {file:<{maxwidth}}{deps}")
+
+            dirs = {k:v for k,v in branch.items() if isinstance(v, dict)}
+            for _dir, val in dirs.items():
+                print(self._vertical_spacer(indent))
+                self._print(f"{tree_prefix} [blue]{_dir}[/blue]/")
+                showdep(val, indent + 4)
+
+        self._print(f"[bold magenta]Root ({self._root})[/bold magenta]")
+        showdep(self._filedep_tree)
+
+    def get_depfile_tree(self, filters: DepType = DepType.ALL) -> dict:
+        """Get the dependency-file tree"""
+        self._gen_depfiles_tree()
+        return self._depfile_tree
+
+    def dependency_file_tree(self, filters: DepType = DepType.ALL) -> None:
+        """Show dependency and files"""
+        self._gen_depfiles_tree()
+        relevant_deps = (
+            self._get_filtered_deps(filters) if filters else set()
+        )
+        def showfiles(branch: dict, indent=0):
+            files = branch.get("files", [])
+            tree_prefix = self._tree_prefix(indent)
+            for file in files:
+                print(f"{tree_prefix} {file}")
+
+            dirs = {k:v for k,v in branch.items() if isinstance(v, dict)}
+            for _dir, val in dirs.items():
+                print(self._vertical_spacer(indent))
+                self._print(f"{tree_prefix} [blue]{_dir}[/blue]/")
+                showfiles(val, indent + 4)
+
+        filtered_deps = (
+            set(self._depfile_tree.keys()).intersection(relevant_deps)
+        )
+        for dep in filtered_deps:
+            deptree = self._depfile_tree.get(dep)
+            self._print(f"[bold cyan]{dep}[/bold cyan]")
+            showfiles(deptree)
+            print("\n")
+
+
+if __name__ == "__main__":
+    pass
+
+    
+
+
+
+
+        
+
+
+
+

digdep/analyzer_bak.py

@@ -0,0 +1,231 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+Core dependency analyzer
+"""
+
+import ast
+from visitors import DependencyVisitor
+from utils import walkpath
+from pathlib import Path
+import os
+from rich.console import Console
+
+
+class DepAnalyzer:
+
+    def __init__(self) -> None:
+        self._path: Path = None
+        self._packages: set[str] = set()
+        self._ignorelist: set[str] = set()
+        self._path_dep_map: dict[str, set[str]] = {}
+        self._dep_path_map: dict[str, list[str]] = {}
+        self._root: str = ""
+        self.filedep_tree = {"files": []}
+        self._console = Console()
+
+    def ignore(self, ignorelist: list[str]) -> None:
+        """Adds files/directories to ignorelist"""
+        self._ignorelist.set(ignorelist)
+        self._ignorelist = set(ignorelist)
+
+    def _get_file_deps(self, fpath: str) -> list[str]:
+        """Get dependencies in a file"""
+        with open(fpath, "r", encoding="utf-8") as fh:
+            source = fh.read()
+            tree = ast.parse(source)
+            visitor = DependencyVisitor()
+            visitor.visit(tree)
+            return visitor.packages
+
+    def _get_relative_path(self, path: str):
+        path = Path(path)
+        return path.relative_to(self._root)
+
+    def scan(self, root: str = ".") -> None:
+        """Scans a python file(s) in a directory/sub-directory"""
+        self._root = Path(root)
+        for path in walkpath(root, self._ignorelist):
+            packages = self._get_file_deps(path)
+            packages = set(packages)
+            self._path_dep_map[path] = packages
+            for pkg in packages:
+                self._dep_path_map.setdefault(pkg, []).append(path)
+            self._packages.update(packages)
+        self._gen_filedeps_tree()
+        self._gen_depfiles_tree()
+
+    @property
+    def packages(self):
+        return self._packages
+
+    def show_packages(self):
+        print("\n".join(self._packages))
+
+    def _tree_prefix(self, indent: int = 0) -> str:
+        """Generates tree prefix with indentation"""
+        spaces = " " * indent
+        #return f"{spaces}|__"
+        return f"{spaces}├──"
+
+    def _vertical_spacer(self, indent: int = 0) -> str:
+        """Generates a vertical spacer"""
+        spaces = " " * indent
+        return f"{spaces}|"
+
+    #def show_filedeps(self) -> str:
+    #    """Shows file and dependencies"""
+    #    grouped_dirs_and_deps = {}
+    #    for path, deps in self._path_dep_map.items():
+    #        dirname = os.path.dirname(path)
+    #        basename = os.path.basename(path)
+    #        grouped_dirs_and_deps.setdefault(
+    #            dirname, []
+    #        ).append((basename, deps))
+
+    #    print(f"Root ({self._root})")
+    #    for dirname, deplist in grouped_dirs_and_deps.items():
+    #        indent = 0
+    #        print(self._vertical_spacer())
+    #        relpath = Path(dirname).relative_to(self._root)
+    #        parts = relpath.parts
+    #        if parts:
+    #            for part in parts:
+    #                tree_prefix = self._tree_prefix(indent)
+    #                print(f"{tree_prefix} {part}/")
+    #                indent += 4
+
+    #        max_filewitdh = max(len(file) for file, _ in deplist)
+    #        for file, deps in deplist:
+    #            deps = sorted(deps) if deps else ""
+    #            deps = str(deps)[1:-1].replace("'", "")
+    #            deps = f" -> {deps}" if deps else ""
+    #            tree_prefix = self._tree_prefix(indent)
+    #            print(f"{tree_prefix} {file:<{max_filewitdh}} {deps}")
+
+    def _print(self, text: str) -> None:
+        """Coloured print"""
+        self._console.print(text)
+
+    def _gen_filedeps_tree(self) -> None:
+        """Generate file dependency tree"""
+        self.filedep_tree = {"files": []}
+        for path, deps in self._path_dep_map.items():
+            dirname = os.path.dirname(path)
+            basename = os.path.basename(path)
+            relpath = Path(dirname).relative_to(self._root)
+            dirparts = relpath.parts
+            branch = self.filedep_tree
+            for part in dirparts:
+                branch = branch.setdefault(part, {"files": []})
+            branch["files"].append((basename, deps))
+
+    def _gen_depfiles_tree(self) -> None:
+        """Generate dependency file tree"""
+        self._depfile_tree = {}
+        for path, deps in self._path_dep_map.items():
+            dirname = os.path.dirname(path)
+            basename = os.path.basename(path)
+            relpath = Path(dirname).relative_to(self._root)
+            dirparts = relpath.parts
+            for dep in deps:
+                branch = self._depfile_tree.setdefault(dep, {"files": []})
+                for part in dirparts:
+                    branch = branch.setdefault(part, {"files": []})
+                branch["files"].append(basename)
+
+    def show_filedeps(self):
+        """Show file and dependencies"""
+        def showdep(branch: dict, indent=0):
+            files = branch.get("files", [])
+            tree_prefix = self._tree_prefix(indent)
+            max_filewitdh = (
+                max(len(file) for file, _ in files) if files else 0
+            )
+            for file, deps in files:
+                deps = sorted(deps) if deps else ""
+                deps = str(deps)[1:-1].replace("'", "")
+                deps = f" → [bold cyan]{deps}[/bold cyan]" if deps else ""
+                self._print(f"{tree_prefix} {file:<{max_filewitdh}}{deps}")
+
+            dirs = {k:v for k,v in branch.items() if isinstance(v, dict)}
+            for _dir, val in dirs.items():
+                print(self._vertical_spacer(indent))
+                self._print(f"{tree_prefix} [blue]{_dir}[/blue]/")
+                showdep(val, indent + 4)
+
+        self._print(f"[bold magenta]Root ({self._root})[/bold magenta]")
+        showdep(self.filedep_tree)
+
+    def show_depfiles(self):
+        """Show dependency and files"""
+        def showfiles(branch: dict, indent=0):
+            files = branch.get("files", [])
+            tree_prefix = self._tree_prefix(indent)
+            for file in files:
+                print(f"{tree_prefix} {file}")
+
+            dirs = {k:v for k,v in branch.items() if isinstance(v, dict)}
+            for _dir, val in dirs.items():
+                print(self._vertical_spacer(indent))
+                self._print(f"{tree_prefix} [blue]{_dir}[/blue]/")
+                showfiles(val, indent + 4)
+
+        for dep, tree in self._depfile_tree.items():
+            self._print(f"[bold cyan]{dep}[/bold cyan]")
+            showfiles(tree)
+            print("\n")
+
+    #def show_depfiles(self) -> str:
+    #    def dirparts(path):
+    #        dirname = os.path.dirname(path)
+
+
+    #    for package, paths in self._dep_path_map.items():
+    #        print(f"{package} ({len(paths)} files)")
+    #        #fmtstr = (" " * 5) + "|" + ("_" * 5)
+    #        tree_prefix = self._tree_prefix()
+    #        sorted_paths = [
+    #            Path(path).relative_to(self._root)
+    #            for path in paths
+    #        ]
+    #        #sorted_paths.sort(key=lamdba p: len(p.parts))
+    #        for path in sorted_paths:
+    #            dirparts(path)
+
+    #            #path = Path(path).relative_to(self._root)
+    #            print(f"{tree_prefix} {path}")
+    #        print("\n")
+
+
+
+
+
+if __name__ == "__main__":
+    dp = DepAnalyzer()
+    dp.scan(r"C:\users\shine\pyprojs\insta-likecom-bot\modules")
+    from pprint import pprint
+    #pprint(dp.packages, width=120)
+    #dp.show_depmap()
+    #dp.show_filedeps()
+    #dp.create_filedeps()
+    #dp.show_filedeps1()
+    #dp.show_depfiles()
+    #dp.show_depfiles()
+    dp.show_filedeps()
+    #dp.show_packages()
+
+    
+
+
+
+
+        
+
+
+
+

digdep/argparsing.py

@@ -0,0 +1,99 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+Argument Parsing for DigDep CLI
+"""
+
+import argparse
+from ._version import __version__
+
+
+DESCRIPTION = "Scan Python projects and inspect import dependencies."
+EXAMPLES = """
+Examples:
+  digdep packages ./myproject
+  digdep file-tree ./myproject
+  digdep dep-tree ./myproject
+
+Ignore directories:
+  digdep file-tree ./myproject --ignore venv __pycache__ tests
+
+Redirect output:
+  digdep dep-tree ./myproject > dependencies.txt
+"""
+
+def add_common_args(parser: argparse.ArgumentParser) -> None:
+    """Add arguments to subparser"""
+    parser.add_argument(
+        "path",
+        help="Path to the Python project.",
+    )
+    parser.add_argument(
+        "-i",
+        "--ignore",
+        nargs="*",
+        default=[],
+        metavar="NAME",
+        help="Directories or files to ignore.",
+    )
+    parser.add_argument(
+        "--type",
+        "-t",
+        default="all",
+        metavar="TYPES",
+        help=(
+            "Comma-separated dependency types (stdlib, third-party, "
+            "local, all). Defaults to 'all'."
+        )
+    )
+
+
+parser = argparse.ArgumentParser(
+    prog="digdep",
+    description=DESCRIPTION,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    epilog=EXAMPLES
+)
+
+parser.add_argument(
+    "-v",
+    "--version",
+    action="version",
+    version=f"%(prog)s {__version__}",
+)
+
+subparsers = parser.add_subparsers(
+    title="Commands",
+    dest="command",
+    required=True,
+)
+packages = subparsers.add_parser(
+    "packages",
+    help = "List imported packages."
+)
+add_common_args(packages)
+
+file_tree = subparsers.add_parser(
+    "file-tree",
+    help="Show the file -> dependency tree."
+)
+add_common_args(file_tree)
+
+dep_tree = subparsers.add_parser(
+    "dep-tree",
+    help="Show the dependency -> file tree."
+)
+add_common_args(dep_tree)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse arguments"""
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    pass

digdep/cli.py

@@ -0,0 +1,56 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+DigDep CLI 
+"""
+
+import sys
+from .argparsing import parse_args
+from .analyzer import DepAnalyzer, DepType
+
+
+ARG_DEPTYPE_MAP = {
+    "stdlib": DepType.STDLIB,
+    "third-party": DepType.THIRD_PARTY,
+    "local": DepType.LOCAL,
+    "all": DepType.ALL,
+}
+
+
+def main(is_ascii: bool = False):
+
+    args = parse_args()
+
+    depanalyzer = DepAnalyzer(is_ascii=is_ascii)
+    depanalyzer.ignore(args.ignore)
+    depanalyzer.scan(args.path)
+
+    arg_deptypes = args.type.split(",")
+    invalid_types = set(arg_deptypes).difference(ARG_DEPTYPE_MAP.keys())
+    if invalid_types:
+        invalid_types = ", ".join(invalid_types)
+        print(f"Error: Invalid dependency type - {invalid_types}")
+        sys.exit(1)
+
+    filters = DepType.NONE
+    for deptype in invalid_types:
+        filters |= ARG_DEPTYPE_MAP.get(deptype.strip(), DepType.NONE)
+    filters = DepType.ALL if filters == DepType.NONE else filters
+
+    if args.command == "packages":
+        depanalyzer.show_packages(filters=filters)
+    elif args.command == "file-tree":
+        depanalyzer.file_dependency_tree(filters=filters)
+    elif args.command == "dep-tree":
+        depanalyzer.dependency_file_tree(filters=filters)
+
+
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")
+    is_ascii = False if sys.stdout.isatty() else True
+    main(is_ascii)
+

digdep/utils.py

@@ -0,0 +1,37 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+Utility methods
+"""
+
+from pathlib import Path
+from collections.abc import Iterator
+
+
+def walkpath(root: str | Path, ignorelist: set[str]) -> Iterator[Path]:
+    """Get .py files from directories and sub-directories"""
+    if not isinstance(root, Path):
+        root = Path(root)
+    if not root.exists():
+        raise Exception("File/Directory doesn't exist")
+
+    if root.is_file():
+        return root
+
+    for path in root.iterdir():
+        if path.name in ignorelist:
+            continue
+        if path.is_dir():
+            yield from walkpath(path, ignorelist)
+
+        elif path.suffix == ".py":
+            yield path
+
+
+if __name__ == "__main__":
+    pass
+

digdep/visitors.py

@@ -0,0 +1,36 @@
+"""
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+
+AST Visitors for dependency analysis
+"""
+
+import ast
+
+
+class DependencyVisitor(ast.NodeVisitor):
+
+    def __init__(self):
+        self._packages = []
+
+    @property
+    def packages(self):
+        return self._packages
+
+    def visit_Import(self, node):
+        self._packages.extend([
+            alias.name.split(".", 1)[0] for alias in node.names
+        ])
+        
+    def visit_ImportFrom(self, node):
+        if node.level == 0:
+            self._packages.append(node.module.split(".")[0])
+
+
+if __name__ == "__main__":
+    pass
+
+

digdep-0.0.3.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: digdep
+Version: 0.0.3
+Summary: Analyze Python import dependencies.
+Author: Shine Jayakumar
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/shine-jayakumar/digdep
+Project-URL: Repository, https://github.com/shine-jayakumar/digdep
+Project-URL: Issues, https://github.com/shine-jayakumar/digdep/issues
+Keywords: python,dependency,dependencies,import,imports,dependency-analyzer,static-analysis,code-analysis,ast,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=14.0.0
+Dynamic: license-file
+
+# DigDep
+
+![Version](https://img.shields.io/static/v1?label=version&message=v.0.0.3&color=blue)
+![License](https://img.shields.io/static/v1?label=license&message=MIT&color=green)
+![Status](https://img.shields.io/badge/status-alpha-yellow.svg)
+![Open Source](https://img.shields.io/static/v1?label=OpenSource&message=Yes&color=brightgreen)
+![GitHub issues](https://img.shields.io/github/issues/shine-jayakumar/docdsl)
+![Last Commit](https://img.shields.io/github/last-commit/shine-jayakumar/docdsl)
+
+A lightweight Python dependency analyzer that scans Python projects and visualizes import relationships.
+
+---
+
+## Installation
+
+```bash
+pip install digdep
+```
+---
+
+## Quick Start (CLI)
+
+List all imported packages:
+
+```bash
+digdep packages ./myproject
+```
+
+Show the File → Dependency tree:
+
+```bash
+digdep file-tree ./myproject
+```
+
+Show the Dependency → File tree:
+
+```bash
+digdep dep-tree ./myproject
+```
+
+---
+
+## Sample Output
+
+### File → Dependency Tree
+
+```text
+Root (/projects/example)
+
+├── main.py              → requests, pathlib
+├── config.py            → json
+│
+├── modules/
+│   ├── logger.py        → logging
+│   ├── parser.py        → re, typing
+│
+└── utils/
+    └── helpers.py       → functools
+```
+
+### Dependency → File Tree
+
+```text
+requests
+├── main.py
+
+re
+├── modules/
+│   └── parser.py
+
+logging
+├── modules/
+│   └── logger.py
+```
+
+---
+
+## Filtering
+
+Filter dependencies by type.
+
+Show only standard library imports:
+
+```bash
+digdep file-tree ./myproject --type stdlib
+```
+
+Show both standard library and third-party imports:
+
+```bash
+digdep file-tree ./myproject --type stdlib,third-party
+```
+
+Show only local imports:
+
+```bash
+digdep file-tree ./myproject --type local
+```
+
+---
+
+## Ignoring Files and Directories
+
+Skip directories or files while scanning:
+
+```bash
+digdep file-tree ./myproject --ignore venv __pycache__ tests
+```
+
+---
+
+## Redirecting Output
+
+Save the generated tree to a file:
+
+```bash
+digdep dep-tree ./myproject > dependencies.txt
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `packages` | List all imported packages |
+| `file-tree` | Show the File → Dependency tree |
+| `dep-tree` | Show the Dependency → File tree |
+
+Run `digdep <command> --help` for command-specific options.
+
+---
+
+## Using as a Python Library
+
+```python
+from digdep import DepAnalyzer, DepType
+
+analyzer = DepAnalyzer()
+
+# Ignoring directories
+analyzer.ignore([
+    "__pycache__",
+    "venv",
+    "build",
+    "tests"
+])
+
+analyzer.scan("./myproject")
+
+# List imported packages
+packages = analyzer.get_packages()
+
+# Get the File -> Dependency tree
+filedep_tree = analyzer.get_filedep_tree()
+
+# Get the Dependency -> File tree
+depfile_tree = analyzer.get_depfile_tree()
+
+```
+
+Filter dependencies by type:
+
+```python
+from digdep import DepAnalyzer, DepType
+
+analyzer = DepAnalyzer()
+analyzer.scan("./myproject")
+
+# Show only standard library imports
+filedep_tree = analyzer.get_filedep_tree(
+    filters=DepType.STDLIB
+)
+
+# Show standard library and third-party imports
+depfile_tree = analyzer.get_depfile_tree(
+    filters=DepType.STDLIB | DepType.THIRD_PARTY
+)
+```
+
+---
+## Roadmap
+
+- Local module detection
+- Dependency statistics
+- JSON export
+- Circular dependency detection
+- Unused dependency detection
+
+---
+
+## Requirements
+
+- Python 3.11+
+
+---
+
+## License
+
+Released under the MIT License.
+
+---

digdep-0.0.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+digdep/__init__.py,sha256=IrfTBnv2zH46vb4QyvU5fS3SDt0fIc1Ga0ISp-LEqqs,265
+digdep/_version.py,sha256=79MJWhXNnaJw5cNtr92jjRu70eZ4XQg5EaOpzH_LZIw,227
+digdep/analyzer.py,sha256=y2mb_4JEu483Rc6tMXIZN6PBbmZEfHvGCVBhwFTHzeA,7841
+digdep/analyzer_bak.py,sha256=FhEOrY88-aTRr7DIMAIx2TuFg-OSV0TVkuXYW5Med1w,8045
+digdep/argparsing.py,sha256=6Rp9N2HV2kdP2GEDSIceVXOOENBk4hC7tsos5wu1SMY,2197
+digdep/cli.py,sha256=npqPAmq3XZ0Td7PlrXDDWKuK7kwFHyvnH7vqdGBAryU,1553
+digdep/utils.py,sha256=87At93jcWathtkyHpoY40Ikz4QQ67SZEG6k8jLU_Buk,876
+digdep/visitors.py,sha256=38p-WAy_gJSMwmHQbkEXde2neCOk36oYifr-1i2R51I,743
+digdep-0.0.3.dist-info/licenses/LICENSE,sha256=1Yd7r-jQ0rtrPD3-VSKbnz4g_0W-BqAk61f4pyyE3mk,1093
+digdep-0.0.3.dist-info/METADATA,sha256=LRlvYcf0Uj7g51TedYH0yrRFv6Di8fMbhwqLztskM5M,4776
+digdep-0.0.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+digdep-0.0.3.dist-info/entry_points.txt,sha256=eVui0hJOlqguQoi33AWWgEV_oJHu3x9K9PnYtz8YnT4,43
+digdep-0.0.3.dist-info/top_level.txt,sha256=peD93GMI23bK_4WyaaxRCynAfGaJnWBj6pWhQfVa9tw,7
+digdep-0.0.3.dist-info/RECORD,,

digdep-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

digdep-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+digdep = digdep.cli:main

digdep-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shine Jayakumar
+
+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.

digdep-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+digdep