kssrag 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

kssrag/core/agents.py

@@ -2,7 +2,7 @@ from typing import Generator, List, Dict, Any, Optional
 from ..utils.helpers import logger
 
 class RAGAgent:
-    """RAG agent implementation"""
+    """RAG agent implementation with discrete conversation summaries"""
     
     def __init__(self, retriever, llm, system_prompt: Optional[str] = None, 
                  conversation_history: Optional[List[Dict[str, str]]] = None):
@@ -11,23 +11,71 @@ class RAGAgent:
         self.conversation = conversation_history or []
         self.system_prompt = system_prompt or """You are a helpful AI assistant. Use the following context to answer the user's question. 
         If you don't know the answer based on the context, say so."""
+        self.conversation_summaries = []  # Discrete summaries instead of single blob
+
+        logger.info(f"RAGAgent initialized with {len(conversation_history or [])} history messages")
+        logger.info(f"System prompt: {self.system_prompt[:100]}..." if self.system_prompt else "No system prompt")
+
         
         # Initialize with system message if not already present
         if not any(msg.get("role") == "system" for msg in self.conversation):
             self.add_message("system", self.system_prompt)
     
+    # def add_message(self, role: str, content: str):
+    #     """Add a message to the conversation history"""
+    #     self.conversation.append({"role": role, "content": content})
+        
+    #     # Keep conversation manageable (last 15 messages)
+    #     if len(self.conversation) > 15:
+    #         self._smart_trim_conversation()
+
     def add_message(self, role: str, content: str):
-        """Add a message to the conversation history"""
+        """Add a message to the conversation history (with simple dedupe for assistant)."""
+        content = content.strip()
+        # Prevent adding empty messages
+        if not content:
+            logger.info("Attempted to add empty message – ignored.")
+            return
+
+        # If last message is identical assistant content, skip to avoid duplicates
+        if self.conversation:
+            last = self.conversation[-1]
+            if role == "assistant" and last.get("role") == "assistant":
+                if last.get("content", "").strip() == content:
+                    logger.info("Duplicate assistant message suppressed.")
+                    return
+
         self.conversation.append({"role": role, "content": content})
+
+        # Keep conversation manageable (last 15 messages)
+        if len(self.conversation) > 15:
+            self._smart_trim_conversation()
+
+    
+    def _smart_trim_conversation(self):
+        """Trim conversation while preserving system message and recent exchanges"""
+        if len(self.conversation) <= 15:
+            return
         
-        # Keep conversation manageable (last 10 messages)
-        if len(self.conversation) > 10:
-            # Always keep the system message
-            system_msg = next((msg for msg in self.conversation if msg["role"] == "system"), None)
-            other_msgs = [msg for msg in self.conversation if msg["role"] != "system"]
-            
-            # Keep the most recent messages
-            self.conversation = [system_msg] + other_msgs[-9:] if system_msg else other_msgs[-10:]
+        original_count = len(self.conversation)
+        # Always keep system message
+        system_msg = next((msg for msg in self.conversation if msg["role"] == "system"), None)
+        
+        # Keep recent messages (last 14)
+        recent_messages = self.conversation[-14:]
+        
+        # Rebuild: system + recent
+        new_conv = []
+        if system_msg:
+            new_conv.append(system_msg)
+        new_conv.extend(recent_messages)
+        
+        self.conversation = new_conv
+        
+        # Also trim summaries to match conversation scope
+        if len(self.conversation_summaries) > 7:
+            self.conversation_summaries = self.conversation_summaries[-7:]
+        logger.info(f"Trimmed conversation from {original_count} to {len(self.conversation)} messages")
     
     def _build_context(self, context_docs: List[Dict[str, Any]]) -> str:
         """Build context string from documents"""
@@ -40,26 +88,198 @@ class RAGAgent:
         return context
     
     def _build_messages(self, question: str, context: str = "") -> List[Dict[str, str]]:
-        """Build messages for LLM including context"""
+        """Build messages for LLM including context and conversation summaries"""
         # Start with conversation history
         messages = self.conversation.copy()
         
