What Are the Dependencies of the Main LoopX Files?

LoopX operates with zero runtime dependencies, requiring only the Python standard library to function, while optional testing tools are isolated in the test extra group.

Understanding the dependency footprint of a control-plane framework is critical for deployment planning. The LoopX project (huangruiteng/loopx) maintains a strict stdlib-only policy for its core runtime according to its source configuration, making it suitable for constrained environments where minimizing external packages is essential.

Examining the Project Configuration

The definitive source for LoopX dependency information resides in pyproject.toml at the repository root. Here, the project metadata explicitly declares an empty dependency array for runtime requirements.

In pyproject.toml, the configuration shows:

[project]
dependencies = []          # ← no packages required at runtime

This empty list confirms that pip install loopx will not pull in any external wheels or transitive dependencies when deploying LoopX in production.

Core Module Dependencies

A review of the main source files confirms the stdlib-only implementation. None of the primary modules import third-party libraries, ensuring consistent behavior across Python environments without version conflicts.

loopx/init.py

The package entry point exposes the public API through pure Python constructs. As implemented in loopx/__init__.py, the initialization logic relies exclusively on standard library modules, avoiding external framework dependencies that could complicate integration.

loopx/entrypoint.py

The console script implementation in loopx/entrypoint.py handles CLI invocation using only built-in Python functionality. This module powers the loopx command-line interface without requiring packages like Click, Typer, or argparse extensions.

# After installation

loopx --help

loopx/extensions/manifest.py

Extension metadata registration in loopx/extensions/manifest.py continues the stdlib pattern. The manifest system uses entry points and internal utilities rather than pulling in schema validation libraries or configuration parsers from PyPI.

Optional Development Dependencies

While the runtime requires no external packages, the project defines optional dependencies under the test extra for development workflows. These tools support the test suite, coverage reporting, and static analysis but remain uninstalled during standard production deployments.

The test extra includes:

• jsonschema (>=4.23,<5) — JSON Schema validation for test fixtures
• pytest (>=8,<9) — Test runner framework
• pytest-cov (>=5,<7) — Coverage reporting plugin
• pytest-xdist (>=3,<4) — Parallel test execution
• ruff (>=0.12,<0.16) — Python linter and formatter
• mypy (>=1.18,<2) — Static type checker

Install these only when contributing to LoopX development:

pip install "loopx[test]"

Production Installation Scenarios

Deploying LoopX requires no dependency resolution overhead. The standard installation pulls only the package source:

pip install loopx

This command installs LoopX without triggering downloads of numpy, requests, or other common framework dependencies. The lightweight footprint makes LoopX suitable for embedding in larger systems where dependency trees must remain shallow, or for environments with restricted internet access where PyPI packages cannot be fetched.

Summary

LoopX maintains a zero-dependency runtime architecture according to the huangruiteng/loopx source code:

• No runtime dependencies: The dependencies array in pyproject.toml remains empty
• Stdlib-only core: Key files including loopx/__init__.py, loopx/entrypoint.py, and loopx/extensions/manifest.py import no third-party modules
• Optional test extras: Development tools (pytest, mypy, ruff) install only via pip install "loopx[test]"
• Python 3.11+ required: The sole prerequisite is the Python interpreter version

Frequently Asked Questions

Does LoopX require any third-party packages to run?

No. LoopX requires only Python 3.11 or higher and the standard library. The pyproject.toml explicitly declares dependencies = [], ensuring clean installations without external wheels.

What packages are included in the test extra?

The test extra includes jsonschema>=4.23,<5, pytest>=8,<9, pytest-cov>=5,<7, pytest-xdist>=3,<4, ruff>=0.12,<0.16, and mypy>=1.18,<2. These support development workflows but remain optional for production deployments.

How do I install LoopX without development dependencies?

Run pip install loopx without brackets or extras. This command installs only the core package, as the main codebase in loopx/entrypoint.py and related modules uses only standard library imports.

Which Python versions are compatible with LoopX?

LoopX targets Python 3.11 and newer versions. The codebase leverages modern standard library features available from Python 3.11 onward while maintaining zero external dependencies.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}