Maintanence

python-Maintenance Dependency Management

Requirements Management

text

# requirements.txt
flask==2.3.3
gunicorn==21.2.0
psycopg2-binary==2.9.7
redis==5.0.1
celery==5.3.4
prometheus-client==0.19.0
python-json-logger==2.0.7
opentelemetry-api==1.21.0
opentelemetry-sdk==1.21.0

# requirements-dev.txt
pytest==7.4.3
pytest-cov==4.1.0
flake8==6.1.0
mypy==1.7.1
black==23.11.0
isort==5.12.0

Dependency Scanning

bash

#!/bin/bash
# security_scan.sh
# Install security tools
pip install safety bandit semgrep
# Scan for known vulnerabilities
safety check --json --output safety-report.json
# Static analysis for security issues
bandit -r src/ -f json -o bandit-report.json
# Additional security scanning
semgrep --config=auto src/ --json --output=semgrep-report.json
# Check for outdated packages
pip list --outdated --format=json > outdated-packages.json

Update and Patching Strategy

Automated Dependency Updates

yaml

# .github/workflows/dependency-update.yml
name: Dependency Update
on:
  schedule:
    - cron: '0 2 * * MON'  # Every Monday at 2 AM
  workflow_dispatch:
jobs:
  update-dependencies:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: 3.11.11
    - name: Install pip-tools
      run: pip install pip-tools
    - name: Update dependencies
      run: |
        pip-compile --upgrade requirements.in
        pip-compile --upgrade requirements-dev.in
    - name: Create Pull Request
      uses: peter-evans/create-pull-request@v5
      with:
        token: ${{ secrets.GITHUB_TOKEN }}
        commit-message: 'Update dependencies'
        title: 'Automated dependency update'
        body: 'Automated update of Python dependencies'
        branch: dependency-update

Version Pinning Strategy

python

# version_manager.py
import subprocess
import json
from packaging import version
def check_python_version():
    """Ensure Python 3.11.11 is being used"""
    import sys
    current_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
    required_version = "3.11.11"
    if version.parse(current_version) < version.parse(required_version):
        raise RuntimeError(f"Python {required_version} required, found {current_version}")
def audit_dependencies():
    """Audit installed packages for security vulnerabilities"""
    result = subprocess.run(['safety', 'check', '--json'], capture_output=True, text=True)
    if result.returncode != 0:
        vulnerabilities = json.loads(result.stdout)
        return vulnerabilities
    return []

Backup and Recovery

Virtual Environment Backup

bash

#!/bin/bash
# backup_env.sh
BACKUP_DIR="/opt/backups/python-envs"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
ENV_NAME="myapp"
# Create backup directory
mkdir -p "${BACKUP_DIR}/${TIMESTAMP}"
# Backup requirements
pip freeze > "${BACKUP_DIR}/${TIMESTAMP}/requirements.txt"
# Backup virtual environment
tar -czf "${BACKUP_DIR}/${TIMESTAMP}/${ENV_NAME}_venv.tar.gz" \
    -C /opt/myapp venv
# Backup application configuration
cp -r /opt/myapp/config "${BACKUP_DIR}/${TIMESTAMP}/"
# Clean old backups (keep last 30 days)
find "${BACKUP_DIR}" -type d -mtime +30 -exec rm -rf {} \;

Environment Recreation Script

bash

#!/bin/bash
# restore_env.sh
BACKUP_DIR="/opt/backups/python-envs"
RESTORE_DATE="$1"
if [ -z "$RESTORE_DATE" ]; then
    echo "Usage: $0 <backup_date>"
    echo "Available backups:"
    ls -la "$BACKUP_DIR"
    exit 1
fi
RESTORE_PATH="${BACKUP_DIR}/${RESTORE_DATE}"
if [ ! -d "$RESTORE_PATH" ]; then
    echo "Backup not found: $RESTORE_PATH"
    exit 1
fi
# Stop services
systemctl stop myapp
# Remove current environment
rm -rf /opt/myapp/venv
# Create new virtual environment
python3.11 -m venv /opt/myapp/venv
source /opt/myapp/venv/bin/activate
# Restore packages
pip install -r "${RESTORE_PATH}/requirements.txt"
# Restore configuration
cp -r "${RESTORE_PATH}/config/"* /opt/myapp/config/
# Start services
systemctl start myapp

Performance Optimization

Memory Profiling

python

# memory_profiler.py
import tracemalloc
import psutil
import gc
from memory_profiler import profile
class MemoryMonitor:
    def __init__(self):
        self.process = psutil.Process()
        tracemalloc.start()
    def get_memory_usage(self):
        """Get current memory usage"""
        return {
            'rss': self.process.memory_info().rss,
            'vms': self.process.memory_info().vms,
            'percent': self.process.memory_percent(),
            'available': psutil.virtual_memory().available
        }
    def get_top_memory_consumers(self, limit=10):
        """Get top memory consuming objects"""
        snapshot = tracemalloc.take_snapshot()
        top_stats = snapshot.statistics('lineno')
        return top_stats[:limit]
    def force_garbage_collection(self):
        """Force garbage collection and return collected objects"""
        collected = []
        for generation in range(3):
            collected.append(gc.collect())
        return collected
# Usage example
@profile
def memory_intensive_function():
    # Your memory-intensive code here
    large_list = [i for i in range(1000000)]
    return large_list

Useful Commands Reference

bash

# Virtual environment management

python3.11 -m venv venv
source venv/bin/activate
deactivate
# Package management
pip install package_name
pip install -r requirements.txt
pip freeze > requirements.txt
pip show package_name
# Development tools
python -m pytest tests/
python -m coverage run -m pytest
python -m flake8 src/
python -m mypy src/
python -m black src/
# Debugging
python -m pdb script.py
python -c "import package; help(package)"
python -m trace --trace script.py