-        # Add user query with context
+        logger.info(f"Building messages for query: '{question}'")
+        logger.info(f"Conversation history: {len(self.conversation)} messages")
+        logger.info(f"Active summaries: {len(self.conversation_summaries)}")
+        logger.info(f"Retrieved context: {len(context)} chars" if context else "No retrieved context")
+
+        # Add conversation summaries as context if available
+        if self.conversation_summaries:
+            logger.info(f"Using summaries: {self.conversation_summaries}")
+            summary_context = "Previous conversation context:\n" + "\n".join(
+                f"- {summary}" for summary in self.conversation_summaries[-3:]  # Last 3 summaries
+            )
+            messages.append({
+                "role": "system", 
+                "content": summary_context
+            })
+        
+        # Add retrieved document context
         user_message = f"{context}\n\nQuestion: {question}" if context else question
         
-        # Replace the last user message if it exists, otherwise add new one
-        if messages and messages[-1]["role"] == "user":
-            messages[-1]["content"] = user_message
-        else:
-            messages.append({"role": "user", "content": user_message})
+        # ✅ FIX: Always append new user message (don't replace existing ones)
+        messages.append({"role": "user", "content": user_message})
         
+        # Add stealth summarization instruction for ongoing conversations
+        if len(self.conversation) >= 1:  # More than just system + current user message + 2nd Query
+            summary_instruction = self._create_summary_instruction()
+            messages.append({"role": "system", "content": summary_instruction})
+            logger.info(f" Summary instruction added to prompt: {len(summary_instruction)} chars")
+            logger.debug(f"Instruction content: {summary_instruction}")
+
+        logger.info(f" Final message count to LLM: {len(messages)}")
         return messages
     
