kalibr 1.0.28__py3-none-any.whl → 1.1.0__py3-none-any.whl

kalibr-1.0.28.data/data/examples/enhanced_kalibr_example.py

@@ -1,347 +0,0 @@
-"""
-Enhanced Kalibr App Example - App-level capabilities
-This demonstrates the new enhanced capabilities including file uploads,
-sessions, streaming, workflows, and multi-model schema generation.
-"""
-
-from kalibr import KalibrApp
-from kalibr.types import FileUpload, Session, StreamingResponse, WorkflowState, AuthenticatedUser
-import asyncio
-import json
-from datetime import datetime
-from typing import List
-
-# Create an enhanced KalibrApp instance
-app = KalibrApp(title="Enhanced Kalibr Demo", base_url="http://localhost:8000")
-
-# Basic action (compatible with original Kalibr)
-@app.action("hello", "Say hello with enhanced capabilities")
-def hello_enhanced(name: str = "World", include_timestamp: bool = False):
-    """Enhanced hello function with optional timestamp"""
-    message = f"Hello, {name}! This is Enhanced Kalibr v2.0"
-    
-    response = {"message": message}
-    if include_timestamp:
-        response["timestamp"] = datetime.now().isoformat()
-    
-    return response
-
-# File upload handler
-@app.file_handler("analyze_document", [".txt", ".md", ".py", ".js", ".json"])
-async def analyze_document(file: FileUpload):
-    """Analyze uploaded document and return insights"""
-    try:
-        # Decode file content
-        content = file.content.decode('utf-8')
-        
-        # Basic analysis
-        lines = content.split('\n')
-        words = content.split()
-        
-        # Language detection based on file extension
-        language = "text"
-        if file.filename.endswith('.py'):
-            language = "python"
-        elif file.filename.endswith('.js'):
-            language = "javascript"
-        elif file.filename.endswith('.json'):
-            language = "json"
-            try:
-                json_data = json.loads(content)
-                return {
-                    "upload_id": file.upload_id,
-                    "filename": file.filename,
-                    "analysis": {
-                        "type": "json",
-                        "valid_json": True,
-                        "keys": list(json_data.keys()) if isinstance(json_data, dict) else None,
-                        "size_bytes": file.size
-                    }
-                }
-            except json.JSONDecodeError:
-                pass
-        
-        return {
-            "upload_id": file.upload_id,
-            "filename": file.filename,
-            "analysis": {
-                "language": language,
-                "line_count": len(lines),
-                "word_count": len(words),
-                "character_count": len(content),
-                "size_bytes": file.size,
-                "non_empty_lines": len([line for line in lines if line.strip()]),
-                "estimated_reading_time_minutes": len(words) / 200  # Average reading speed
-            }
-        }
-    except UnicodeDecodeError:
-        return {
-            "upload_id": file.upload_id,
-            "filename": file.filename,
-            "error": "File is not text-readable (binary file)",
-            "size_bytes": file.size
-        }
-
-# Session-aware action
-@app.session_action("save_note", "Save a note to user session")
-async def save_note(session: Session, note_title: str, note_content: str):
-    """Save a note to the user's session"""
-    
-    # Initialize notes if not exists
-    if 'notes' not in session.data:
-        session.data['notes'] = []
-    
-    # Create note object
-    note = {
-        "id": len(session.data['notes']) + 1,
-        "title": note_title,
-        "content": note_content,
-        "created_at": datetime.now().isoformat(),
-        "updated_at": datetime.now().isoformat()
-    }
-    
-    session.data['notes'].append(note)
-    session.set('last_note_id', note['id'])
-    
-    return {
-        "status": "saved",
-        "note": note,
-        "total_notes": len(session.data['notes']),
-        "session_id": session.session_id
-    }
-
-@app.session_action("get_notes", "Retrieve all notes from session")
-async def get_notes(session: Session):
-    """Get all notes from the user's session"""
-    notes = session.get('notes', [])
-    
-    return {
-        "notes": notes,
-        "count": len(notes),
-        "session_id": session.session_id,
-        "last_note_id": session.get('last_note_id')
-    }
-
-# Streaming action
-@app.stream_action("count_with_progress", "Stream counting with progress updates")
-async def count_with_progress(max_count: int = 10, delay_seconds: float = 1.0):
-    """Stream counting numbers with progress indication"""
-    
-    for i in range(max_count + 1):
-        progress_percent = (i / max_count) * 100
-        
-        yield {
-            "count": i,
-            "max_count": max_count,
-            "progress_percent": progress_percent,
-            "message": f"Counting: {i}/{max_count}",
-            "timestamp": datetime.now().isoformat(),
-            "is_complete": (i == max_count)
-        }
-        
-        if i < max_count:  # Don't delay after the last item
-            await asyncio.sleep(delay_seconds)
-
-@app.stream_action("generate_fibonacci", "Stream Fibonacci sequence")
-async def generate_fibonacci(count: int = 20, delay_seconds: float = 0.5):
-    """Generate Fibonacci sequence as a stream"""
-    
-    a, b = 0, 1
-    for i in range(count):
-        yield {
-            "position": i + 1,
-            "fibonacci_number": a,
-            "sequence_so_far": f"F({i+1}) = {a}",
-            "timestamp": datetime.now().isoformat()
-        }
-        
-        a, b = b, a + b
-        await asyncio.sleep(delay_seconds)
-
-# Complex workflow
-@app.workflow("process_text_analysis", "Complete text analysis workflow")
-async def text_analysis_workflow(text: str, workflow_state: WorkflowState):
-    """Multi-step text analysis workflow"""
-    
-    # Step 1: Validation
-    workflow_state.step = "validation"
-    workflow_state.status = "processing"
-    
-    if not text or len(text.strip()) < 10:
-        workflow_state.status = "error"
-        return {"error": "Text must be at least 10 characters long"}
-    
-    await asyncio.sleep(1)  # Simulate processing time
-    
-    # Step 2: Basic analysis
-    workflow_state.step = "basic_analysis"
-    workflow_state.data["validation_passed"] = True
-    
-    words = text.split()
-    sentences = [s.strip() for s in text.replace('!', '.').replace('?', '.').split('.') if s.strip()]
-    
-    basic_stats = {
-        "character_count": len(text),
-        "word_count": len(words),
-        "sentence_count": len(sentences),
-        "paragraph_count": len([p for p in text.split('\n\n') if p.strip()])
-    }
-    
-    workflow_state.data["basic_stats"] = basic_stats
-    await asyncio.sleep(1)
-    
-    # Step 3: Advanced analysis
-    workflow_state.step = "advanced_analysis"
-    
-    # Word frequency
-    word_freq = {}
-    for word in words:
-        clean_word = word.lower().strip('.,!?";:')
-        word_freq[clean_word] = word_freq.get(clean_word, 0) + 1
-    
-    # Top words
-    top_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
-    
-    advanced_stats = {
-        "unique_words": len(word_freq),
-        "average_word_length": sum(len(word) for word in words) / len(words) if words else 0,
-        "longest_word": max(words, key=len) if words else None,
-        "top_words": top_words,
-        "readability_score": min(100, max(0, 100 - (len(words) / len(sentences) if sentences else 1) * 2))
-    }
-    
-    workflow_state.data["advanced_stats"] = advanced_stats
-    await asyncio.sleep(1)
-    
-    # Step 4: Final compilation
-    workflow_state.step = "compilation"
-    
-    result = {
-        "workflow_id": workflow_state.workflow_id,
-        "analysis_type": "complete_text_analysis",
-        "input_text_preview": text[:100] + "..." if len(text) > 100 else text,
-        "basic_statistics": basic_stats,
-        "advanced_statistics": advanced_stats,
-        "processing_steps": ["validation", "basic_analysis", "advanced_analysis", "compilation"],
-        "completed_at": datetime.now().isoformat()
-    }
-    
-    workflow_state.step = "completed"
-    workflow_state.status = "success"
-    workflow_state.data["final_result"] = result
-    
-    return result
-
-# Data processing workflow
-@app.workflow("batch_text_processor", "Process multiple texts in batch")
-async def batch_text_processor(texts: List[str], workflow_state: WorkflowState):
-    """Process multiple texts as a batch workflow"""
-    
-    workflow_state.step = "initialization"
-    workflow_state.status = "processing"
-    
-    if not texts or len(texts) == 0:
-        workflow_state.status = "error"
-        return {"error": "No texts provided for processing"}
-    
-    results = []
-    workflow_state.data["total_texts"] = len(texts)
-    
-    for i, text in enumerate(texts):
-        workflow_state.step = f"processing_text_{i+1}"
-        workflow_state.data["current_text"] = i + 1
-        workflow_state.data["progress_percent"] = ((i + 1) / len(texts)) * 100
-        
-        # Process each text
-        words = text.split()
-        analysis = {
-            "text_id": i + 1,
-            "text_preview": text[:50] + "..." if len(text) > 50 else text,
-            "word_count": len(words),
-            "character_count": len(text),
-            "sentence_count": len([s for s in text.split('.') if s.strip()])
-        }
-        
-        results.append(analysis)
-        await asyncio.sleep(0.5)  # Simulate processing time
-    
-    # Final aggregation
-    workflow_state.step = "aggregation"
-    
-    total_words = sum(r["word_count"] for r in results)
-    total_chars = sum(r["character_count"] for r in results)
-    
-    final_result = {
-        "workflow_id": workflow_state.workflow_id,
-        "batch_summary": {
-            "total_texts_processed": len(results),
-            "total_words": total_words,
-            "total_characters": total_chars,
-            "average_words_per_text": total_words / len(results) if results else 0,
-            "average_chars_per_text": total_chars / len(results) if results else 0
-        },
-        "individual_results": results,
-        "completed_at": datetime.now().isoformat()
-    }
-    
-    workflow_state.step = "completed"
-    workflow_state.status = "success"
-    workflow_state.data["final_result"] = final_result
-    
-    return final_result
-
-# Advanced action with multiple parameters
-@app.action("advanced_search", "Perform advanced search with multiple filters")
-def advanced_search(
-    query: str,
-    category: str = "all",
-    min_score: float = 0.0,
-    max_results: int = 10,
-    include_metadata: bool = False,
-    sort_by: str = "relevance"
-):
-    """Advanced search function demonstrating complex parameter handling"""
-    
-    # Simulate search results
-    mock_results = [
-        {"id": 1, "title": f"Result matching '{query}'", "score": 0.95, "category": category},
-        {"id": 2, "title": f"Another match for '{query}'", "score": 0.87, "category": category},
-        {"id": 3, "title": f"Related to '{query}'", "score": 0.73, "category": category},
-    ]
-    
-    # Filter by score
-    filtered_results = [r for r in mock_results if r["score"] >= min_score]
-    
-    # Limit results
-    filtered_results = filtered_results[:max_results]
-    
-    # Sort results
-    if sort_by == "score":
-        filtered_results.sort(key=lambda x: x["score"], reverse=True)
-    
-    response = {
-        "query": query,
-        "filters": {
-            "category": category,
-            "min_score": min_score,
-            "max_results": max_results,
-            "sort_by": sort_by
-        },
-        "results": filtered_results,
-        "result_count": len(filtered_results)
-    }
-    
-    if include_metadata:
-        response["metadata"] = {
-            "search_performed_at": datetime.now().isoformat(),
-            "processing_time_ms": 45,
-            "total_available": len(mock_results)
-        }
-    
-    return response
-
-# Enable authentication (optional)
-# app.enable_auth("your-secret-jwt-key-here")
-
-# The app instance is automatically discovered by the Kalibr CLI
-# To run this: kalibr serve enhanced_kalibr_example.py --app-mode

