kalibr 1.0.17__py3-none-any.whl → 1.0.20__py3-none-any.whl

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

@@ -0,0 +1,347 @@
+"""
+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.20.dist-info/METADATA

@@ -0,0 +1,302 @@
+Metadata-Version: 2.4
+Name: kalibr
+Version: 1.0.20
+Summary: Multi-Model AI Integration Framework
+Home-page: https://github.com/devonakelley/kalibr-sdk
+Author: Kalibr Team
+Author-email: Kalibr Team <team@kalibr.dev>
+License: MIT
+Project-URL: Homepage, https://kalibr.dev
+Project-URL: Documentation, https://kalibr.dev/docs
+Project-URL: Repository, https://github.com/devonakelley/kalibr-sdk
+Project-URL: Bug Reports, https://github.com/devonakelley/kalibr-sdk/issues
+Keywords: ai,api,framework,gpt,claude,gemini,copilot,multi-model,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+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: pydantic>=2.6.4
+Requires-Dist: typer>=0.9.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: passlib[bcrypt]>=1.7.4
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: motor>=3.3.1
+Requires-Dist: pymongo>=4.5.0
+Requires-Dist: boto3>=1.34.129
+Requires-Dist: aiofiles>=23.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: black>=24.1.1; extra == "dev"
+Requires-Dist: isort>=5.13.2; extra == "dev"
+Requires-Dist: flake8>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Kalibr SDK
+
+**Multi-Model AI Integration Framework**
+
+Write once. Deploy anywhere. Connect to any AI model.
+
+Kalibr lets you expose Python functions as APIs that work with **GPT, Claude, Gemini, and Copilot** automatically.
+
+[![PyPI version](https://badge.fury.io/py/kalibr.svg)](https://badge.fury.io/py/kalibr)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## 🚀 Quick Start (2 minutes)
+
+### 1. Install
+```bash
+pip install kalibr
+```
+
+### 2. Get Examples
+```bash
+kalibr-connect examples
+```
+
+This copies example files to `./kalibr_examples/` in your current directory.
+
+### 3. Run Demo
+```bash
+kalibr-connect serve kalibr_examples/basic_kalibr_example.py
+```
+
+### 4. See Multi-Model Schemas
+
+Open your browser to see all 4 AI model schemas auto-generated:
+
+```
+http://localhost:8000/                    # API info
+http://localhost:8000/gpt-actions.json    # For ChatGPT
+http://localhost:8000/mcp.json            # For Claude
+http://localhost:8000/schemas/gemini      # For Gemini
+http://localhost:8000/schemas/copilot     # For Copilot
+http://localhost:8000/docs                # Interactive docs
+```
+
+**That's it!** One Python file, four AI platform schemas. 🎯
+
+---
+
+## 🎯 What Does This Do?
+
+Kalibr turns your Python functions into APIs that AI assistants can call:
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="My Business API")
+
+@app.action("get_inventory", "Check product stock")
+def get_inventory(product_id: str):
+    # Your business logic
+    return {"product_id": product_id, "stock": 42}
+```
+
+**Result:** ChatGPT, Claude, Gemini, and Copilot can all call your `get_inventory` function!
+
+---
+
+## 💪 Two Modes
+
+### Function-Level (Simple)
+Perfect for exposing business logic:
+
+```python
+from kalibr import Kalibr
+
+app = Kalibr(title="My API")
+
+@app.action("calculate_price", "Calculate product price")
+def calculate_price(product_id: str, quantity: int):
+    return {"total": quantity * get_price(product_id)}
+```
+
+### App-Level (Advanced)
+Full framework with file uploads, sessions, streaming, workflows:
+
+```python
+from kalibr import KalibrApp
+from kalibr.types import FileUpload, Session
+
+app = KalibrApp(title="Advanced API")
+
+@app.file_handler("analyze_doc", [".pdf", ".docx"])
+async def analyze_doc(file: FileUpload):
+    return {"filename": file.filename, "analysis": "..."}
+
+@app.session_action("save_data", "Save to session")
+async def save_data(session: Session, data: dict):
+    session.set("my_data", data)
+    return {"saved": True}
+
+@app.stream_action("live_feed", "Stream real-time data")
+async def live_feed(count: int = 10):
+    for i in range(count):
+        yield {"item": i, "timestamp": "..."}
+```
+
+---
+
+## 📚 Examples Included
+
+After running `kalibr-connect examples`, you get:
+
+- **`basic_kalibr_example.py`** - Simple function-level example
+- **`enhanced_kalibr_example.py`** - Advanced app-level example with all features
+
+---
+
+## 🤖 AI Platform Integration
+
+Once your Kalibr app is running, integrate with AI platforms:
+
+### ChatGPT (GPT Actions)
+1. Copy schema from `http://localhost:8000/gpt-actions.json`
+2. Go to GPT Builder → Actions → Import from URL
+3. Done! ChatGPT can now call your functions
+
+### Claude (MCP)
+1. Add to Claude Desktop config:
+```json
+{
+  "mcp": {
+    "servers": {
+      "my-api": {
+        "url": "http://localhost:8000/mcp.json"
+      }
+    }
+  }
+}
+```
+2. Done! Claude can now call your functions
+
+### Gemini & Copilot
+Similar simple setup using their respective schema endpoints.
+
+---
+
+## 🎯 Use Cases
+
+- **Customer Service APIs** - Let AI assistants look up orders, process refunds
+- **Data Analysis APIs** - Let AI query your analytics and generate insights
+- **Document Processing** - Let AI analyze uploaded documents
+- **Business Automation** - Let AI trigger workflows in your systems
+- **Internal Tools** - Give your team AI-powered access to internal systems
+
+---
+
+## 📖 Documentation
+
+- **Quick Start**: You're reading it!
+- **Full Docs**: See `KALIBR_SDK_COMPLETE.md` in the package
+- **Examples**: Run `kalibr-connect examples`
+- **CLI Help**: `kalibr-connect --help`
+
+---
+
+## 🔧 CLI Commands
+
+```bash
+kalibr-connect examples          # Copy example files to current dir
+kalibr-connect serve my_app.py   # Run your app locally
+kalibr-connect version           # Show version info
+kalibr-connect --help            # Show all commands
+```
+
+---
+
+## ⚡ Key Features
+
+- ✅ **Multi-Model Support** - Works with GPT, Claude, Gemini, Copilot
+- ✅ **Automatic Schemas** - No manual schema writing
+- ✅ **File Uploads** - Handle document uploads
+- ✅ **Sessions** - Stateful conversations
+- ✅ **Streaming** - Real-time data streaming
+- ✅ **Workflows** - Multi-step processes
+- ✅ **Type Safe** - Full Python type hints
+- ✅ **Fast** - Async/await support
+
+---
+
+## 🔥 Why Kalibr?
+
+**Without Kalibr:**
+- Learn 4 different API specs
+- Write 4 different schemas
+- Maintain 4 codebases
+- = Weeks of work
+
+**With Kalibr:**
+- Write Python functions once
+- Kalibr generates all 4 schemas
+- Single codebase
+- = One day of work
+
+---
+
+## 💡 Simple Example
+
+```python
+# my_app.py
+from kalibr import Kalibr
+
+app = Kalibr(title="Weather API")
+
+@app.action("get_weather", "Get current weather")
+def get_weather(city: str):
+    # Your logic here
+    return {"city": city, "temp": 72, "condition": "sunny"}
+```
+
+```bash
+# Run it
+kalibr-connect serve my_app.py
+
+# Now ALL these work:
+# ✅ ChatGPT can call get_weather()
+# ✅ Claude can call get_weather()
+# ✅ Gemini can call get_weather()
+# ✅ Copilot can call get_weather()
+```
+
+---
+
+## 🚀 Get Started Now
+
+```bash
+pip install kalibr
+kalibr-connect examples
+kalibr-connect serve kalibr_examples/basic_kalibr_example.py
+```
+
+Open http://localhost:8000 and see your multi-model API in action! 🎯
+
+---
+
+## 📝 License
+
+MIT License - see LICENSE file for details.
+
+---
+
+**Kalibr SDK** - Transform how you build AI-integrated applications! 🚀

kalibr-1.0.20.dist-info/RECORD

@@ -0,0 +1,16 @@
+kalibr/__init__.py,sha256=1IIl43EB3tAsP1anJhi63PyD9Cx-cOGYPGJ9eKbAB0s,188
+kalibr/__main__.py,sha256=Hl_-_vfimqHWZEwAUl4_OjrUWb1l7pM4q_13wbDI6gY,25584
+kalibr/deployment.py,sha256=B-2ePPCMF2UcnkM2YKkAoaNrOjpUKUGfNO0IxyNOJMI,670
+kalibr/kalibr.py,sha256=yrgXVlTgadBbpnX_l7fAxxjxGp9oxcZhzGjaQPiIcpo,10469
+kalibr/kalibr_app.py,sha256=gNQprofiDk8CUk0oxC8kwRiOt32VkoRhKc2t6cgD3IA,19307
+kalibr/schema_generators.py,sha256=nIgoYaO0FGC6arHdUHG0XaGDpJDycJeWDDC1-zAHzfI,7528
+kalibr/types.py,sha256=bNmf_cOWXBmhaMVAPEp3_EdRCcdXY2pbOgOxZ1dZ0Mc,3476
+kalibr-1.0.20.data/data/examples/README.md,sha256=loo2nm6yfT-pqGb5uNg1VeEdOKflYzHISUHTuSltfY0,4875
+kalibr-1.0.20.data/data/examples/basic_kalibr_example.py,sha256=Kfrh-XZuJ0vwFLB_xBpdqpgpMJw2NpIx0yBsqrAqBnE,2188
+kalibr-1.0.20.data/data/examples/enhanced_kalibr_example.py,sha256=AuhTpyRUNVAJuZKRy9iydXusNkBgQ84eKNiXxsr4iUQ,11994
+kalibr-1.0.20.dist-info/licenses/LICENSE,sha256=1WLJDkrueNpHCROy9zANrK2Ar2weqZ_z88hw90UKDoc,451
+kalibr-1.0.20.dist-info/METADATA,sha256=mKCIVFrYPVFhl2XUidHMI21O8_-L8VNVvarWmshJO8E,7965
+kalibr-1.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kalibr-1.0.20.dist-info/entry_points.txt,sha256=T-DOrFEZb0fZxA9H8sSCh-2zKxdjnmpzIRmm5TY_f6s,56
+kalibr-1.0.20.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
+kalibr-1.0.20.dist-info/RECORD,,