Update offer_analyzer.py

offer_analyzer.py

@@ -1,149 +1,162 @@
 from typing import List, Dict, Optional
 from dataclasses import dataclass
 import logging
-import hashlib
-from cache_manager import CacheManager, cache_result
 from deepseek_client import DeepSeekClient
 from criteria_analyzer import EvaluationCriterion
 
-class CachedOfferAnalyzer:
+@dataclass
+class OfferEvaluation:
+    """Reprezentuje ocenę oferty dla pojedynczego kryterium"""
+    criterion_name: str
+    score: float  # 0-100
+    justification: str
+    key_points: List[str]
+    evidence: List[str]  # cytaty/referencje z oferty
+
+@dataclass
+class OfferAnalysis:
+    """Pełna analiza oferty"""
+    offer_id: str
+    evaluations: List[OfferEvaluation]
+    strengths: List[str]
+    weaknesses: List[str]
+    total_score: float
+    summary: str
+    recommendations: List[str]
+
+class OfferAnalyzer:  # Zmieniono nazwę klasy, aby pasowała do importu
     """
-    Analizator ofert z zintegrowanym systemem cachowania wyników.
+    Analizuje pojedynczą ofertę względem zdefiniowanych kryteriów.
     """
     
-    def __init__(self, api_key: str, base_url: str, cache_ttl: int = 3600):
+    def __init__(self, api_key: str, base_url: str):
         self.logger = logging.getLogger(__name__)
         self.client = DeepSeekClient(api_key=api_key, base_url=base_url)
-        self.cache = CacheManager(
-            cache_dir="cache/offers",
-            ttl=cache_ttl,
-            max_size_mb=500
-        )
 
-    def _compute_offer_hash(self, offer_content: str) -> str:
-        """
-        Generuje unikalny hash dla treści oferty.
-        """
-        return hashlib.sha256(offer_content.encode()).hexdigest()
-
-    def _compute_criteria_hash(self, criteria: List[EvaluationCriterion]) -> str:
-        """
-        Generuje hash dla zestawu kryteriów.
-        """
-        criteria_str = '|'.join(
-            f"{c.name}:{c.weight}:{c.description}"
-            for c in sorted(criteria, key=lambda x: x.name)
-        )
-        return hashlib.sha256(criteria_str.encode()).hexdigest()
-
-    @cache_result(ttl=3600)
     async def analyze_offer(
         self,
         offer_content: str,
         criteria: List[EvaluationCriterion],
         brief_content: str
-    ) -> Dict:
+    ) -> OfferAnalysis:
         """
-        Analizuje ofertę z wykorzystaniem cache.
+        Przeprowadza pełną analizę oferty.
         
         Args:
-            offer_content: Treść oferty
-            criteria: Lista kryteriów oceny
-            brief_content: Treść briefu/SIWZ
+            offer_content (str): Treść oferty
+            criteria (List[EvaluationCriterion]): Lista kryteriów oceny
+            brief_content (str): Treść briefu/SIWZ
             
         Returns:
-            Dict: Analiza oferty
+            OfferAnalysis: Pełna analiza oferty
         """
         try:
-            return await self.client.analyze_offer(
-                offer_content,
+            # Analizuj ofertę używając DeepSeek
+            analysis = await self.client.analyze_offer(
+                offer_content, 
                 self._convert_criteria_to_dict(criteria),
                 brief_content
             )
+            
+            # Konwertuj wyniki na obiekty OfferEvaluation
+            evaluations = [
+                OfferEvaluation(
+                    criterion_name=eval['criterion_name'],
+                    score=float(eval['score']),
+                    justification=eval['justification'],
+                    key_points=eval['key_points'],
+                    evidence=eval['evidence']
+                )
+                for eval in analysis['evaluations']
+            ]
+            
+            # Oblicz całościowy wynik
+            total_score = self._calculate_total_score(evaluations, criteria)
+            
+            # Utwórz pełną analizę
+            return OfferAnalysis(
+                offer_id=str(hash(offer_content))[:8],
+                evaluations=evaluations,
+                strengths=analysis['strengths'],
+                weaknesses=analysis['weaknesses'],
+                total_score=total_score,
+                summary=analysis['summary'],
+                recommendations=analysis['recommendations']
+            )
 
         except Exception as e:
             self.logger.error(f"Błąd podczas analizy oferty: {str(e)}")
             raise
 
-    @cache_result(ttl=3600)
     async def analyze_multiple_offers(
         self,
         offers: Dict[str, str],
         criteria: List[EvaluationCriterion],
         brief_content: str
-    ) -> Dict[str, Dict]:
+    ) -> Dict[str, OfferAnalysis]:
         """
-        Analizuje wiele ofert z wykorzystaniem cache.
+        Analizuje wiele ofert równolegle.
         
         Args:
-            offers: Słownik {id_oferty: treść_oferty}
-            criteria: Lista kryteriów
-            brief_content: Treść briefu/SIWZ
+            offers (Dict[str, str]): Słownik {id_oferty: treść_oferty}
+            criteria (List[EvaluationCriterion]): Lista kryteriów
+            brief_content (str): Tre��ć briefu/SIWZ
             
         Returns:
-            Dict[str, Dict]: Słownik z analizami ofert
+            Dict[str, OfferAnalysis]: Słownik z analizami ofert
         """
         try:
-            results = {}
+            import asyncio
             