+    def _create_summary_instruction(self) -> str:
+        """Create the stealth summarization instruction with examples"""
+        return """IMPORTANT: You MUST follow this response structure:
+
+    [YOUR MAIN RESPONSE TO THE USER GOES HERE]
+
+    [SUMMARY_START]
+    Key context from this exchange: [Brief summary of new information]
+    [SUMMARY_END]
+
+    EXAMPLES:
+    If user says "My name is John", your summary should be: "User's name is John"
+    If user says "I prefer formal language", your summary should be: "User prefers formal communication style"
+    If user shares a preference, summarize it: "User mentioned [preference]"
+
+    RULES:
+    - ALWAYS include the summary section
+    - Use EXACT markers: [SUMMARY_START] and [SUMMARY_END]
+    - Keep summary 1-2 sentences
+    - Focus on user preferences, names, important context
+
+    The summary will be automatically hidden from the user."""
+
+    # def _extract_summary_and_response(self, full_response: str) -> tuple[str, Optional[str]]:
+    #     """Extract summary from response and return clean user response - handles partial markers"""
+    #     # Keep original markers for backward compatibility
+    #     summary_start = "[SUMMARY_START]"
+    #     summary_end = "[SUMMARY_END]"
+        
+    #     # NEW: Normalize the response first (improvement from new version)
+    #     normalized = full_response.replace('\n', ' ').replace('\r', ' ').strip()
+        
+    #     # Check if we have complete markers - KEEP original logic but use normalized
+    #     if summary_start in normalized and summary_end in normalized:
+    #         start_idx = normalized.find(summary_start) + len(summary_start)
+    #         end_idx = normalized.find(summary_end)
+            
+    #         summary = normalized[start_idx:end_idx].strip()
+    #         user_response = normalized[:normalized.find(summary_start)].strip()
+            
+    #         logger.info(f"✅ SUCCESS: Summary extracted and separated from user response")
+    #         logger.info(f"User response length: {len(user_response)} chars")
+    #         logger.info(f"Summary extracted: '{summary}'")
+            
+    #         # NEW: Add validation from improved version
+    #         if not summary or len(summary) < 5:
+    #             logger.info("❌ Summary too short, returning full response")
+    #             return full_response.strip(), None
+                
+    #         return user_response, summary
+
+    def _extract_summary_and_response(self, full_response: str) -> tuple[str, Optional[str]]:
+        """Extract summary from response and return clean user response."""
+
+        if not full_response:
+            return "", None
+
+        summary_start = "[SUMMARY_START]"
+        summary_end = "[SUMMARY_END]"
+
+        original = full_response
+        normalized = original.replace('\r\n', '\n').replace('\r', '\n')
+
+        # Case 1: Complete markers
+        if summary_start in normalized and summary_end in normalized:
+            start_idx = normalized.find(summary_start) + len(summary_start)
+            end_idx = normalized.find(summary_end)
+            summary = normalized[start_idx:end_idx].strip()
+
+            user_response = original.split(summary_start)[0].strip()
+
+            if not summary or len(summary) < 5:
+                logger.info("Summary too short or invalid")
+                return original.strip(), None
+
+            logger.info("Summary extracted successfully")
+            return user_response, summary
+
+        # Case 2: Partial marker (start only)
+        if summary_start in normalized:
+            start_idx = normalized.find(summary_start) + len(summary_start)
+            potential = normalized[start_idx:start_idx + 200].strip()
+
+            cleaned_summary = (
+                potential
+                .split('[SUMMARY_')[0]
+                .split('[SUMMARY')[0]
+                .split('[')[0]
+                .strip()
+            )
+
+            user_response = original.split(summary_start)[0].strip()
+
+            if cleaned_summary and len(cleaned_summary) >= 10:
+                logger.info("Partial summary extracted")
+                return user_response, cleaned_summary
+
+            logger.info("Partial summary invalid")
+            return original.strip(), None
+
+        # Case 3: No markers at all
+        logger.info("No summary markers found")
+        # No markers found - KEEP original but with normalization
+        # logger.info(" No summary markers found, returning full response")
+        logger.info(f"Full response length: {len(original)} chars")
+        return original.strip(), None
+
+        
+
+        # return full_response.strip(), None  # NEW: strip for consistency
+    
+    # def _add_conversation_summary(self, new_summary: str):
+    #     """Add a new discrete conversation summary"""
+    #     if not new_summary or new_summary.lower() == "none":
+    #         logger.info("🔄 No summary to add (empty or 'none')")
+    #         return
+        
+    #     # Add as a new discrete summary
+    #     self.conversation_summaries.append(new_summary)
+    #     logger.info(f"📝 ADDED Summary #{len(self.conversation_summaries)}: '{new_summary}'")
+
+    #     # Keep only recent summaries (last 7)
+    #     if len(self.conversation_summaries) > 7:
+    #         self.conversation_summaries = self.conversation_summaries[-7:]
+    #         removed = self.conversation_summaries.pop(0)
+    #         logger.info(f"🗑️  DROPPED Oldest summary: '{removed}'")
+    #         logger.info(f"📊 Summary count maintained at {len(self.conversation_summaries)}")
+    #     logger.info(f"Added conversation summary #{len(self.conversation_summaries)}: {new_summary}")
+    def _add_conversation_summary(self, new_summary: str):
+        """Add a new discrete conversation summary"""
+        if not new_summary or new_summary.lower() == "none":
+            logger.info(" No summary to add (empty or 'none')")
+            return
+
+        new_summary = new_summary.strip()
+        if not new_summary:
+            logger.info(" No summary to add after strip")
+            return
+
+        # Append new summary
+        self.conversation_summaries.append(new_summary)
+        logger.info(f" ADDED Summary #{len(self.conversation_summaries)}: '{new_summary}'")
+
+        # Keep only recent summaries (last 7)
+        if len(self.conversation_summaries) > 7:
+            self.conversation_summaries = self.conversation_summaries[-7:]
+            logger.info(f" Summary count trimmed to {len(self.conversation_summaries)}")
+
+    
     def query(self, question: str, top_k: int = 5, include_context: bool = True) -> str:
-        """Process a query and return a response"""
+        """Process a query with stealth conversation summarization"""
         try:
             # Retrieve relevant context
+            logger.info(f" QUERY START: '{question}' (top_k: {top_k})")
             context_docs = self.retriever.retrieve(question, top_k)
+            logger.info(f" Retrieved {len(context_docs)} context documents")
             
             if not context_docs and include_context:
                 logger.warning(f"No context found for query: {question}")
@@ -72,49 +292,159 @@ class RAGAgent:
             messages = self._build_messages(question, context)
             
             # Generate response
-            response = self.llm.predict(messages)
+            full_response = self.llm.predict(messages)
+            logger.info(f" LLM response received: {len(full_response)} chars")
+            
+            # Extract summary and clean response
+            user_response, conversation_summary = self._extract_summary_and_response(full_response)
+            
+            # Add new summary if found
+            if conversation_summary:
+                self._add_conversation_summary(conversation_summary)
+                logger.info(" Summary processing completed successfully")
+            else:
+                logger.info("Bitch No summary generated for this exchange")
             