kalibr-1.0.28.dist-info/METADATA

@@ -1,175 +0,0 @@
-Metadata-Version: 2.4
-Name: kalibr
-Version: 1.0.28
-Summary: Multi-Model MCP SDK — deploy to GPT, Claude, Gemini, Copilot from one codebase.
-Home-page: https://github.com/devonakelley/kalibr-sdk
-Author: Kalibr Team
-Author-email: team@kalibr.dev
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.110.1
-Requires-Dist: uvicorn>=0.25.0
-Requires-Dist: typer>=0.9.0
-Requires-Dist: pydantic>=2.6.4
-Requires-Dist: requests>=2.31.0
-Requires-Dist: aiofiles>=23.2.1
-Requires-Dist: jsonschema>=4.21.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# Kalibr SDK v1.0.28
-### Multi-Model AI Integration Framework
-
-**Write once. Deploy anywhere. Connect to any AI model.**
-
-Kalibr turns your Python functions into APIs that automatically work with **GPT Actions**, **Claude MCP**, **Gemini Extensions**, and **Copilot Plugins** — all from one codebase.  
-It’s the unified SDK layer for building, packaging, and deploying AI-ready endpoints.
-
----
-
-## 🧠 Core Purpose
-
-Kalibr is a **multi-model integration SDK** that converts simple Python functions into fully MCP-compatible APIs for every major AI model ecosystem.
-
-> One function → Four schemas → Deploy anywhere.
-
----
-
-## ⚙️ What It Does
-
-### 1. Unified Schema Generation
-
-Kalibr automatically generates and serves schemas for:
-- `/openapi.json` → GPT Actions
-- `/mcp.json` → Claude MCP
-- `/schemas/gemini` → Gemini Extensions
-- `/schemas/copilot` → Copilot Plugins
-- `/models/supported` → List of supported integrations
-
-No manual YAML or JSON schema creation needed.
-
----
-
-### 2. Environment-Aware Base URLs
-
-Kalibr auto-detects where it's running and sets the correct base URL automatically:
-
-| Environment | Example Base URL |
-|--------------|------------------|
-| Local | `http://localhost:8000` |
-| Fly.io | `https://<app>.fly.dev` |
-| Render | `https://<app>.onrender.com` |
-| Custom | Set via `KALIBR_BASE_URL` |
-
----
-
-### 3. Deployment & Runtime Abstraction
-
-Kalibr provides a single CLI entrypoint for local and hosted runtime deployment:
-
-```bash
-kalibr serve my_app.py
-kalibr deploy my_app.py --runtime fly|render|local
-kalibr version
-```
-
-Each runtime automatically generates valid schema URLs and deployment bundles (`Dockerfile`, `fly.toml`, etc).
-
----
-
-### 4. Two Development Modes
-
-#### Simple Mode (Function-Level)
-For lightweight APIs and test integrations.
-
-```python
-from kalibr import Kalibr
-
-app = Kalibr(title="Weather API")
-
-@app.action("get_weather", "Fetch weather data")
-def get_weather(city: str):
-    return {"city": city, "temp": 72, "condition": "sunny"}
-```
-
-#### Advanced Mode (Full App)
-
-```python
-from kalibr import KalibrApp
-from kalibr.types import FileUpload, Session
-
-app = KalibrApp(title="Document API")
-
-@app.file_handler("analyze_doc", [".pdf", ".docx"])
-async def analyze_doc(file: FileUpload):
-    return {"filename": file.filename, "result": "parsed"}
-
-@app.session_action("save_data")
-async def save_data(session: Session, data: dict):
-    session.set("data", data)
-    return {"saved": True}
-```
-
-Includes:
-- Async/await support  
-- File uploads  
-- Session persistence  
-- Streaming responses  
-- Workflow scaffolding  
-
----
-
-### 5. Built-in Routes
-
-| Endpoint | Purpose |
-|-----------|----------|
-| `/health` | Health + version check |
-| `/docs` | Swagger UI |
-| `/models/supported` | Shows model compatibility |
-| `/openapi.json`, `/mcp.json`, etc. | Model schemas |
-
----
-
-### 6. CLI Reference
-
-```
-kalibr serve my_app.py        # Run locally
-kalibr deploy my_app.py       # Deploy to Fly/Render
-kalibr examples               # Copy examples
-kalibr version                # Show SDK version
-```
-
----
-
-### 7. Value Proposition
-
-For developers or MCP infrastructure projects:
-
-- **Instant MCP onboarding** — one file → all model schemas  
-- **Zero config** — no schema or deployment setup required  
-- **Multi-runtime support** — local, Fly, Render, or custom hosts  
-- **Unified interface layer** — consistent schema output for all AI platforms  
-
----
-
-### 8. Upcoming Additions
-
-- Observability + tracing hooks  
-- Usage metering and billing  
-- Schema diffing / auto-validation  
-- Multi-runtime load routing  
-
----
-
-### License
-
-MIT License © 2025 Kalibr Team  
-
----
-
-**Kalibr SDK** — the unified layer between AI models and the real world.  
-Write once. Deploy anywhere. Integrate everything.

