Update deepseek_client.py

deepseek_client.py

@@ -100,4 +100,214 @@ class DeepSeekClient:
                 response_data = response.json()
                 
                 # Sprawdź strukturę odpowiedzi
-                if 'choices' not in response
+                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()