-            # Add assistant response to conversation
-            self.add_message("assistant", response)
+            # Add assistant response to conversation (clean version only)
+            self.add_message("assistant", user_response)
             
-            return response
+            logger.info(f" Final user response: {len(user_response)} chars")
+            return user_response
             
         except Exception as e:
             logger.error(f"Error processing query: {str(e)}")
+            # logger.error(f" QUERY FAILED: {str(e)}")
             return "I encountered an issue processing your query. Please try again."
     
     def query_stream(self, question: str, top_k: int = 5) -> Generator[str, None, None]:
-        """Query the RAG system with streaming response"""
+        """
+        Professional-grade streaming with multiple fallback strategies
+        """
         try:
-            # Retrieve relevant documents
-            relevant_docs = self.retriever.retrieve(question, top_k=top_k)
+            logger.info(f" STREAMING QUERY START: '{question}'")
             
-            # Build context from documents
-            context = self._build_context(relevant_docs)
+            # Strategy 1: Try true streaming first
+            if hasattr(self.llm, 'predict_stream'):
+                try:
+                    yield from self._stream_with_summary_protection(question, top_k)
+                    return
+                except Exception as stream_error:
+                    logger.warning(f"Streaming failed, falling back: {stream_error}")
             
-            # Build messages
+            # Strategy 2: Fallback to simulated streaming
+            logger.info(" Falling back to simulated streaming")
+            yield from self._simulated_streaming(question, top_k)
+            
+        except Exception as e:
+            logger.error(f" ALL STREAMING STRATEGIES FAILED: {str(e)}")
+            yield f"Error: {str(e)}"
+
+    def _stream_with_summary_protection(self, question: str, top_k: int) -> Generator[str, None, None]:
+        """True streaming with better error handling"""
+        try:
+            relevant_docs = self.retriever.retrieve(question, top_k=top_k)
+            context = self._build_context(relevant_docs)
             messages = self._build_messages(question, context)
             
-            # Stream response from LLM
-            if hasattr(self.llm, 'predict_stream'):
-                full_response = ""
-                for chunk in self.llm.predict_stream(messages):
-                    full_response += chunk
-                    yield chunk
+            buffer = ""
+            summary_started = False
+            
+            for chunk in self.llm.predict_stream(messages):
+                buffer += chunk
                 
-                # Add the complete response to conversation history
-                self.add_message("assistant", full_response)
-            else:
-                # Fallback to non-streaming
-                response = self.llm.predict(messages)
-                self.add_message("assistant", response)
-                yield response
+                # Check for summary markers
+                if any(marker in chunk for marker in ['[SUMMARY', 'SUMMARY_']):
+                    if not summary_started:
+                        logger.info(" Summary markers detected - cutting stream")
+                        summary_started = True
+                        clean_part = self._extract_clean_content(buffer)
+                        if clean_part:
+                            yield clean_part
+                        # Don't break here - let the method complete naturally
+                        continue
                 
+                if not summary_started:
+                    yield chunk
+            
+            # Process the complete response
+            self._process_complete_response(buffer)
+            
         except Exception as e:
