pip install callpyback

import callpyback
print(callpyback.__version__)
Quick test
from callpyback import CallPyBack, on_success
@CallPyBack(observers=[on_success(lambda r: print(f"Success: {r.value}"))])
def test_install():
return "CallPyBack is working!"
test_install()  # Should print: Success: CallPyBack is working!

# Clone the repository
git clone https://github.com/adnanharundogan/callpyback.git
cd callpyback
Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
Install in development mode
pip install -e .
Install development dependencies
pip install -e ".[dev]"

# Core development tools
pip install -e ".[dev]"
Or install specific tool sets
pip install -e ".[test]"      # Testing tools
pip install -e ".[docs]"      # Documentation tools
pip install -e ".[lint]"      # Linting and formatting
pip install -e ".[benchmark]" # Performance testing

# Pull the latest image
docker pull callpyback/callpyback:latest
Run interactive container
docker run -it callpyback/callpyback:latest python

FROM python:3.11-slim
Install CallPyBack
RUN pip install callpyback[all]
Copy your application
COPY . /app
WORKDIR /app
Install your app dependencies
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

version: '3.8'
services:
app:
build: .
environment:
- CALLPYBACK_LOG_LEVEL=INFO
- CALLPYBACK_METRICS_ENABLED=true
volumes:
- ./logs:/app/logs
depends_on:
- redis
redis:
image: redis:alpine
ports:
- "6379:6379"
monitoring:
image: grafana/grafana
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin

# requirements.txt
callpyback==2.0.0
lambda_function.py
import json
from callpyback import CallPyBack, on_success, on_failure
from callpyback.observers.builtin import LoggingObserver
Configure for Lambda
logger = LoggingObserver()
@CallPyBack(
observers=[logger, on_success(lambda r: print(f"Lambda success: {r.value}"))],
exception_classes=(Exception,),
default_return={"statusCode": 500, "body": "Error"}
)
def lambda_handler(event, context):
# Your Lambda logic
return {
"statusCode": 200,
"body": json.dumps({"message": "Success"})
}

# requirements.txt
callpyback==2.0.0
main.py
from callpyback import CallPyBack
from callpyback.observers.builtin import MetricsObserver
metrics = MetricsObserver()
@CallPyBack(observers=[metrics])
def hello_world(request):
return f"Hello from CallPyBack!"

# requirements.txt
callpyback==2.0.0

init.py
import azure.functions as func
from callpyback import CallPyBack, on_success
@CallPyBack(observers=[on_success(lambda r: print(f"Azure success: {r.value}"))])
def main(req: func.HttpRequest) -> func.HttpResponse:
return func.HttpResponse("Hello from CallPyBack on Azure!")

# Create conda environment
conda create -n callpyback python=3.11
conda activate callpyback
Install via conda-forge (when available)
conda install -c conda-forge callpyback
Or install via pip in conda environment
pip install callpyback

# pyproject.toml
[tool.poetry.dependencies]
python = "^3.8"
callpyback = "^2.0.0"
[tool.poetry.group.dev.dependencies]
callpyback = {extras = ["dev"], version = "^2.0.0"}

poetry install
poetry add callpyback[monitoring,database]

# Install basic package
pipenv install callpyback
Install with extras
pipenv install callpyback[all]
Development dependencies
pipenv install --dev callpyback[dev]

# config/callpyback_config.py
"""Enterprise CallPyBack configuration."""
import os
import logging
from callpyback.observers.builtin import LoggingObserver, MetricsObserver
from callpyback.management.error_handling import create_robust_error_chain
Environment-based configuration
ENVIRONMENT = os.getenv('ENVIRONMENT', 'development')
Logging configuration
def get_logger_config():
if ENVIRONMENT == 'production':
return LoggingObserver(
logger=logging.getLogger('enterprise.callpyback'),
log_level=logging.WARNING
)
else:
return LoggingObserver(log_level=logging.DEBUG)
Default observers for enterprise deployment
DEFAULT_OBSERVERS = [
get_logger_config(),
MetricsObserver(priority=100)
]
Error handling configuration
ERROR_HANDLER = create_robust_error_chain(
default_return={'status': 'error', 'environment': ENVIRONMENT}
)
Export configuration
ENTERPRISE_CONFIG = {
'observers': DEFAULT_OBSERVERS,
'error_handler': ERROR_HANDLER,
'max_observer_failures': 3,
'enable_async_observers': True
}

