deepseek_client.py

import random
import os
from typing import Dict, List, Optional, Any
import logging
import json
import asyncio
from pathlib import Path
import httpx

class DeepSeekClient:
    """
    Asynchroniczny klient do komunikacji z API DeepSeek dla analizy dokumentów przetargowych
    """
    
    def __init__(self, api_key: str, base_url: str):
        """
        Inicjalizuje klienta DeepSeek.
        
        Args:
            api_key: Klucz API do DeepSeek
            base_url: Bazowy URL API DeepSeek
        """
        self.api_key = api_key
        self.base_url = base_url.rstrip('/')
        self.logger = logging.getLogger(__name__)
        
        # Konfiguracja asynchronicznego klienta HTTP
        self.client = httpx.AsyncClient(
            base_url=self.base_url,
            headers={
                'Authorization': f'Bearer {self.api_key}',
                'Content-Type': 'application/json'
            },
            timeout=60.0
        )
        
        # Domyślne parametry dla zapytań
        self.default_params = {
            'temperature': 0.3,
            'max_tokens': 2000,
            'model': 'deepseek-chat'
        }

    async def analyze_text(
        self,
        prompt: str,
        content: str,
        temperature: float = 0.3,
        max_tokens: int = 2000,
        max_retries: int = 3,
        retry_delay: float = 1.0
    ) -> Dict:
        """
        Analizuje tekst używając API DeepSeek.
        
        Args:
            prompt: Prompt dla modelu
            content: Tekst do analizy
            temperature: Temperatura generowania (0-1)
            max_tokens: Maksymalna długość odpowiedzi
            max_retries: Maksymalna liczba prób
            retry_delay: Podstawowe opóźnienie między próbami (w sekundach)
            
        Returns:
            Dict: Odpowiedź od API
            
        Raises:
            ValueError: Gdy odpowiedź ma nieprawidłową strukturę
            httpx.HTTPError: Przy błędach komunikacji z API
        """
        retries = 0
        last_error = None
        
        while retries < max_retries:
            try:
                request_data = {
                    'model': self.default_params['model'],
                    'messages': [
                        {
                            'role': 'system',
                            'content': 'Jesteś ekspertem w analizie dokumentów przetargowych. ' 
                                     'Zawsze odpowiadasz w poprawnym formacie JSON.'
                        },
                        {
                            'role': 'user',
                            'content': f"{prompt}\n\nTekst do analizy:\n{content}"
                        }
                    ],
                    'temperature': temperature,
                    'max_tokens': max_tokens,
                    'response_format': {"type": "json_object"}
                }
                
                self.logger.debug(f"Wysyłanie zapytania do API (próba {retries + 1}/{max_retries})")
                response = await self.client.post(  # Użyj self.client bez otwierania nowego kontekstu
                    '/v1/chat/completions',
                    json=request_data
                )
                response.raise_for_status()
                response_data = response.json()
                
                # Sprawdź strukturę odpowiedzi
                if 'choices' not in response_data or not response_data['choices']:
                    raise ValueError("Nieprawidłowa struktura odpowiedzi: brak choices")
                    
                choice = response_data['choices'][0]
                if 'message' not in choice or 'content' not in choice['message']:
                    raise ValueError("Nieprawidłowa struktura odpowiedzi: brak message/content")
                
                content = choice['message']['content']
                
                # Próba parsowania JSON
                try:
                    parsed_content = json.loads(content)
                    return parsed_content
                except json.JSONDecodeError as e:
                    self.logger.error(f"Nie udało się sparsować odpowiedzi jako JSON: {content}")
                    raise ValueError(f"Odpowiedź nie jest prawidłowym JSON: {str(e)}")

            except (httpx.HTTPError, ValueError) as e:
                last_error = e
                retries += 1
                
                if retries < max_retries:
                    # Exponential backoff z jitterem
                    wait_time = retry_delay * (2 ** (retries - 1)) * (0.5 + random.random())
                    self.logger.warning(
                        f"Próba {retries} nie powiodła się: {str(e)}. "
                        f"Czekam {wait_time:.2f}s przed ponowieniem..."
                    )
                    await asyncio.sleep(wait_time)
                    continue
                    
                self.logger.error(f"Wszystkie {max_retries} prób nie powiodły się")
                break

        raise last_error

    async def analyze_criteria(self, brief_content: str) -> List[Dict]:
        """
        Analizuje brief/SIWZ w poszukiwaniu kryteriów oceny.
        
        Args:
            brief_content: Treść dokumentu do analizy
            
        Returns:
            List[Dict]: Lista wyodrębnionych kryteriów
            
        Raises:
            ValueError: Gdy nie udało się wyodrębnić kryteriów
        """
        prompt = """
        Przeanalizuj poniższy dokument przetargowy i zidentyfikuj kryteria oceny ofert.
        Zwróć odpowiedź dokładnie w poniższym formacie JSON (ważne: odpowiedź musi być poprawnym JSON):

        {
            "criteria": [
                {
                    "name": "nazwa kryterium",
                    "weight": liczba,
                    "description": "opis",
                    "scoring_guide": "wskazówki do oceny"
                }
            ]
        }

        Upewnij się, że:
        - Suma wag wszystkich kryteriów wynosi dokładnie 100%
        - Każde kryterium ma unikalną nazwę
        - Opisy są konkretne i jednoznaczne
        - Format JSON jest ściśle zachowany
        """
        
        try:
            response = await self.analyze_text(prompt, brief_content)
            
            if not isinstance(response, dict) or 'criteria' not in response:
                raise ValueError("Nieprawidłowa struktura odpowiedzi od modelu")
                
            criteria = response['criteria']
            await self._validate_criteria(criteria)
            return criteria
            
        except Exception as e:
            self.logger.error(f"Błąd podczas parsowania kryteriów: {str(e)}")
            raise

    async def analyze_offer(
        self,
        offer_content: str,
        criteria: List[Dict],
        brief_content: str
    ) -> Dict:
        """
        Analizuje ofertę względem zadanych kryteriów.
        
        Args:
            offer_content: Treść oferty do analizy
            criteria: Lista kryteriów oceny
            brief_content: Treść briefu/SIWZ
            
        Returns:
            Dict: Analiza oferty z ocenami i uzasadnieniami
            
        Raises:
            ValueError: Gdy nie udało się przeanalizować oferty
        """
        prompt = f"""
        Oceń poniższą ofertę względem kryteriów. Zwróć odpowiedź dokładnie w poniższym formacie JSON:

        {{
            "evaluations": [
                {{
                    "criterion_name": "nazwa kryterium",
                    "score": liczba 0-100,
                    "justification": "szczegółowe uzasadnienie",
                    "key_points": ["główny punkt 1", "główny punkt 2"],
                    "evidence": ["cytat/referencja 1", "cytat/referencja 2"]
                }}
            ],
            "strengths": ["mocna strona 1", "mocna strona 2"],
            "weaknesses": ["słaba strona 1", "słaba strona 2"],
            "summary": "krótkie podsumowanie oceny",
            "recommendations": ["rekomendacja 1", "rekomendacja 2"]
        }}

        Kryteria oceny:
        {json.dumps(criteria, indent=2, ensure_ascii=False)}

        Kontekst z briefu/SIWZ:
        {brief_content[:1000]}...
        """
        
        response = await self.analyze_text(prompt, offer_content)
        try:
            await self._validate_analysis(response)
            return response
        except Exception as e:
            self.logger.error(f"Błąd podczas parsowania analizy oferty: {str(e)}")
            raise

    async def _validate_criteria(self, criteria: List[Dict]) -> None:
        """
        Waliduje wyodrębnione kryteria.
        
        Args:
            criteria: Lista kryteriów do walidacji
            
        Raises:
            ValueError: Gdy kryteria nie spełniają wymagań
        """
        if not criteria:
            raise ValueError("Nie znaleziono żadnych kryteriów")
            
        # Sprawdź sumę wag
        total_weight = sum(c['weight'] for c in criteria)
        if abs(total_weight - 100) > 0.01:
            self.logger.warning(
                f"Suma wag kryteriów ({total_weight}%) różni się od 100%"
            )
            
        # Sprawdź unikalność nazw
        names = [c['name'] for c in criteria]
        if len(names) != len(set(names)):
            raise ValueError("Znaleziono duplikaty w nazwach kryteriów")
            
        # Sprawdź wymagane pola
        required_fields = {'name', 'weight', 'description'}
        for criterion in criteria:
            missing_fields = required_fields - set(criterion.keys())
            if missing_fields:
                raise ValueError(f"Brakujące pola w kryterium: {missing_fields}")

    async def _validate_analysis(self, analysis: Dict) -> None:
        """
        Waliduje analizę oferty.
        
        Args:
            analysis: Analiza do walidacji
            
        Raises:
            ValueError: Gdy analiza nie spełnia wymagań
        """
        required_fields = {
            'evaluations', 'strengths', 'weaknesses', 
            'summary', 'recommendations'
        }
        
        missing_fields = required_fields - set(analysis.keys())
        if missing_fields:
            raise ValueError(f"Brakujące pola w analizie: {missing_fields}")
            
        if not analysis['evaluations']:
            raise ValueError("Brak ocen w analizie")
            
        for eval in analysis['evaluations']:
            if not (0 <= eval['score'] <= 100):
                raise ValueError(
                    f"Nieprawidłowa ocena: {eval['score']} "
                    f"dla kryterium {eval['criterion_name']}"
                )

    async def close(self):
        """Zamyka klienta HTTP"""
        await self.client.aclose()

    async def __aenter__(self):
        """Context manager entry"""
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """Context manager exit"""
        await self.close()