AI Agent Generator

import uuid
import json
import re
from typing import Any, Dict, List, Optional
from datetime import datetime

def generate_unique_id(prefix: str = "") -> str:
    """Generuje unikalny identyfikator"""
    unique_id = str(uuid.uuid4())
    if prefix:
        return f"{prefix}_{unique_id}"
    return unique_id

def validate_json_schema(data: Dict[str, Any], schema: Dict[str, Any]) -> Dict[str, Any]:
    """Podstawowa walidacja JSON schema"""
    errors = []
    
    # Sprawdź wymagane pola
    required_fields = schema.get("required", [])
    for field in required_fields:
        if field not in data:
            errors.append(f"Missing required field: {field}")
    
    # Sprawdź typy
    properties = schema.get("properties", {})
    for field, field_schema in properties.items():
        if field in data:
            expected_type = field_schema.get("type")
            actual_value = data[field]
            
            if not _validate_type(actual_value, expected_type):
                errors.append(f"Invalid type for field {field}: expected {expected_type}")
    
    return {
        "valid": len(errors) == 0,
        "errors": errors
    }

def _validate_type(value: Any, expected_type: str) -> bool:
    """Waliduje typ wartości"""
    type_mapping = {
        "string": str,
        "integer": int,
        "number": (int, float),
        "boolean": bool,
        "array": list,
        "object": dict
    }
    
    expected_python_type = type_mapping.get(expected_type)
    if expected_python_type is None:
        return True  # Unknown type, assume valid
    
    return isinstance(value, expected_python_type)

def sanitize_string(text: str, max_length: int = 1000) -> str:
    """Czyści i sanityzuje tekst"""
    if not isinstance(text, str):
        text = str(text)
    
    # Usuń niebezpieczne znaki
    text = re.sub(r'[<>"\']', '', text)
    
    # Ogranicz długość
    if len(text) > max_length:
        text = text[:max_length] + "..."
    
    return text.strip()

def format_timestamp(dt: datetime = None) -> str:
    """Formatuje timestamp"""
    if dt is None:
        dt = datetime.now()
    return dt.isoformat()

def parse_configuration(config: Dict[str, Any], defaults: Dict[str, Any] = None) -> Dict[str, Any]:
    """Parsuje i waliduje konfigurację"""
    if defaults is None:
        defaults = {}
    
    # Scal z domyślnymi wartościami
    result = {**defaults, **config}
    
    # Waliduj kluczowe pola
    if "temperature" in result:
        temp = result["temperature"]
        if not isinstance(temp, (int, float)) or temp < 0 or temp > 2:
            result["temperature"] = 0.7
    
    if "max_tokens" in result:
        tokens = result["max_tokens"]
        if not isinstance(tokens, int) or tokens < 1:
            result["max_tokens"] = 1000
    
    return result

def extract_urls_from_text(text: str) -> List[str]:
    """Wyciąga URL-e z tekstu"""
    url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
    return re.findall(url_pattern, text)

def extract_emails_from_text(text: str) -> List[str]:
    """Wyciąga adresy email z tekstu"""
    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
    return re.findall(email_pattern, text)

def calculate_text_similarity(text1: str, text2: str) -> float:
    """Oblicza podobieństwo między tekstami (prosty algorytm)"""
    if not text1 or not text2:
        return 0.0
    
    # Konwertuj do małych liter i podziel na słowa
    words1 = set(text1.lower().split())
    words2 = set(text2.lower().split())
    
    # Oblicz Jaccard similarity
    intersection = len(words1.intersection(words2))
    union = len(words1.union(words2))
    
    if union == 0:
        return 0.0
    
    return intersection / union

def chunk_text(text: str, chunk_size: int = 1000, overlap: int = 100) -> List[str]:
    """Dzieli tekst na mniejsze części z nakładaniem"""
    if len(text) <= chunk_size:
        return [text]
    
    chunks = []
    start = 0
    
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        
        # Znajdź najlepsze miejsce podziału (koniec zdania)
        if end < len(text):
            last_period = chunk.rfind('.')
            last_newline = chunk.rfind('\n')
            split_point = max(last_period, last_newline)
            
            if split_point > start + chunk_size // 2:
                chunk = text[start:start + split_point + 1]
                end = start + split_point + 1
        
        chunks.append(chunk.strip())
        start = end - overlap
        
        if start >= len(text):
            break
    
    return chunks

def estimate_tokens(text: str) -> int:
    """Szacuje liczbę tokenów w tekście"""
    # Prosty szacunek: ~4 znaki na token
    return len(text) // 4

def format_file_size(size_bytes: int) -> str:
    """Formatuje rozmiar pliku"""
    if size_bytes == 0:
        return "0 B"
    
    size_names = ["B", "KB", "MB", "GB", "TB"]
    import math
    i = int(math.floor(math.log(size_bytes, 1024)))
    p = math.pow(1024, i)
    s = round(size_bytes / p, 2)
    
    return f"{s} {size_names[i]}"

def is_valid_email(email: str) -> bool:
    """Sprawdza czy email ma poprawny format"""
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None

def is_valid_url(url: str) -> bool:
    """Sprawdza czy URL ma poprawny format"""
    pattern = r'^https?://(?:[-\w.])+(?:[:\d]+)?(?:/(?:[\w/_.])*(?:\?(?:[\w&=%.])*)?(?:#(?:\w*))?)?$'
    return re.match(pattern, url) is not None

def merge_dictionaries(dict1: Dict[str, Any], dict2: Dict[str, Any], deep: bool = True) -> Dict[str, Any]:
    """Łączy słowniki z opcją głębokiego łączenia"""
    if not deep:
        return {**dict1, **dict2}
    
    result = dict1.copy()
    
    for key, value in dict2.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = merge_dictionaries(result[key], value, deep=True)
        else:
            result[key] = value
    
    return result

def flatten_dictionary(d: Dict[str, Any], parent_key: str = '', sep: str = '.') -> Dict[str, Any]:
    """Spłaszcza zagnieżdżony słownik"""
    items = []
    
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        
        if isinstance(v, dict):
            items.extend(flatten_dictionary(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    
    return dict(items)

def safe_json_loads(json_str: str, default: Any = None) -> Any:
    """Bezpieczne parsowanie JSON"""
    try:
        return json.loads(json_str)
    except (json.JSONDecodeError, TypeError):
        return default

def safe_json_dumps(obj: Any, default: str = "{}") -> str:
    """Bezpieczne serializowanie JSON"""
    try:
        return json.dumps(obj, ensure_ascii=False, indent=2)
    except (TypeError, ValueError):
        return default