# app.py
from flask import Flask, request, jsonify
from callpyback import CallPyBack, on_call, on_success, on_failure
app = Flask(name)
Request logging observer
def log_request(context):
print(f"Request to {context.function_signature.name}: {context.arguments}")
def log_response(result):
print(f"Response: {result.value}")
def log_error(result):
print(f"Error: {result.exception}")
@app.route('/api/users/<int:user_id>')
@CallPyBack(
observers=[
on_call(log_request),
on_success(log_response),
on_failure(log_error)
],
exception_classes=(ValueError, KeyError),
default_return=jsonify({"error": "Internal server error"})
)
def get_user(user_id):
# Your route logic
return jsonify({"user_id": user_id, "name": "John Doe"})
if name == 'main':
app.run(debug=True)

# settings.py
INSTALLED_APPS = [
    # ... your apps
    'callpyback.contrib.django',  # CallPyBack Django integration
]
CALLPYBACK_SETTINGS = {
'DEFAULT_OBSERVERS': [
'callpyback.observers.builtin.LoggingObserver',
'callpyback.observers.builtin.MetricsObserver',
],
'ERROR_HANDLING': {
'exception_classes': ('ValueError', 'KeyError'),
'default_return': {'error': 'Service unavailable'}
}
}
views.py
from django.http import JsonResponse
from callpyback import CallPyBack
from callpyback.contrib.django import django_observer
@CallPyBack(observers=[django_observer])
def api_view(request):
# Your view logic
return JsonResponse({"status": "success"})

# main.py
from fastapi import FastAPI, HTTPException
from callpyback import CallPyBack, on_success, on_failure
from callpyback.observers.builtin import MetricsObserver
app = FastAPI()
metrics = MetricsObserver()
def log_api_success(result):
print(f"API Success: {result.value}")
def handle_api_error(result):
print(f"API Error: {result.exception}")
@app.get("/items/{item_id}")
@CallPyBack(
observers=[metrics, on_success(log_api_success), on_failure(handle_api_error)],
exception_classes=(ValueError, HTTPException),
default_return={"error": "Service unavailable"}
)
async def read_item(item_id: int):
if item_id < 0:
raise ValueError("Invalid item ID")
return {"item_id": item_id, "name": f"Item {item_id}"}
@app.get("/metrics")
async def get_metrics():
return metrics.get_metrics()

# test_installation.py
"""Test script to verify CallPyBack installation."""
import sys
import time
from callpyback import CallPyBack, on_success, on_failure, on_completion
from callpyback.observers.builtin import MetricsObserver, TimingObserver
def test_basic_functionality():
"""Test basic decorator functionality."""
results = []
@CallPyBack(observers=[on_success(lambda r: results.append(r.value))])
def basic_function():
    return "basic_test_passed"

result = basic_function()
assert result == "basic_test_passed"
assert len(results) == 1
print("✅ Basic functionality test passed")

def test_error_handling():
"""Test error handling."""
errors = []
@CallPyBack(
    observers=[on_failure(lambda r: errors.append(str(r.exception)))],
    exception_classes=(ValueError,),
    default_return="error_handled"
)
def error_function():
    raise ValueError("Test error")

result = error_function()
assert result == "error_handled"
assert len(errors) == 1
print("✅ Error handling test passed")

def test_observers():
"""Test built-in observers."""
metrics = MetricsObserver()
timing = TimingObserver(threshold=0.01)
@CallPyBack(observers=[metrics, timing])
def monitored_function():
    time.sleep(0.02)  # Should trigger timing alert
    return "monitored"

result = monitored_function()
assert result == "monitored"

metrics_data = metrics.get_metrics()
assert metrics_data['total_executions'] == 1

slow_executions = timing.get_slow_executions()
assert len(slow_executions) == 1
print("✅ Observer test passed")

def test_variable_extraction():
"""Test variable extraction."""
captured = []
@CallPyBack(
    observers=[on_completion(lambda vars: captured.append(vars))],
    variable_names=['local_var']
)
def variable_function():
    local_var = "extracted_value"
    return "done"

result = variable_function()
assert result == "done"
assert len(captured) == 1
assert captured[0]['local_var'] == "extracted_value"
print("✅ Variable extraction test passed")