kalibr-1.0.28.dist-info/RECORD

@@ -1,19 +0,0 @@
-kalibr/__init__.py,sha256=0M3sG1no7m3EjMR_rwHfoWekMxswhFPbzfM0KfjF3eU,119
-kalibr/__main__.py,sha256=nRQLefjyoy9c_-UKU1UZGcCRrypQWchJAbUlmNFPv2g,8353
-kalibr/deployment.py,sha256=GZ874FXQX1uIroTA-UM5A-pTVn2UY0NxXi39vmTowyI,1396
-kalibr/kalibr.py,sha256=yrgXVlTgadBbpnX_l7fAxxjxGp9oxcZhzGjaQPiIcpo,10469
-kalibr/kalibr_app.py,sha256=5ylagvKEsGN6T6AFr9rWHaAjdWcpKdDG7nhDPUEQAQA,13809
-kalibr/packager.py,sha256=vrwviRzZMjegbDXyjZZwA7gsqchd5V6PZAZTi5WNjyQ,1353
-kalibr/runtime_router.py,sha256=PTXMj5yt72cfzYtjWQ-mUF3t8eov9nuXXI0ScIVNMrU,4606
-kalibr/schema_generators.py,sha256=xxnY05KgHTJ7BPXMCIC-McJCCt8aIOF5s0ptCwDqs_Y,6716
-kalibr/types.py,sha256=bNmf_cOWXBmhaMVAPEp3_EdRCcdXY2pbOgOxZ1dZ0Mc,3476
-kalibr/validator.py,sha256=PezDmHG9dVINce91rdYQstJC41eZP21qEA3VDICE3C4,2333
-kalibr-1.0.28.data/data/examples/README.md,sha256=loo2nm6yfT-pqGb5uNg1VeEdOKflYzHISUHTuSltfY0,4875
-kalibr-1.0.28.data/data/examples/basic_kalibr_example.py,sha256=Kfrh-XZuJ0vwFLB_xBpdqpgpMJw2NpIx0yBsqrAqBnE,2188
-kalibr-1.0.28.data/data/examples/enhanced_kalibr_example.py,sha256=AuhTpyRUNVAJuZKRy9iydXusNkBgQ84eKNiXxsr4iUQ,11994
-kalibr-1.0.28.dist-info/licenses/LICENSE,sha256=1WLJDkrueNpHCROy9zANrK2Ar2weqZ_z88hw90UKDoc,451
-kalibr-1.0.28.dist-info/METADATA,sha256=W1stKZstce3wcTk6RDNMPy6-OtoEW0wPKsqjZIHjU_M,4443
-kalibr-1.0.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kalibr-1.0.28.dist-info/entry_points.txt,sha256=KiJfV_BaeYdIdYniww3wnSBBqSHpRxP9BTLNwu7IjyY,48
-kalibr-1.0.28.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
-kalibr-1.0.28.dist-info/RECORD,,

kalibr-1.0.28.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-kalibr = kalibr.__main__:main

kalibr-1.0.28.dist-info/licenses/LICENSE

@@ -1,11 +0,0 @@
-Kalibr Source-Available License
-
-Copyright (c) 2025 Kalibr Systems.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
-for the purpose of internal evaluation, testing, or demonstration only.
-
-Commercial, production, or revenue-generating use of this software requires a valid commercial 
-license from Kalibr Systems (https://kalibr.systems).
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.