Python SDK

Basic Usage

from autonoma import Autonoma

# Initialize the client
autonoma = Autonoma(
    api_key="your-api-key",
    environment="production"
)

# Start monitoring
autonoma.start()

# Analyze code
with open("app.py", "r") as f:
    analysis = autonoma.analyze(
        file="app.py",
        content=f.read()
    )

# Get predictions
predictions = autonoma.get_predictions()

# Apply auto-fix
if predictions and predictions[0].auto_fix_available:
    result = autonoma.apply_fix(predictions[0].id)
    print(f"Fix applied: {result.success}")

Async Support

import asyncio
from autonoma import AsyncAutonoma

async def main():
    # Initialize async client
    autonoma = AsyncAutonoma(
        api_key="your-api-key",
        environment="production"
    )
    
    # Analyze multiple files concurrently
    files = ["app.py", "models.py", "views.py"]
    
    tasks = []
    for file_path in files:
        with open(file_path, "r") as f:
            task = autonoma.analyze(
                file=file_path,
                content=f.read()
            )
            tasks.append(task)
    
    # Wait for all analyses to complete
    results = await asyncio.gather(*tasks)
    
    # Process results
    for result in results:
        print(f"{result.file}: {len(result.predictions)} issues found")
    
    # Clean up
    await autonoma.close()

# Run async function
asyncio.run(main())

Django Integration

# settings.py
INSTALLED_APPS = [
    # ...
    'autonoma.contrib.django',
]

AUTONOMA = {
    'API_KEY': os.environ.get('AUTONOMA_API_KEY'),
    'ENVIRONMENT': 'production',
    'AUTO_FIX': {
        'ENABLED': True,
        'CONFIDENCE': 0.95,
    },
    'MIDDLEWARE': {
        'ENABLED': True,
        'SAMPLE_RATE': 1.0,
    }
}

# views.py
from autonoma.contrib.django import monitor_view

@monitor_view
def user_profile(request, user_id):
    # Autonoma automatically monitors this view
    user = User.objects.get(id=user_id)
    return render(request, 'profile.html', {'user': user})

# management command
python manage.py autonoma analyze
python manage.py autonoma fix --auto-approve

Flask Integration

from flask import Flask
from autonoma.contrib.flask import Autonoma

app = Flask(__name__)

# Initialize Autonoma
autonoma = Autonoma(app, api_key="your-api-key")

# Or with app factory
autonoma = Autonoma()

def create_app():
    app = Flask(__name__)
    autonoma.init_app(app, api_key="your-api-key")
    return app

# Automatic error tracking
@app.errorhandler(Exception)
def handle_error(error):
    autonoma.capture_exception(error)
    return "Internal Server Error", 500

# Monitor specific routes
@app.route('/api/users/<user_id>')
@autonoma.monitor
def get_user(user_id):
    # Route is automatically monitored
    return User.query.get_or_404(user_id).to_dict()

analyze(file, content, **kwargs)

Analyze code for potential issues, performance problems, and security vulnerabilities.

# Analyze a single file
result = autonoma.analyze(
    file="src/models/user.py",
    content=file_content,
    context={
        "framework": "django",
        "python_version": "3.9"
    }
)

# Analyze with specific rules
result = autonoma.analyze(
    file="api.py",
    content=file_content,
    rules=["security", "performance"],
    severity_threshold="medium"
)

# Batch analysis
files = [
    {"file": "app.py", "content": app_content},
    {"file": "models.py", "content": models_content}
]
results = autonoma.analyze_batch(files)

# Response structure
{
    "predictions": [
        {
            "id": "pred_123",
            "type": "security",
            "severity": "high",
            "message": "SQL injection vulnerability detected",
            "line": 45,
            "column": 12,
            "auto_fix_available": True
        }
    ],
    "metrics": {
        "total_issues": 3,
        "by_severity": {"high": 1, "medium": 2},
        "execution_time": 0.234
    }
}

get_predictions(**filters)

Retrieve predictions for your codebase with optional filtering.

# Get all predictions
predictions = autonoma.get_predictions()

# Filter by severity and type
critical_security = autonoma.get_predictions(
    severity=["critical", "high"],
    type="security",
    status="open"
)

# Filter by date and confidence
recent_high_confidence = autonoma.get_predictions(
    created_after=datetime.now() - timedelta(days=7),
    confidence_min=0.9
)

# Pagination
page = autonoma.get_predictions(
    page=1,
    per_page=50,
    order_by="severity",
    order="desc"
)

# Access results
for prediction in predictions:
    print(f"{prediction.file}:{prediction.line} - {prediction.message}")
    if prediction.auto_fix_available:
        print(f"  Auto-fix available with {prediction.fix_confidence:.0%} confidence")

apply_fix(prediction_id, **options)

Apply an auto-fix for a specific prediction with validation and rollback support.

# Apply fix with default settings
fix_result = autonoma.apply_fix("pred_123abc")

# Apply with options
fix_result = autonoma.apply_fix(
    "pred_123abc",
    dry_run=True,           # Preview without applying
    create_backup=True,     # Backup file before changes
    run_tests=True,         # Run test suite after fix
    test_command="pytest",  # Custom test command
    auto_commit=False,      # Don't auto-commit to git
    commit_message="fix: resolve SQL injection vulnerability"
)

# Handle result
if fix_result.success:
    print(f"Fix applied successfully!")
    print(f"Files changed: {fix_result.files_changed}")
    print(f"Lines modified: {fix_result.lines_modified}")
    
    # Review changes
    for change in fix_result.changes:
        print(f"  {change.file}: {change.description}")
else:
    print(f"Fix failed: {fix_result.error}")
    
    # Rollback if needed
    if fix_result.rollback_available:
        autonoma.rollback(fix_result.rollback_id)

# Batch fixes
fixes = autonoma.apply_fixes(
    prediction_ids=["pred_123", "pred_456"],
    stop_on_error=True
)

monitor(**options) / @monitor decorator

Monitor application performance and errors in real-time.

# Start monitoring
autonoma.monitor(
    capture_errors=True,
    capture_performance=True,
    capture_custom_metrics=True
)

# Using decorators
from autonoma.decorators import monitor, measure_time

@monitor
def process_payment(amount, user_id):
    # Function is automatically monitored
    # Errors are captured and reported
    return payment_gateway.charge(amount, user_id)

@measure_time
def expensive_operation():
    # Execution time is automatically tracked
    return complex_calculation()

# Custom metrics
autonoma.metric("api.requests", 1, tags={"endpoint": "/users"})
autonoma.gauge("queue.size", queue.qsize())
autonoma.histogram("response.size", len(response.content))

# Context manager for monitoring
with autonoma.monitor_context("batch_job"):
    for item in items:
        process_item(item)

# Stop monitoring
autonoma.stop_monitoring()