if name == "main":
print("Testing CallPyBack installation...")
print(f"Python version: {sys.version}")
try:
    test_basic_functionality()
    test_error_handling()
    test_observers()
    test_variable_extraction()
    
    print("\n🎉 All installation tests passed!")
    print("CallPyBack is ready to use.")
    
except Exception as e:
    print(f"\n❌ Installation test failed: {e}")
    sys.exit(1)

python test_installation.py

# benchmark_installation.py
"""Benchmark CallPyBack overhead."""
import time
import statistics
from callpyback import CallPyBack
from callpyback.observers.builtin import MetricsObserver
def benchmark_overhead():
"""Measure observer overhead."""
# Baseline function
def baseline_function():
return "result"
# Decorated function
metrics = MetricsObserver()

@CallPyBack(observers=[metrics])
def decorated_function():
    return "result"

# Measure baseline
baseline_times = []
for _ in range(1000):
    start = time.perf_counter()
    baseline_function()
    baseline_times.append(time.perf_counter() - start)

# Measure decorated
decorated_times = []
for _ in range(1000):
    start = time.perf_counter()
    decorated_function()
    decorated_times.append(time.perf_counter() - start)

# Calculate overhead
baseline_avg = statistics.mean(baseline_times)
decorated_avg = statistics.mean(decorated_times)
overhead = decorated_avg - baseline_avg

print(f"Baseline average: {baseline_avg*1000:.3f}ms")
print(f"Decorated average: {decorated_avg*1000:.3f}ms")
print(f"Observer overhead: {overhead*1000:.3f}ms")
print(f"Overhead percentage: {(overhead/baseline_avg)*100:.1f}%")

# Performance assertion
assert overhead < 0.001, f"Overhead too high: {overhead*1000:.3f}ms"
print("✅ Performance benchmark passed")

if name == "main":
benchmark_overhead()

# Error
ModuleNotFoundError: No module named 'callpyback'
Solutions
pip install callpyback  # Basic installation
pip install --upgrade callpyback  # Upgrade existing
pip install --force-reinstall callpyback  # Force reinstall

# Error
Permission denied: '/usr/local/lib/python3.x/site-packages/'
Solutions
pip install --user callpyback  # User installation
sudo pip install callpyback     # System-wide (not recommended)
Or use virtual environment (recommended)

# Error
ERROR: pip's dependency resolver does not currently consider...
Solutions
pip install --upgrade pip  # Upgrade pip first
pip install callpyback --no-deps  # Skip dependency checks
pip install callpyback --force-reinstall  # Force reinstall

# Error
SyntaxError: f-strings require Python 3.6+
Solution: Upgrade Python or use compatible version
python --version  # Check current version
pyenv install 3.11.0  # Install newer Python (if using pyenv)

# Create clean environment
python -m venv fresh_env
source fresh_env/bin/activate
pip install --upgrade pip setuptools wheel
pip install callpyback

# Build with no cache
docker build --no-cache -t my-callpyback-app .
Check Python version in container
docker run -it my-callpyback-app python --version

# Add to Python path if needed
import sys
sys.path.insert(0, '/path/to/callpyback')
import callpyback

# diagnose_installation.py
"""Diagnostic script for CallPyBack installation issues."""
import sys
import platform
import pkg_resources
def diagnose_environment():
"""Diagnose Python environment."""
print("=== Environment Diagnosis ===")
print(f"Python version: {sys.version}")
print(f"Platform: {platform.platform()}")
print(f"Architecture: {platform.architecture()}")
print(f"Python path: {sys.executable}")
try:
    import callpyback
    print(f"CallPyBack version: {callpyback.__version__}")
    print(f"CallPyBack location: {callpyback.__file__}")
except ImportError as e:
    print(f"❌ CallPyBack import failed: {e}")
    return False

# Check dependencies
print("\n=== Dependencies ===")
try:
    requirements = ['typing-extensions']
    for req in requirements:
        version = pkg_resources.get_distribution(req).version
        print(f"✅ {req}: {version}")
except pkg_resources.DistributionNotFound as e:
    print(f"❌ Missing dependency: {e}")
    return False

return True

if name == "main":
if diagnose_environment():
print("\n✅ Installation appears healthy")
else:
print("\n❌ Installation issues detected")