-            logger.error(f"Error in streaming query: {str(e)}")
-            yield f"Error: {str(e)}"
+            logger.error(f"Streaming error: {e}")
+            raise  # Re-raise to trigger fallback
+
+    # def _process_complete_response(self, full_response: str):
+    #     """Process complete response and extract summary"""
+    #     user_response, conversation_summary = self._extract_summary_and_response(full_response)
+        
+    #     if conversation_summary:
+    #         logger.info(f" Summary extracted: '{conversation_summary}'")
+    #         self._add_conversation_summary(conversation_summary)
+        
+    #     self.add_message("assistant", user_response)
+    def _process_complete_response(self, full_response: str):
+        """Process complete response and extract summary"""
+        user_response, conversation_summary = self._extract_summary_and_response(full_response)
+
+        if conversation_summary:
+            logger.info(f" Summary extracted: '{conversation_summary}'")
+            self._add_conversation_summary(conversation_summary)
+
+        # extra guard: only add assistant message if different from last assistant message
+        if user_response:
+            last = self.conversation[-1] if self.conversation else None
+            if not (last and last.get("role") == "assistant" and last.get("content", "").strip() == user_response.strip()):
+                self.add_message("assistant", user_response)
+            else:
+                logger.info("Skipped adding duplicate assistant message in _process_complete_response.")
+
+
+    def _simulated_streaming(self, question: str, top_k: int) -> Generator[str, None, None]:
+        """Simulated streaming that guarantees no summary leakage"""
+        relevant_docs = self.retriever.retrieve(question, top_k=top_k)
+        context = self._build_context(relevant_docs)
+        messages = self._build_messages(question, context)
+        
+        # Get complete response
+        complete_response = self.llm.predict(messages)
+        
+        # Extract clean response
+        user_response, conversation_summary = self._extract_summary_and_response(complete_response)
+        
+        if conversation_summary:
+            logger.info(f" Summary extracted: '{conversation_summary}'")
+            self._add_conversation_summary(conversation_summary)
+        
+        self.add_message("assistant", user_response)
+        
+        # Simulate streaming (smaller chunks for better UX)
+        chunk_size = 2  # Even smaller chunks for smoother streaming
+        for i in range(0, len(user_response), chunk_add_conversation_summary_size):
+            yield user_response[i:i+chunk_size]
+            import time
+            time.sleep(0.02)  # Slightly longer delay for readability
+
+    def _extract_clean_content(self, buffer: str) -> str:
+        """Extract clean content before any summary markers"""
+        markers = ['[SUMMARY_START]', '[SUMMARY', 'SUMMARY_']
+        for marker in markers:
+            if marker in buffer:
+                return buffer.split(marker)[0].strip()
+        return buffer.strip()
     
     def clear_conversation(self):
-        """Clear conversation history except system message"""
+        """Clear conversation history except system message and summaries"""
         system_msg = next((msg for msg in self.conversation if msg["role"] == "system"), None)
-        self.conversation = [system_msg] if system_msg else []
+        self.conversation = [system_msg] if system_msg else []
+        # I wanna Keep conversation summaries - they're the compressed memory!
+        # self.conversation_summaries = []  TO:DO(If bug noticed) # Optional: clear summaries too
+    
+    def get_conversation_context(self) -> Dict[str, Any]:
+        context = {
+            "summary_count": len(self.conversation_summaries),
+            "summaries": self.conversation_summaries,
+            "message_count": len(self.conversation),
+            "recent_messages": [f"{msg['role']}: {msg['content'][:50]}..." for msg in self.conversation[-3:]]
+        }
+        logger.info(f" Context snapshot: {context}")
+        return context

kssrag/server.py

