Guides
This overview collects all imported guides for ManifestGuard Python and serves as navigation for this section.
Prerequisites
Python 3.10+, pip, and the same interpreter locally and in CI.
ManifestGuard should see the same project on your machine and in CI. That is mostly a Python and packaging baseline, not a new platform.
License
Community is free. Pro is the paid plan: 2 device activations, annual updates.
Start free. Buy Pro when you need deeper analysis and CI evidence. The product page lists the plans you can purchase today.
First steps
Install, run one check, read the report, then tighten the gate.
One command should already show packaging, import, and dependency issues. Fix blockers first; turn on deeper analysis when the baseline is quiet.
Installation
Community from PyPI. Pro activates locally and updates itself.
Keep one CLI on Python 3.12. Point it at the project with --project-python instead of installing a second copy into .venv.
Troubleshooting
Wrong interpreter, a second CLI in the venv, or Pro updated via PyPI.
Use the same Python minor and the same py -3.12 -m manifestguard ... invocation. Point --project-python at the project venv; do not pip-install a second CLI into .venv.
Testing basics
What check, --extended, and check-lifecycle each tell you.
check is the everyday quality radar: packaging, entry points, dependencies, import hygiene. One report, clear next steps.
Testing overview
Fast check, Pro extended analysis, optional lifecycle gate.
Start with the fast packaging pass. Add Pro analysis when you need CI evidence. Keep the lifecycle scan as its own gate if you care about thread/timer/logger leaks in source.
Reducing Complexity
Techniques to measure and reduce cyclomatic and cognitive complexity in Python code.
mgpy treats complexity as a measurable refactoring target: hotspots should be visible, comparable and trackable across baselines.
Code Consistency
Enforcing consistent coding standards and style across a Python codebase.
Consistency is not a cosmetic extra in mgpy: a clear tooling and style path reduces review friction, false positives and unstable reports.
PEP 8 Style
Applying PEP 8 formatting and style rules with ManifestGuard quality checks.
For mgpy, PEP 8 is the readable baseline. Good style rules speed up debugging, reduce cognitive load and keep review discussions short.
Type Hints
Adding and validating Python type annotations to improve static analysis coverage.
Type hints make mgpy reports more precise because public API boundaries, return values and data models become easier to validate.
Updates & modern Python
One CLI, Pro self-update, pathlib and a single pyproject.toml.
Keep one ManifestGuard CLI on Python 3.12 and point it at the project interpreter. Community refreshes from PyPI. Pro refreshes with license update-apply.
Documentation Quality
Best practices for docstrings, README files and inline documentation quality gates.
Strong documentation ensures that mgpy CLI, API and release artifacts all tell the same story. Missing documentation creates support and integration cost.
Security Vulnerabilities
Detecting and remedying common Python security vulnerabilities with ManifestGuard.
mgpy combines product-level and supply-chain signals: risky code patterns, outdated dependencies and accidental secrets must be visible before release.
Security Overview
Overview of all security checks available in ManifestGuard.
mgpy uses a layered security strategy: repository hygiene, build validation, runtime licensing and release verification all support each other.
Modern Cryptography
Replacing deprecated hashing and encryption algorithms with current best-practice equivalents.
Cryptography in mgpy is not a marketing add-on. Signed offline activation, secret handling and supply-chain protection require modern primitives and clear key flows.
Portable Paths
Cross-platform path handling in Python, avoiding hard-coded separators and OS assumptions.
mgpy should behave predictably on local machines, in CI and on customer environments across platforms. Hardcoded paths and OS assumptions break that promise first.
Performance Optimization
Profiling and tuning Python code for speed and resource efficiency.
For mgpy, performance only matters after correctness and signal quality are stable. Fast wrong reports are worse than slower correct ones.
Memory Profiling
Measuring and reducing the memory footprint of mgpy runs (without analyzing application runtime leaks).
In mgpy, memory usage often creeps up slowly: large reports, history files, caches or build artifacts grow longer unnoticed than simple runtime spikes.
SBOM Quality
Generating and validating Software Bill of Materials for Python packages.
For mgpy, a good SBOM is more than an export format. It links package reality, license visibility and supply-chain transparency into an auditable artifact.
Quality Gate
Setting up ManifestGuard quality thresholds that block builds on regressions.
Quality gates ensure that mgpy does not only observe quality but also protects decisions. A gate without a clear threshold model only creates noise.
Quality Regression Detection
Tracking quality trends over time and alerting on regressions across commits.
Regression detection is the bridge between a single run and real maintenance. mgpy should preserve improvements and surface backslides early.
Trend Analysis
Visualizing and interpreting long-term quality metric trends from ManifestGuard history.
For mgpy, trends prove whether improvements hold or whether erosion starts early. Individual good runs do not replace historical visibility.
Static lifecycle scan
Pro source scan for thread/timer/logger leaks. Separate from --extended.
check-lifecycle is a Pro quality test. It looks at source for leak patterns (threads without join, timers without cancel, logger handlers without a guard, optional Qt threads). It does not measure live process...