PraisonAI 3.0.0__py3-none-any.whl

praisonai/capabilities/fine_tuning.py

@@ -0,0 +1,293 @@
+"""
+Fine-tuning Capabilities Module
+
+Provides model fine-tuning functionality via LiteLLM.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Any, Dict, Literal
+
+
+@dataclass
+class FineTuningResult:
+    """Result from fine-tuning operations."""
+    id: str
+    object: str = "fine_tuning.job"
+    model: Optional[str] = None
+    status: Optional[str] = None
+    training_file: Optional[str] = None
+    validation_file: Optional[str] = None
+    fine_tuned_model: Optional[str] = None
+    created_at: Optional[int] = None
+    finished_at: Optional[int] = None
+    trained_tokens: Optional[int] = None
+    error: Optional[Dict[str, Any]] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def fine_tuning_create(
+    training_file: str,
+    model: str = "gpt-4o-mini-2024-07-18",
+    validation_file: Optional[str] = None,
+    hyperparameters: Optional[Dict[str, Any]] = None,
+    suffix: Optional[str] = None,
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> FineTuningResult:
+    """
+    Create a fine-tuning job.
+    
+    Args:
+        training_file: ID of the training file
+        model: Base model to fine-tune
+        validation_file: Optional validation file ID
+        hyperparameters: Training hyperparameters
+        suffix: Suffix for the fine-tuned model name
+        custom_llm_provider: Provider ("openai", "azure")
+        timeout: Request timeout in seconds
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        
+    Returns:
+        FineTuningResult with job ID
+        
+    Example:
+        >>> result = fine_tuning_create("file-abc123")
+        >>> print(result.id, result.status)
+    """
+    import litellm
+    
+    call_kwargs = {
+        'training_file': training_file,
+        'model': model,
+        'custom_llm_provider': custom_llm_provider,
+        'timeout': timeout,
+    }
+    
+    if validation_file:
+        call_kwargs['validation_file'] = validation_file
+    if hyperparameters:
+        call_kwargs['hyperparameters'] = hyperparameters
+    if suffix:
+        call_kwargs['suffix'] = suffix
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = litellm.create_fine_tuning_job(**call_kwargs)
+    
+    error = None
+    if hasattr(response, 'error') and response.error:
+        error = {
+            'code': getattr(response.error, 'code', None),
+            'message': getattr(response.error, 'message', None),
+        }
+    
+    return FineTuningResult(
+        id=getattr(response, 'id', ''),
+        object=getattr(response, 'object', 'fine_tuning.job'),
+        model=getattr(response, 'model', model),
+        status=getattr(response, 'status', None),
+        training_file=getattr(response, 'training_file', training_file),
+        validation_file=getattr(response, 'validation_file', validation_file),
+        fine_tuned_model=getattr(response, 'fine_tuned_model', None),
+        created_at=getattr(response, 'created_at', None),
+        finished_at=getattr(response, 'finished_at', None),
+        trained_tokens=getattr(response, 'trained_tokens', None),
+        error=error,
+    )
+
+
+async def afine_tuning_create(
+    training_file: str,
+    model: str = "gpt-4o-mini-2024-07-18",
+    validation_file: Optional[str] = None,
+    hyperparameters: Optional[Dict[str, Any]] = None,
+    suffix: Optional[str] = None,
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> FineTuningResult:
+    """
+    Async: Create a fine-tuning job.
+    
+    See fine_tuning_create() for full documentation.
+    """
+    import litellm
+    
+    call_kwargs = {
+        'training_file': training_file,
+        'model': model,
+        'custom_llm_provider': custom_llm_provider,
+        'timeout': timeout,
+    }
+    
+    if validation_file:
+        call_kwargs['validation_file'] = validation_file
+    if hyperparameters:
+        call_kwargs['hyperparameters'] = hyperparameters
+    if suffix:
+        call_kwargs['suffix'] = suffix
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = await litellm.acreate_fine_tuning_job(**call_kwargs)
+    
+    error = None
+    if hasattr(response, 'error') and response.error:
+        error = {
+            'code': getattr(response.error, 'code', None),
+            'message': getattr(response.error, 'message', None),
+        }
+    
+    return FineTuningResult(
+        id=getattr(response, 'id', ''),
+        object=getattr(response, 'object', 'fine_tuning.job'),
+        model=getattr(response, 'model', model),
+        status=getattr(response, 'status', None),
+        training_file=getattr(response, 'training_file', training_file),
+        validation_file=getattr(response, 'validation_file', validation_file),
+        fine_tuned_model=getattr(response, 'fine_tuned_model', None),
+        created_at=getattr(response, 'created_at', None),
+        finished_at=getattr(response, 'finished_at', None),
+        trained_tokens=getattr(response, 'trained_tokens', None),
+        error=error,
+    )
+
+
+def fine_tuning_list(
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    after: Optional[str] = None,
+    limit: int = 20,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> List[FineTuningResult]:
+    """
+    List fine-tuning jobs.
+    
+    Args:
+        custom_llm_provider: Provider
+        after: Cursor for pagination
+        limit: Maximum number of jobs to return
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        
+    Returns:
+        List of FineTuningResult objects
+    """
+    import litellm
+    
+    call_kwargs = {
+        'custom_llm_provider': custom_llm_provider,
+        'limit': limit,
+    }
+    
+    if after:
+        call_kwargs['after'] = after
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = litellm.list_fine_tuning_jobs(**call_kwargs)
+    
+    results = []
+    data = getattr(response, 'data', response) if hasattr(response, 'data') else response
+    if isinstance(data, list):
+        for item in data:
+            error = None
+            if hasattr(item, 'error') and item.error:
+                error = {
+                    'code': getattr(item.error, 'code', None),
+                    'message': getattr(item.error, 'message', None),
+                }
+            
+            results.append(FineTuningResult(
+                id=getattr(item, 'id', ''),
+                object=getattr(item, 'object', 'fine_tuning.job'),
+                model=getattr(item, 'model', None),
+                status=getattr(item, 'status', None),
+                training_file=getattr(item, 'training_file', None),
+                validation_file=getattr(item, 'validation_file', None),
+                fine_tuned_model=getattr(item, 'fine_tuned_model', None),
+                created_at=getattr(item, 'created_at', None),
+                finished_at=getattr(item, 'finished_at', None),
+                trained_tokens=getattr(item, 'trained_tokens', None),
+                error=error,
+            ))
+    
+    return results
+
+
+async def afine_tuning_list(
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    after: Optional[str] = None,
+    limit: int = 20,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> List[FineTuningResult]:
+    """
+    Async: List fine-tuning jobs.
+    
+    See fine_tuning_list() for full documentation.
+    """
+    import litellm
+    
+    call_kwargs = {
+        'custom_llm_provider': custom_llm_provider,
+        'limit': limit,
+    }
+    
+    if after:
+        call_kwargs['after'] = after
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = await litellm.alist_fine_tuning_jobs(**call_kwargs)
+    
+    results = []
+    data = getattr(response, 'data', response) if hasattr(response, 'data') else response
+    if isinstance(data, list):
+        for item in data:
+            error = None
+            if hasattr(item, 'error') and item.error:
+                error = {
+                    'code': getattr(item.error, 'code', None),
+                    'message': getattr(item.error, 'message', None),
+                }
+            
+            results.append(FineTuningResult(
+                id=getattr(item, 'id', ''),
+                object=getattr(item, 'object', 'fine_tuning.job'),
+                model=getattr(item, 'model', None),
+                status=getattr(item, 'status', None),
+                training_file=getattr(item, 'training_file', None),
+                validation_file=getattr(item, 'validation_file', None),
+                fine_tuned_model=getattr(item, 'fine_tuned_model', None),
+                created_at=getattr(item, 'created_at', None),
+                finished_at=getattr(item, 'finished_at', None),
+                trained_tokens=getattr(item, 'trained_tokens', None),
+                error=error,
+            ))
+    
+    return results

praisonai/capabilities/guardrails.py

@@ -0,0 +1,182 @@
+"""
+Guardrails Capabilities Module
+
+Provides content guardrails and safety checks functionality.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Any, Dict, List
+
+
+@dataclass
+class GuardrailResult:
+    """Result from guardrail check."""
+    passed: bool
+    violations: Optional[List[Dict[str, Any]]] = None
+    modified_content: Optional[str] = None
+    original_content: Optional[str] = None
+    guardrail_name: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def apply_guardrail(
+    content: str,
+    guardrail_name: str = "default",
+    rules: Optional[List[str]] = None,
+    model: str = "gpt-4o-mini",
+    timeout: float = 60.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> GuardrailResult:
+    """
+    Apply a guardrail to content.
+    
+    Args:
+        content: Content to check
+        guardrail_name: Name of the guardrail
+        rules: List of rules to apply
+        model: Model to use for guardrail checking
+        timeout: Request timeout in seconds
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        metadata: Optional metadata for tracing
+        
+    Returns:
+        GuardrailResult with check results
+        
+    Example:
+        >>> result = apply_guardrail("Some content", rules=["no_pii", "no_profanity"])
+        >>> print(result.passed)
+    """
+    import litellm
+    
+    # Build guardrail prompt
+    rules_text = ""
+    if rules:
+        rules_text = "\n".join(f"- {rule}" for rule in rules)
+    else:
+        rules_text = """- No personally identifiable information (PII)
+- No profanity or offensive language
+- No harmful or dangerous content
+- No misinformation"""
+    
+    check_prompt = f"""You are a content guardrail. Check the following content against these rules:
+
+{rules_text}
+
+Content to check:
+{content}
+
+Respond with a JSON object:
+{{"passed": true/false, "violations": ["list of violations if any"], "modified_content": "cleaned content if needed"}}
+
+Only respond with the JSON, no other text."""
+
+    try:
+        response = litellm.completion(
+            model=model,
+            messages=[{"role": "user", "content": check_prompt}],
+            timeout=timeout,
+            api_key=api_key,
+            api_base=api_base,
+            response_format={"type": "json_object"},
+            **kwargs
+        )
+        
+        import json
+        result_text = response.choices[0].message.content
+        result_data = json.loads(result_text)
+        
+        return GuardrailResult(
+            passed=result_data.get("passed", True),
+            violations=result_data.get("violations"),
+            modified_content=result_data.get("modified_content"),
+            original_content=content,
+            guardrail_name=guardrail_name,
+            metadata=metadata or {},
+        )
+    except Exception as e:
+        # On error, fail safe (pass through)
+        return GuardrailResult(
+            passed=True,
+            violations=None,
+            modified_content=None,
+            original_content=content,
+            guardrail_name=guardrail_name,
+            metadata={"error": str(e), **(metadata or {})},
+        )
+
+
+async def aapply_guardrail(
+    content: str,
+    guardrail_name: str = "default",
+    rules: Optional[List[str]] = None,
+    model: str = "gpt-4o-mini",
+    timeout: float = 60.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> GuardrailResult:
+    """
+    Async: Apply a guardrail to content.
+    
+    See apply_guardrail() for full documentation.
+    """
+    import litellm
+    
+    rules_text = ""
+    if rules:
+        rules_text = "\n".join(f"- {rule}" for rule in rules)
+    else:
+        rules_text = """- No personally identifiable information (PII)
+- No profanity or offensive language
+- No harmful or dangerous content
+- No misinformation"""
+    
+    check_prompt = f"""You are a content guardrail. Check the following content against these rules:
+
+{rules_text}
+
+Content to check:
+{content}
+
+Respond with a JSON object:
+{{"passed": true/false, "violations": ["list of violations if any"], "modified_content": "cleaned content if needed"}}
+
+Only respond with the JSON, no other text."""
+
+    try:
+        response = await litellm.acompletion(
+            model=model,
+            messages=[{"role": "user", "content": check_prompt}],
+            timeout=timeout,
+            api_key=api_key,
+            api_base=api_base,
+            response_format={"type": "json_object"},
+            **kwargs
+        )
+        
+        import json
+        result_text = response.choices[0].message.content
+        result_data = json.loads(result_text)
+        
+        return GuardrailResult(
+            passed=result_data.get("passed", True),
+            violations=result_data.get("violations"),
+            modified_content=result_data.get("modified_content"),
+            original_content=content,
+            guardrail_name=guardrail_name,
+            metadata=metadata or {},
+        )
+    except Exception as e:
+        return GuardrailResult(
+            passed=True,
+            violations=None,
+            modified_content=None,
+            original_content=content,
+            guardrail_name=guardrail_name,
+            metadata={"error": str(e), **(metadata or {})},
+        )