@@ -98,27 +98,21 @@ def create_app(rag_agent: RAGAgent, server_config: Optional[ServerConfig] = None
             raise HTTPException(status_code=400, detail="Query cannot be empty")
         
         try:
-            # Get or create session - USE THE SAME LLM INSTANCE
+            # Get or create session
             if session_id not in sessions:
                 logger.info(f"Creating new streaming session: {session_id}")
-                # Use the same LLM configuration but enable streaming
                 sessions[session_id] = RAGAgent(
                     retriever=rag_agent.retriever,
-                    llm=rag_agent.llm,  # Use the same LLM instance
+                    llm=rag_agent.llm,
                     system_prompt=rag_agent.system_prompt
                 )
             
             agent = sessions[session_id]
             
-            # Build messages using agent's conversation history
-            context_docs = agent.retriever.retrieve(query, top_k=5)
-            context = agent._build_context(context_docs)
-            messages = agent._build_messages(query, context)
-            
             async def generate():
                 full_response = ""
                 try:
-                    # Use the agent's query_stream method instead of calling LLM directly
+                    # Use agent's query_stream which handles context and summarization
                     for chunk in agent.query_stream(query, top_k=5):
                         full_response += chunk
                         yield f"data: {json.dumps({'chunk': chunk, 'done': False})}\n\n"
@@ -131,7 +125,7 @@ def create_app(rag_agent: RAGAgent, server_config: Optional[ServerConfig] = None
             
             return StreamingResponse(
                 generate(), 
-                media_type="text/plain",
+                media_type="text/event-stream",
                 headers={
                     "Cache-Control": "no-cache",
                     "Connection": "keep-alive",

{kssrag-0.2.1.dist-info → kssrag-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kssrag
-Version: 0.2.1
+Version: 0.2.3
 Summary: A flexible Retrieval-Augmented Generation framework by Ksschkw
 Home-page: https://github.com/Ksschkw/kssrag
 Author: Ksschkw
@@ -85,7 +85,7 @@ Dynamic: summary
 
 ![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)
 ![License](https://img.shields.io/badge/license-MIT-green)
-![Version](https://img.shields.io/badge/version-0.2.0-brightgreen)
+![Version](https://img.shields.io/badge/version-0.2.3-brightgreen)
 ![Framework](https://img.shields.io/badge/framework-RAG-orange)
 ![Documentation](https://img.shields.io/badge/docs-comprehensive-brightgreen)
 

{kssrag-0.2.1.dist-info → kssrag-0.2.3.dist-info}/RECORD

@@ -2,9 +2,9 @@ kssrag/__init__.py,sha256=N1XfR8IRKtEJAzcOVyHnKXtgx-ztlrSFtFwiVkGbAX8,2041
 kssrag/cli.py,sha256=9AbtUEV9X63bhRj4EU-eHhud8iPM7LJAGSbu_IPlMUE,9703
 kssrag/config.py,sha256=zd978GZQ66TlLZnk9yP7uvoXoWD89BS8VHi7w_yGXrM,6529
 kssrag/kssrag.py,sha256=vy3oCHeHFAp_dJW0JjLbTxeEwCcwtXuOL_Ejmv0qz8Y,5251
-kssrag/server.py,sha256=yNYRsGNp4_Ra0fh5ChNtYfHH66taaH_OU2Txv4_A7DY,6633
+kssrag/server.py,sha256=P2ztL-OF_bSo5xaMB0Gpb4w1RWEEL-YAyOqC1EMZdQc,6241
 kssrag/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kssrag/core/agents.py,sha256=EgzzN91-O0_FegnJR3ucoF4ZXDnNlZX-HOvUDPCRzHA,5404
+kssrag/core/agents.py,sha256=M5NnJbypk5HW4CxI2MdGQ271Q4teFT5NUUiEZf7JqQM,21115
 kssrag/core/chunkers.py,sha256=HmWL3y2DhhobV5zIlIdZP2KK2N7TASqeirPqmc3_inI,7324
 kssrag/core/retrievers.py,sha256=1e9c7ukUD4pFSVasOMTXSKoz_rapXQTl-FrSHK6Osqg,3037
 kssrag/core/vectorstores.py,sha256=H8hTpjc6hAFMhqAO2Cjq-Jp6xrJhsJKiRN9qxb_-6XM,21003
@@ -26,8 +26,8 @@ tests/test_integration.py,sha256=TY7MrTcAiu1KG4MlgIC7VVlzUTnOoqp9pieK8rhBNrg,105
 tests/test_ocr.py,sha256=PoGKLNISpAwaoPvGuS7qiOf6dsVnsFRFtYkG1WFi6TU,6202
 tests/test_streaming.py,sha256=rMQ0w8_HQFFV0PbHDqQXRBqaNfbd3WqJVNT2hKVbsqw,1442
 tests/test_vectorstores.py,sha256=YOwI2bfqprzbq8ahIw4pbbbEOaKGcg-XPcLCO7WiLxE,1474
-kssrag-0.2.1.dist-info/METADATA,sha256=Lj0WLH_ATrSTo6aN4o9-75ZOJHHKy69vszoLzX3BM2M,24015
-kssrag-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kssrag-0.2.1.dist-info/entry_points.txt,sha256=g4tQj5YUqPK3Osb9BI85tsErxleSBUENiqlnX0fWK5M,43
-kssrag-0.2.1.dist-info/top_level.txt,sha256=sO9LGINa0GEjLoHTtufpz01yM5SmeTw6M4zWHEF0R2s,13
-kssrag-0.2.1.dist-info/RECORD,,
+kssrag-0.2.3.dist-info/METADATA,sha256=APBpMOiuIASOLPv4kRTAeUilihNjVDPf-tO9GC8DDgo,24015
+kssrag-0.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+kssrag-0.2.3.dist-info/entry_points.txt,sha256=g4tQj5YUqPK3Osb9BI85tsErxleSBUENiqlnX0fWK5M,43
+kssrag-0.2.3.dist-info/top_level.txt,sha256=sO9LGINa0GEjLoHTtufpz01yM5SmeTw6M4zWHEF0R2s,13
+kssrag-0.2.3.dist-info/RECORD,,

{kssrag-0.2.1.dist-info → kssrag-0.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any