epochly 0.6.3

Epochly - Transparent performance optimization for Python applications

Epochly - Transparent Performance Optimization

Significant performance improvement with zero code changes!

Epochly provides transparent performance optimization for Python applications through a progressive enhancement system.

🚀 Installation

pip install epochly

That's it! Epochly is now ready to accelerate your Python code.

⚡ Quick Start

Method 1: Automatic Optimization (Recommended)

import epochly  # Just this import provides optimization!

# Your existing code runs faster automatically
import numpy as np

def matrix_computation():
    a = np.random.rand(1000, 1000)
    b = np.random.rand(1000, 1000)
    return np.dot(a, b)

result = matrix_computation()  # Automatically optimized!

Method 2: Selective Optimization

from epochly import optimize

@optimize
def slow_function(data):
    # This function will be optimized
    return complex_computation(data)

Method 3: Context Manager

from epochly import optimize_context

with optimize_context():
    # All code in this block is optimized
    result = heavy_computation()

✨ Key Features

• Zero Configuration: Just import and go - Epochly automatically detects and optimizes your workloads
• Progressive Enhancement: Four optimization levels from monitoring to full sub-interpreter parallelization
• 100% Compatibility: Works with existing Python code, libraries, and frameworks
• Production Ready: Controlled deployment with emergency controls and monitoring
• Transparent Activation: Automatic activation via sitecustomize.py for seamless integration

📊 Performance Results

Epochly provides transparent optimization through 5 progressive enhancement levels:

• Level 0: Monitoring and analysis
• Level 1: Basic threading optimization
• Level 2: JIT compilation
• Level 3: Full optimization with sub-interpreters and shared memory
• Level 4: GPU acceleration (when available)

Average performance improvement varies by workload type.

🎯 Use Cases

Perfect for:

• Scientific computing and data analysis
• Machine learning preprocessing
• Financial modeling
• Image and signal processing
• Any CPU-intensive Python code

🔧 Advanced Configuration

from epochly import configure, EnhancementLevel

# Set optimization level
configure(enhancement_level=EnhancementLevel.LEVEL_3_FULL)

# Enable profiling
configure(profile_enabled=True)

# Control worker threads
configure(max_workers=8)

📖 Documentation

For comprehensive documentation, visit https://epochly.com/docs

🏃 Demo

Try our performance demo:

# After installation
python -m epochly.demos.benchmark

💻 System Requirements

• Python 3.9-3.14
• Linux, macOS, or Windows
• No GPU required (CPU optimization)

🚀 Deployment

Transparent Activation

Epochly can be transparently activated for all Python processes:

# Install sitecustomize.py for automatic activation
epochly-deploy install

# Selective activation by environment
export EPOCHLY_ENABLED=1
python your_app.py

# Configuration file control
echo "enabled: true" > ~/.epochly/config.yml

Production Deployment

# Controlled rollout
epochly-deploy enable --percentage 10 --monitor-only

# Emergency disable
epochly-deploy disable --emergency

# Monitor deployment
epochly-deploy status --detailed

📊 Monitoring

Epochly provides comprehensive monitoring and observability:

import epochly

# Get performance metrics
metrics = epochly.get_metrics()
print(f"Enhancement level: {metrics.get('enhancement_level')}")
print(f"Functions optimized: {metrics.get('functions_optimized', 0)}")

# Check current status
status = epochly.get_status()
print(f"Enabled: {status['enabled']}")

🔒 Security

Epochly implements comprehensive security measures:

• Memory isolation between interpreters
• Access control for shared memory
• Audit logging for all operations
• Side-channel attack mitigation
• Secure deployment controls
• HMAC-signed pickle helper for trusted IPC boundaries (epochly.security.signed_pickle)
• Hardened AST sanitizer for dynamically-compiled user code paths
• Prometheus exporter defaults to loopback (127.0.0.1) with explicit warning when an operator opts into 0.0.0.0 without authentication
• Bounded Prometheus metric-name cardinality (user-input hashing + 1000-name ceiling)

Stability & Memory Correctness

Verified by the 2026-04-16 P0 stabilization sweep (24 behavioral assertions in validation-contract.md, 30+ new regression tests):

• Bounded HALF_OPEN probe concurrency in the memory circuit breaker
• Adjacent-block coalescing in HybridLargeBlockManager (no long-run fragmentation)
• Real OS mprotect(PROT_NONE) enforcement on memory-pool guard pages
• Fixed small-slab (<64 object) bitmap math
• Serialized FastMemoryPool bookkeeping under contention
• Verified on Linux RTX 4070 (NVIDIA GPU path): 1012 passed, 90 skipped, 0 failed across the memory + progression suites
• 5% wall-clock overhead budget preserved on non-beneficial workloads (tests/validation/test_acceleration_proof.py)

Phase 2 Stabilization (P1/P2/P3)

Verified by the 2026-04-16 Phase 2 stabilization sweep (116 additional behavioral assertions across 9 milestones, M5–M13):

• NUMA-aware memory placement and monitoring hardening (M5–M6)
• Runtime, JIT, and ML-path correctness (M7–M8); banned env-var writes rerouted through config helpers
• Licensing integrity (trial endpoint hardening, dev-token horizons, license integrity, progression protection) (M9)
• Boot-sequence, core, and config robustness (M10); CLI, Jupyter, and deployment paths (M11)
• GPU and native inference sweep on RTX 4070 with zero mission regressions (M12)
• Closeout sweeps: progression integrity, hygiene (0 TODO/FIXME/HACK/XXX, 0 mocks, 0 banned env writes), Cython wheel verification, Python 3.9 compatibility fix (M13)
• Hygiene guardrails landed as executable tests: tests/validation/test_no_mocks_in_src.py and tests/validation/test_no_banned_env_writes.py

M6 Post-Merge Followups

Final m6 followup validation on main head e24291509718a89b6820075aa55051ec34a3e996 covered:

• Merged followup PRs: #519, #522, #525, #527, #528, and #529.
• Closed issues touched by the followups: #117, #517, #520, #521, #524, and #526.
• Open infrastructure / known-pre-existing trackers intentionally left open: #498, #512, and #518.
• PR #515 remains in the author's court and was not merged because review identified a cross-platform Level-2 JIT effectiveness regression.

📚 Documentation

• Getting Started Guide
• Architecture Overview
• API Reference
• Deployment Guide
• Performance Tuning

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

# Development setup
git clone https://github.com/epochly-python/epochly.git
cd epochly
python3.12 -m venv .venv
source .venv/bin/activate
pip install -e '.[dev]'
pre-commit install

# Run tests (always activate the venv first)
source .venv/bin/activate
pytest tests/unit/

# Run benchmarks
pytest tests/performance/ --benchmark-only

Note: Epochly supports Python 3.9 through 3.14. Cython extensions build with python setup.py build_ext --inplace. Cross-version development venvs (.venv-py39, .venv-py310, .venv-py311, .venv-py312, .venv-py313) can be created alongside .venv for compatibility testing.

📄 License

Epochly is proprietary commercial software licensed under the Epochly Software License Agreement (ESLA). See LICENSE for the complete license terms.

• Terms of Service
• Privacy Policy

🙏 Acknowledgments

Epochly builds upon the excellent work of:

• Python core developers for sub-interpreter support
• NumPy and SciPy communities for numerical computing foundations
• PyPy team for JIT compilation insights
• Numba developers for compilation techniques

---

Epochly - Making Python Fast, Transparently 🐍⚡