kalibr 1.0.25__py3-none-any.whl → 1.1.2a0__py3-none-any.whl

kalibr-1.0.25.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.25.dist-info/METADATA

@@ -1,231 +0,0 @@
-Metadata-Version: 2.4
-Name: kalibr
-Version: 1.0.25
-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  
-### Multi-Model AI Integration Framework
-
-**Write once. Deploy anywhere. Connect to any AI model.**
-
-Kalibr turns Python functions into APIs that work seamlessly with GPT, Claude, Gemini, and Copilot — automatically generating model-specific schemas and endpoints.
-
----
-
-## 🚀 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 All Schemas
-Kalibr now **auto-detects your environment** and generates the correct base URLs.
-
-| Environment | Example Base URL |
-|--------------|------------------|
-| Local Dev | `http://localhost:8000` |
-| Fly.io | `https://<app-name>.fly.dev` |
-| Custom Host | Use `KALIBR_BASE_URL` env var |
-
-Then open:
-```
-<your-base-url>/gpt-actions.json    # ChatGPT
-<your-base-url>/mcp.json            # Claude
-<your-base-url>/schemas/gemini      # Gemini
-<your-base-url>/schemas/copilot     # Copilot
-```
-
----
-
-## 🧠 What Kalibr Does
-
-Kalibr turns your Python functions into production-ready multi-model APIs.
-
-```python
-from kalibr import Kalibr
-
-app = Kalibr(title="Inventory API")
-
-@app.action("get_inventory", "Fetch inventory data")
-def get_inventory(product_id: str):
-    return {"product_id": product_id, "stock": 42}
-```
-
-Result:  
-ChatGPT, Claude, Gemini, and Copilot can all call `get_inventory()` using their native protocols — no schema work required.
-
----
-
-## 💪 Two Modes
-
-### **Function-Level (Simple)**
-Ideal for one-off APIs or scripts.
-
-```python
-from kalibr import Kalibr
-
-app = Kalibr(title="My API")
-
-@app.action("calculate_price", "Calculate price total")
-def calculate_price(product_id: str, quantity: int):
-    return {"total": quantity * 19.99}
-```
-
-### **App-Level (Advanced)**
-Use `KalibrApp` for complete control — file uploads, sessions, streaming, and 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 session data")
-async def save_data(session: Session, data: dict):
-    session.set("my_data", data)
-    return {"saved": True}
-```
-
----
-
-## 📚 Examples Included
-
-After running `kalibr-connect examples`, you’ll get:
-
-- `basic_kalibr_example.py` – simple function-level demo  
-- `enhanced_kalibr_example.py` – full app with sessions, uploads, and streaming  
-
----
-
-## 🤖 AI Platform Integration
-
-### ChatGPT (GPT Actions)
-1. Copy schema URL:  
-   `https://<your-domain>/gpt-actions.json`
-2. In GPT Builder → *Actions* → *Import from URL*
-3. Done — ChatGPT can call your endpoints.
-
-### Claude (MCP)
-Add to Claude Desktop config:
-```json
-{
-  "mcp": {
-    "servers": {
-      "my-api": {
-        "url": "https://<your-domain>/mcp.json"
-      }
-    }
-  }
-}
-```
-
-### Gemini / Copilot
-Use:
-```
-https://<your-domain>/schemas/gemini
-https://<your-domain>/schemas/copilot
-```
-
----
-
-## 🎯 Common Use Cases
-
-- **Customer Service APIs** — let AI handle orders or refunds  
-- **Data Analysis** — query your analytics through AI  
-- **Document Processing** — parse or summarize uploaded docs  
-- **Business Automation** — trigger internal workflows  
-- **Internal Tools** — expose secure internal logic to assistants  
-
----
-
-## 🔧 CLI Reference
-
-```bash
-kalibr-connect examples          # Copy examples
-kalibr-connect serve my_app.py   # Run locally
-kalibr-connect version           # Show version
-kalibr-connect --help            # Full CLI
-```
-
----
-
-## ⚡ Key Features
-
-✅ Multi-Model Support — GPT, Claude, Gemini, Copilot  
-✅ Automatic Schema Generation  
-✅ Environment-Aware Base URLs (v1.0.21+)  
-✅ File Uploads  
-✅ Session Management  
-✅ Streaming Responses  
-✅ Workflow Support  
-✅ Type-Safe API Generation  
-✅ Async / Await Ready  
-
----
-
-## 🔥 Why Kalibr?
-
-Without Kalibr:
-- Learn 4 model specs  
-- Maintain 4 codebases  
-- Duplicate effort  
-
-With Kalibr:
-- One Python function  
-- Four schemas generated automatically  
-- Deploy anywhere  
-
----
-
-## 🆕 Version 1.0.21+
-
-- **Automatic Base-URL Detection**  
-  - Works with `KALIBR_BASE_URL` or `FLY_APP_NAME`  
-  - Fixes all localhost references in deployed schemas  
-- Ready for **MCP ecosystem production use**  
-- Drop-in backwards compatibility  
-
----
-
-## 🧩 License
-
-MIT License — see `LICENSE` file for details.  
-
----
-
-**Kalibr SDK — the unified layer between AI models and the real world.**  
-Write once. Deploy anywhere. Integrate everything.

kalibr-1.0.25.dist-info/RECORD

@@ -1,19 +0,0 @@
-kalibr/__init__.py,sha256=sm5S95QKw1J7NbsrdgJAd9sdn8wfO_mbEfRhytJ0_wg,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.25.data/data/examples/README.md,sha256=loo2nm6yfT-pqGb5uNg1VeEdOKflYzHISUHTuSltfY0,4875
-kalibr-1.0.25.data/data/examples/basic_kalibr_example.py,sha256=Kfrh-XZuJ0vwFLB_xBpdqpgpMJw2NpIx0yBsqrAqBnE,2188
-kalibr-1.0.25.data/data/examples/enhanced_kalibr_example.py,sha256=AuhTpyRUNVAJuZKRy9iydXusNkBgQ84eKNiXxsr4iUQ,11994
-kalibr-1.0.25.dist-info/licenses/LICENSE,sha256=1WLJDkrueNpHCROy9zANrK2Ar2weqZ_z88hw90UKDoc,451
-kalibr-1.0.25.dist-info/METADATA,sha256=78UxEYfpZk_-ijfDXhQ-v6DcDQF1TE9kkETi8cmVJZo,5424
-kalibr-1.0.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kalibr-1.0.25.dist-info/entry_points.txt,sha256=KiJfV_BaeYdIdYniww3wnSBBqSHpRxP9BTLNwu7IjyY,48
-kalibr-1.0.25.dist-info/top_level.txt,sha256=OkloC5_IfpE4-QwI30aLIYbFZk_-ChABWF7aBGddy28,7
-kalibr-1.0.25.dist-info/RECORD,,

kalibr-1.0.25.dist-info/entry_points.txt

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

kalibr-1.0.25.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.

kalibr-1.0.25.dist-info/top_level.txt

@@ -1 +0,0 @@
-kalibr