Aktualizacja ostatniej szansy

.gitignore

@@ -1 +1,46 @@
-"cache/" 
+"# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Cache and temporary files
+cache/
+*.log
+*.cache
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment variables
+.env
+.env.local
+
+# OS
+.DS_Store
+Thumbs.db" 

README.md

@@ -1,13 +1,86 @@
 ---
-title: JacekAI
-emoji: 🤖
-colorFrom: yellow
-colorTo: purple
+title: JacekAI - A11y Expert
+emoji: ♿
+colorFrom: blue
+colorTo: green
 sdk: gradio
-python_version: 3.12
+sdk_version: 6.1.0
+python_version: 3.10
 app_file: app.py
-pinned: false
-short_description: Chatbot wyspecjalizowany w cyfrowej dostępności.
+pinned: true
+short_description: Inteligentny asystent do spraw dostępności cyfrowej (WCAG, ARIA)
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# 🤖 A11y Expert - Asystent Dostępności Cyfrowej
+
+Inteligentny agent AI wyspecjalizowany w dostępności cyfrowej, wykorzystujący RAG (Retrieval-Augmented Generation) z bazą wiedzy WCAG, ARIA i najlepszych praktyk.
+
+## ✨ Funkcje
+
+- 💬 **Rozmowa w języku polskim i angielskim** - automatyczna detekcja języka
+- 📚 **Baza wiedzy** - WCAG 2.2, ARIA, i praktyczne przykłady
+- 🔍 **RAG** - odpowiedzi oparte na oficjalnej dokumentacji
+- 🎯 **Specjalistyczne odpowiedzi** - cytowanie kryteriów i źródeł
+- ⚡ **Streaming** - płynne generowanie odpowiedzi
+
+## 🚀 Jak używać
+
+1. Wpisz pytanie o dostępność cyfrową
+2. Zadaj pytanie po polsku lub angielsku
+3. Otrzymaj szczegółową odpowiedź z cytowaniem źródeł
+
+**Przykładowe pytania:**
+- "Jakie są wymagania WCAG 2.2 dla etykiet formularzy?"
+- "Wyjaśnij rolę 'alert' w ARIA i podaj przykład"
+- "Czy ten przycisk jest dostępny? `<div onclick='...'>Click me</div>`"
+
+## 🔧 Technologie
+
+- **Gradio** - interfejs użytkownika
+- **OpenAI GPT-4** - model językowy
+- **LanceDB** - wektorowa baza danych
+- **RAG** - wyszukiwanie semantyczne w bazie wiedzy
+
+## 📝 Konfiguracja (dla developerów)
+
+### Zmienne środowiskowe
+```bash
+OPENAI_API_KEY=sk-...        # Wymagane
+SERVER_HOST=0.0.0.0           # Dla Hugging Face Spaces
+SERVER_PORT=7860              # Port Gradio
+LOG_LEVEL=INFO                # Poziom logowania
+```
+
+### Instalacja lokalna
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+# Ustaw OPENAI_API_KEY w .env
+python app.py
+```
+
+### Test przed wdrożeniem
+```bash
+python test_startup.py
+```
+
+## 📖 Dokumentacja
+
+- [Deployment Guide](./README_DEPLOYMENT.md) - szczegółowy przewodnik wdrożeniowy
+- [WCAG 2.2](https://www.w3.org/TR/WCAG22/) - oficjalna specyfikacja
+- [ARIA](https://www.w3.org/TR/wai-aria/) - dostępne komponenty internetowe
+
+## 🐛 Rozwiązane problemy
+
+✅ Konflikty pętli zdarzeń asyncio  
+✅ Brak czyszczenia zasobów przy shutdown  
+✅ Konflikty wersji bibliotek (Pydantic 2.x)  
+✅ Graceful shutdown na Hugging Face Spaces  
+
+## 📄 Licencja
+
+Ten projekt służy celom edukacyjnym. Baza wiedzy pochodzi z publicznych źródeł (W3C, MDN).
+
+## 👨‍💻 Autor
+
+Stworzony z pomocą GitHub Copilot CLI

agent/a11y_agent.py

@@ -42,6 +42,17 @@ class A11yExpertAgent:
         
         logger.info(f"A11yExpertAgent initialized (lang={language}, expertise={expertise})")
     
+    def close(self):
+        """Close agent resources."""
+        try:
+            if self.vector_store:
+                self.vector_store.close()
+            if hasattr(self.llm_client, 'close'):
+                self.llm_client.close()
+            logger.info("A11yExpertAgent resources closed")
+        except Exception as e:
+            logger.warning(f"Error closing A11yExpertAgent: {e}")
+    
     async def ask(self, question: str) -> AsyncGenerator[str, None]:
         """
         Ask a question and get a streaming answer with RAG.

app.py

@@ -7,6 +7,7 @@ import asyncio
 import gradio as gr
 from loguru import logger
 import sys
+import atexit
 from agent.a11y_agent import create_agent, A11yExpertAgent
 from config import get_settings
 # --- Setup ---
@@ -15,17 +16,60 @@ logger.remove()
 logger.add(sys.stderr, level=get_settings().log_level)
 # Global agent instance
 agent_instance: A11yExpertAgent = None
+# Global event loop for async operations
+loop = None
+
 # --- Agent Initialization ---
-async def initialize_agent():
-    """Initialize the agent asynchronously."""
-    global agent_instance
+def initialize_agent_sync():
+    """Initialize the agent synchronously (wrapper for async init)."""
+    global agent_instance, loop
     try:
         logger.info("Initializing A11y Expert Agent...")
-        agent_instance = await create_agent()
+        # Use existing event loop if available, otherwise create new one
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_closed():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
+        agent_instance = loop.run_until_complete(create_agent())
         logger.success("✅ A11y Expert Agent is ready!")
     except Exception as e:
         logger.error(f"Failed to initialize agent: {e}")
         agent_instance = None
+
+def cleanup_resources():
+    """Clean up resources on app shutdown."""
+    global agent_instance, loop
+    logger.info("Cleaning up resources...")
+    try:
+        # Close agent and all its resources
+        if agent_instance:
+            agent_instance.close()
+        
+        # Close embeddings client singleton if it exists
+        from models.embeddings import get_embeddings_client
+        if hasattr(get_embeddings_client, '_instance'):
+            get_embeddings_client._instance.close()
+        
+        # Close event loop if it exists and is still open
+        if loop and not loop.is_closed():
+            # Cancel all pending tasks
+            try:
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            except RuntimeError:
+                pass  # Loop may already be stopped
+            loop.close()
+        
+        logger.success("✅ Resources cleaned up successfully")
+    except Exception as e:
+        logger.warning(f"Error during cleanup: {e}")
 # --- Gradio Chat Logic ---
 async def respond(message: str, history: list[list[str]]):
     """
@@ -38,7 +82,7 @@ async def respond(message: str, history: list[list[str]]):
     Yields:
         A stream of response chunks to update the UI.
     """
-    global agent_instance
+    global agent_instance, loop
     if not agent_instance:
         yield "Agent not initialized. Please check logs for errors."
         return
@@ -46,7 +90,7 @@ async def respond(message: str, history: list[list[str]]):
     logger.info(f"User query: '{message}'")
     full_response = ""
     try:
-        # Stream the response from the agent
+        # Use the global event loop to run async generator
         async for chunk in agent_instance.ask(message):
             full_response += chunk
             yield full_response
@@ -80,13 +124,22 @@ with gr.Blocks() as demo:
 
 # --- App Launch ---
 if __name__ == "__main__":
-    # Initialize agent synchronously using asyncio.run() before launching Gradio
-    # This avoids event loop conflicts with Gradio's own event loop
-    asyncio.run(initialize_agent())
+    # Register cleanup handler
+    atexit.register(cleanup_resources)
+    
+    # Initialize agent before launching Gradio
+    initialize_agent_sync()
     
     settings = get_settings()
     logger.info("Launching Gradio app...")
-    demo.launch(
-        server_name=settings.server_host,
-        server_port=settings.server_port,
-    )
+    
+    try:
+        demo.launch(
+            server_name=settings.server_host,
+            server_port=settings.server_port,
+            show_error=True,
+        )
+    except KeyboardInterrupt:
+        logger.info("Received interrupt signal")
+    finally:
+        cleanup_resources()

config.py

@@ -6,7 +6,7 @@ All settings can be configured via environment variables or .env file.
 """
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
-from pydantic import Field, validator
+from pydantic import Field, field_validator
 from functools import lru_cache
 import os
 
@@ -101,7 +101,8 @@ class Settings(BaseSettings):
         description="Gradio server port"
     )
     
-    @validator("openai_api_key")
+    @field_validator("openai_api_key")
+    @classmethod
     def validate_api_key(cls, v):
         """Ensure API key is provided and not empty."""
         v = v or ""
@@ -113,7 +114,8 @@ class Settings(BaseSettings):
             )
         return v
     
-    @validator("log_level")
+    @field_validator("log_level")
+    @classmethod
     def validate_log_level(cls, v):
         """Ensure log level is valid."""
         valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
@@ -125,12 +127,13 @@ class Settings(BaseSettings):
             )
         return v_upper
     
-    @validator("chunk_overlap")
-    def validate_overlap(cls, v, values):
+    @field_validator("chunk_overlap")
+    @classmethod
+    def validate_overlap(cls, v, info):
         """Ensure chunk overlap is less than chunk size."""
-        if "chunk_size" in values and v >= values["chunk_size"]:
+        if info.data and "chunk_size" in info.data and v >= info.data["chunk_size"]:
             raise ValueError(
-                f"chunk_overlap ({v}) must be less than chunk_size ({values['chunk_size']})"
+                f"chunk_overlap ({v}) must be less than chunk_size ({info.data['chunk_size']})"
             )
         return v
     

models/embeddings.py

@@ -110,6 +110,17 @@ class EmbeddingsClient:
             self.cache = None
             logger.info(f"✅ EmbeddingsClient initialized (model: {self.model}, cache: disabled)")
     
+    def close(self):
+        """Close cache and clean up resources."""
+        try:
+            if self.cache is not None:
+                self.cache.close()
+                logger.info("EmbeddingsClient cache closed")
+            if hasattr(self.client, 'close'):
+                self.client.close()
+        except Exception as e:
+            logger.warning(f"Error closing EmbeddingsClient: {e}")
+    
     def _get_cache_key(self, text: str) -> str:
         """
         Generate cache key for text.

requirements.txt

@@ -1,9 +1,9 @@
 # Core application libraries
-gradio
-openai
-lancedb
-pydantic-settings
-loguru
-langdetect
-diskcache
-pandas
+gradio>=4.0.0,<5.0.0
+openai>=1.0.0,<2.0.0
+lancedb>=0.3.0,<1.0.0
+pydantic-settings>=2.0.0,<3.0.0
+loguru>=0.7.0,<1.0.0
+langdetect>=1.0.0,<2.0.0
+diskcache>=5.6.0,<6.0.0
+pandas>=2.0.0,<3.0.0

vector_store_client.py

@@ -354,6 +354,6 @@ class VectorStoreClient:
                 # but we clear references to help garbage collection
                 self._table = None
                 self._db = None
-                logger.debug("VectorStoreClient resources cleared")
+                logger.info("VectorStoreClient resources cleared")
         except Exception as e:
             logger.warning(f"Error during VectorStoreClient cleanup: {e}")