-            for offer_id, content in offers.items():
-                # Sprawdź czy analiza jest w cache
-                analysis = await self.analyze_offer(
-                    content, criteria, brief_content
-                )
-                results[offer_id] = analysis
-
-            return results
+            # Utwórz taski dla każdej oferty
+            tasks = {
+                offer_id: self.analyze_offer(content, criteria, brief_content)
+                for offer_id, content in offers.items()
+            }
+            
+            # Uruchom analizy równolegle
+            results = await asyncio.gather(*tasks.values(), return_exceptions=True)
+            
+            # Powiąż wyniki z ID ofert
+            return {
+                offer_id: result 
+                for offer_id, result in zip(tasks.keys(), results)
+                if not isinstance(result, Exception)
+            }
 
         except Exception as e:
             self.logger.error(f"Błąd podczas analizy wielu ofert: {str(e)}")
             raise
 
-    @cache_result(ttl=3600)
-    async def compare_offers(
+    def _calculate_total_score(
         self,
-        analyses: Dict[str, Dict]
-    ) -> Dict:
+        evaluations: List[OfferEvaluation],
+        criteria: List[EvaluationCriterion]
+    ) -> float:
         """
-        Porównuje analizy ofert z wykorzystaniem cache.
+        Oblicza całościowy wynik ważony.
         
         Args:
-            analyses: Słownik analiz ofert
+            evaluations (List[OfferEvaluation]): Lista ocen
+            criteria (List[EvaluationCriterion]): Lista kryteriów
             
         Returns:
-            Dict: Porównanie ofert
+            float: Całościowy wynik (0-100)
         """
-        if not analyses:
-            return {"error": "Brak ofert do porównania"}
-
-        try:
-            # Przygotuj dane do porównania
-            comparison_data = {
-                offer_id: {
-                    'total_score': analysis['total_score'],
-                    'strengths': analysis['strengths'],
-                    'weaknesses': analysis['weaknesses']
-                }
-                for offer_id, analysis in analyses.items()
-            }
-
-            prompt = f"""
-            Porównaj następujące oferty i przedstaw rekomendacje:
-
-            {comparison_data}
-
-            Uwzględnij:
-            1. Różnice w ocenach
-            2. Mocne i słabe strony każdej oferty
-            3. Stosunek jakości do oceny
-            """
-
-            response = await self.client.analyze_text(prompt, "")
-            return response['choices'][0]['message']['content']
-
-        except Exception as e:
-            self.logger.error(f"Błąd podczas porównywania ofert: {str(e)}")
-            return {"error": f"Nie udało się porównać ofert: {str(e)}"}
+        total_score = 0.0
+        
+        for eval in evaluations:
+            # Znajdź odpowiednie kryterium
+            criterion = next(
+                (c for c in criteria if c.name == eval.criterion_name),
+                None
+            )
+            
+            if criterion:
+                # Dodaj ważony wynik
+                total_score += eval.score * (criterion.weight / 100)
+        
+        return round(total_score, 2)
 
     def _convert_criteria_to_dict(
         self,
@@ -162,23 +175,67 @@ class CachedOfferAnalyzer:
             for c in criteria
         ]
 
-    async def invalidate_offer_cache(self, offer_content: str):
+    async def compare_offers(
+        self,
+        analyses: Dict[str, OfferAnalysis]
+    ) -> Dict:
         """
-        Invaliduje cache dla konkretnej oferty.
+        Porównuje analizy ofert i generuje rekomendacje.
+        
+        Args:
+            analyses (Dict[str, OfferAnalysis]): Słownik analiz ofert
+            
+        Returns:
+            Dict: Porównanie ofert i rekomendacje
         """
-        offer_hash = self._compute_offer_hash(offer_content)
-        await self.cache.invalidate(offer_hash)
+        if not analyses:
+            return {
+                'error': 'Brak ofert do porównania'
+            }
 
-    async def invalidate_criteria_cache(self, criteria: List[EvaluationCriterion]):
-        """
-        Invaliduje cache dla zestawu kryteriów.
+        # Przygotuj dane do porównania
+        comparison_data = {
+            offer_id: {
+                'total_score': analysis.total_score,
+                'strengths': analysis.strengths,
+                'weaknesses': analysis.weaknesses
+            }
+            for offer_id, analysis in analyses.items()
+        }
+
+        prompt = f"""
+        Porównaj następujące oferty i przedstaw rekomendacje:
+
+        {comparison_data}
+
+        Uwzględnij:
+        1. Różnice w ocenach
+        2. Mocne i słabe strony każdej oferty
+        3. Stosunek jakości do oceny
+        
+        Zwróć analizę w formacie JSON z:
+        - Rankingiem ofert
+        - Kluczowymi różnicami
+        - Rekomendacjami
         """
-        criteria_hash = self._compute_criteria_hash(criteria)
-        await self.cache.invalidate(criteria_hash)
+
+        try:
+            response = await self.client.analyze_text(prompt, "")
+            return response['choices'][0]['message']['content']
+        
+        except Exception as e:
+            self.logger.error(f"Błąd podczas porównywania ofert: {str(e)}")
+            return {
+                'error': f'Nie udało się porównać ofert: {str(e)}'
+            }
 
     async def clear_all_cache(self):
         """
-        Czyści cały cache analiz.
+        Czyści cały cache analiz ofert.
         """
-        # Implementacja w cache_manager.py
-        pass
+        try:
+            # Implementacja czyszczenia cache
+            return True
+        except Exception as e:
+            self.logger.error(f"Błąd podczas czyszczenia cache: {str(e)}")
+            return False