Update deepseek_client.py

deepseek_client.py

@@ -91,224 +91,13 @@ class DeepSeekClient:
                     'response_format': {"type": "json_object"}
                 }
                 
-                async with self.client as client:
-                    self.logger.debug(f"Wysyłanie zapytania do API (próba {retries + 1}/{max_retries})")
-                    response = await client.post(
-                        '/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']}"
+                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
                 )
-
-    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()
+                response.raise_for_status()
+                response_data = response.json()
+                
+                # Sprawdź strukturę odpowiedzi
+                if 'choices' not in response