It's a toolkit for modularizing codebases, helping define module boundaries, generating dependency graphs, and conducting impact analysis. It supports easy setup, is fast, open source, and enforces strict module interfaces. It's designed for understanding architecture, finding cycles, and documenting designs.
Features
Easy Setup
Define module boundaries interactively in your terminal to preserve clean architecture.
Fast Analysis
Built with Rust for fast static analysis of codebases.
Open Source
Permissively licensed (MIT) for flexibility and community engagement.
Powerful Enforcements
Enforce a public interface for each module with strict mode.
Dependency Graph
Visualizes dependencies between modules to identify cycles and tight coupling.
Team Collaboration
Allows teams to discuss high-level design and share dependency insights.
Impact Analysis
Determines which files are impacted by changes to speed up CI pipelines.
Accurate Testing
Rerun tests only for the module if anything within it has changed.
Reliable Module Detection
Uses static analysis to determine module usage.
Fine-Grained Caching
Caches results accurately based on source files and environment.
Pare SDK & CLI
Managed platform for Pare endpoints allowing users to handle functions serverlessly.
Atomic Deploys
Deploys functions efficiently as a part of production use-case solutions.
Environment Variables
Use environment variables to manage different configurations effortlessly.
Dependency Discovery
Utilizes 'tach' to discover and list external dependencies in your Python project, allowing for a better alignment between used and declared dependencies.
Dependency Report
Employs the 'tach report-external' command to surface external dependencies and generate a summary in PEP 508 format.
Type Checking Imports
Allows the user to configure the 'ignore_type_checking' option in 'tach' to include type checking imports in the dependency list.
Dependency Validation
Uses 'tach check-external' to validate that the external dependencies in your source code match the ones declared in your project configuration, ensuring no bloat or missing dependencies.
Lazy AST Parsing
Moves C-dependent AST parsing to Rust, delaying conversion until necessary. This reduces malloc calls and garbage collection cycles, enhancing speed.
AST Query Engine
Utilizes a combination of Python and Rust extensions for efficient AST handling, allowing lazily generated binary representations.
Module Isolation
Allows you to isolate Python modules to create separate dependencies, enabling you to move modules into microservices or deprecate them.
Boundary Configuration
Enables setting boundaries of the Python source folder and module to isolate using a YAML configuration file.
Dependency Sync
Synchronizes existing dependencies using the 'tach sync' command to ensure all dependencies are captured in the module.
Resolvable Dependencies Check
Checks and displays unresolved dependencies of a module, giving options to include them in configuration or refactor the code to remove them.
Full Isolation
Enforces complete isolation of a module by ensuring all dependencies are either included or flagged, verifying through 'tach check'.
CI Integration
Integrates with CI/CD pipelines to ensure no additional dependencies are accidentally introduced, safeguarding the isolation of modules.
Test Impact Analysis (TIA)
Identifies only the tests needed to run based on code changes, reducing CI duration by not executing unnecessary tests.
Set Up Module Boundaries
Defines boundaries within which tests are relevant, minimizing the scope of testing when changes occur.
Reduced Test Execution
Runs only tests impacted by recent changes, speeding up the CI process significantly.
Tach Integration
Integrates Tach tool to automatically check module boundaries and determine necessary tests.
Tach Installation
Allows you to install Tach using the command `pip install tach`. This is a necessary step to get started with visualizing dependencies.
Module Boundary Definition
Use the command `tach mod` to define modules within your project. This involves marking directories and files as modules using keyboard shortcuts.
Sync Dependencies
Run `tach sync` to have Tach crawl the Python AST and figure out the module imports, ensuring that dependencies are accurately captured.
Dependency Visualization
Use the command `tach --web` to generate a URL for viewing the dependency graph. You can also view a local version using GraphViz with `tach show`.