Merge pull request #22 from basedosdados/dev

Update deploy workflow

Author: vrtornisiello

.github/workflows/deploy-dev.yaml

@@ -76,8 +76,8 @@ jobs:
                 nginx.ingress.kubernetes.io/ssl-redirect: "true"
                 cert-manager.io/issuer: letsencrypt-production
                 nginx.ingress.kubernetes.io/configuration-snippet: |
-                  # Redirect exact /chatbot → /chatbot/ with a 301
-                  rewrite ^/chatbot$ /chatbot/ permanent;
+                  # Redirect exact /chatbot-streamlit → /chatbot-streamlit/ with a 301
+                  rewrite ^/chatbot-streamlit$ /chatbot-streamlit/ permanent;
               tls:
                 - hosts:
                     - development.basedosdados.org

Dockerfile

@@ -3,8 +3,15 @@ FROM python:3.13-slim
 WORKDIR /app/frontend
 
 COPY . .
-RUN pip install --upgrade pip && pip install --no-cache-dir .
+
+RUN pip install --upgrade pip && \
+    pip install --user pipx
+
+ENV PATH="/root/.local/bin:$PATH"
+
+RUN pipx install poetry==2.1.3 && \
+    poetry install --only main
 
 EXPOSE 8501
 
-CMD ["bash", "-c", "streamlit run frontend/main.py"]
+CMD ["bash", "-c", "poetry run streamlit run frontend/main.py"]

frontend/api/__init__.py

@@ -1 +1,3 @@
 from .api_client import APIClient
+
+__all__ = ["APIClient"]

frontend/api/api_client.py

@@ -1,9 +1,11 @@
+import json
+from typing import Iterator
 from uuid import UUID
 
-import requests
+import httpx
 from loguru import logger
 
-from frontend.datatypes import MessagePair, Thread, UserMessage
+from frontend.datatypes import MessagePair, Step, Thread, UserMessage
 
 
 class APIClient:
@@ -12,21 +14,21 @@ def __init__(self, base_url: str):
         self.logger = logger.bind(classname=self.__class__.__name__)
 
     def authenticate(self, email: str, password: str) -> tuple[str|None, str]:
-        """Send a post request to the authentication endpoint
+        """Send a post request to the authentication endpoint.
 
         Args:
-            email (str): The email
-            password (str): The password
+            email (str): The email.
+            password (str): The password.
 
         Returns:
-            tuple[str|None, str]: A tuple containing the access token and a status message
+            tuple[str|None, str]: A tuple containing the access token and a status message.
         """
         access_token = None
 
         message = "Ops! Ocorreu um erro durante o login. Por favor, tente novamente."
 
         try:
-            response = requests.post(
+            response = httpx.post(
                 url=f"{self.base_url}/chatbot/token/",
                 data={
                     "email": email,
@@ -42,104 +44,179 @@ def authenticate(self, email: str, password: str) -> tuple[str|None, str]:
                 message = "Conectado com sucesso!"
             else:
                 self.logger.error(f"[LOGIN] No access token returned")
-        except requests.exceptions.HTTPError:
-            if response.status_code == requests.codes.unauthorized:
+        except httpx.HTTPStatusError:
+            if response.status_code == httpx.codes.UNAUTHORIZED:
                 self.logger.warning(f"[LOGIN] Invalid credentials")
                 message = "Usuário ou senha incorretos."
             else:
                 self.logger.exception(f"[LOGIN] HTTP error:")
-        except requests.exceptions.RequestException:
+        except Exception:
             self.logger.exception(f"[LOGIN] Login error:")
 
         return access_token, message
 
-    def create_thread(self, access_token: str) -> UUID|None:
-        """Create a thread
+    def create_thread(self, access_token: str, title: str) -> Thread|None:
+        """Create a thread.
 
         Args:
-            access_token (str): User access token
+            access_token (str): User access token.
+            title (str): The thread title.
 
         Returns:
-            UUID|None: Thread unique identifier if the thread was created successfully. None otherwise
+            Thread|None: A Thread object if the thread was created successfully. None otherwise.
         """
         self.logger.info("[THREAD] Creating thread")
 
         try:
-            response = requests.post(
+            response = httpx.post(
                 url=f"{self.base_url}/chatbot/threads/",
-                headers={"Authorization": f"Bearer {access_token}"}
+                json={"title": title},
+                headers={"Authorization": f"Bearer {access_token}"},
             )
             response.raise_for_status()
             thread = Thread(**response.json())
-            self.logger.success(f"[MESSAGE] Thread created successfully for user {thread.id}")
-            return thread.id
-        except requests.RequestException:
-            self.logger.exception(f"[MESSAGE] Error on thread creation:")
+            self.logger.success(f"[THREAD] Thread created successfully for user {thread.account}")
+            return thread
+        except Exception:
+            self.logger.exception(f"[THREAD] Error on thread creation:")
             return None
 
-    def send_message(self, access_token: str, message: str, thread_id: UUID) -> MessagePair:
-        """Send a user message
+    def get_threads(self, access_token: str) -> list[Thread]|None:
+        """Get all threads from a user.
 
         Args:
-            access_token (str): User access token
-            message (str): User message
-            thread_id (UUID): Thread unique identifier
+            access_token (str): User access token.
 
         Returns:
-            MessagePair:
-                A MessagePair object containing:
-                    - id: unique identifier
-                    - thread: thread unique identifier
-                    - model_uri: assistant's model URI
-                    - user_message: user message
-                    - assistant_message: assistant message
-                    - generated_queries: generated sql queries
-                    - generated_chart: generated data for visualization
-                    - created_at: message pair creation timestamp
+            list[Thread]|None: A list of Thread objects if any thread was found. None otherwise.
+        """
+        self.logger.info("[THREAD] Retrieving threads")
+        try:
+            response = httpx.get(
+                url=f"{self.base_url}/chatbot/threads/",
+                params={"order_by": "created_at"},
+                headers={"Authorization": f"Bearer {access_token}"}
+            )
+            response.raise_for_status()
+            threads = [Thread(**thread) for thread in response.json()]
+            self.logger.success(f"[THREAD] Threads retrieved successfully")
+            return threads
+        except Exception:
+            self.logger.exception(f"[THREAD] Error on threads retrieval:")
+            return None
+
+    def get_message_pairs(self, access_token: str, thread_id: UUID) -> list[MessagePair]|None:
+        self.logger.info(f"[MESSAGE] Retrieving message pairs for thread {thread_id}")
+        try:
+            response = httpx.get(
+                url=f"{self.base_url}/chatbot/threads/{thread_id}/messages/",
+                params={"order_by": "created_at"},
+                headers={"Authorization": f"Bearer {access_token}"}
+            )
+            response.raise_for_status()
+            message_pairs = [MessagePair(**pair) for pair in response.json()]
+            self.logger.success(f"[MESSAGE] Message pairs retrieved successfully for thread {thread_id}")
+            return message_pairs
+        except Exception:
+            self.logger.exception(f"[MESSAGE] Error on message pairs retrieval for thread {thread_id}:")
+            return None
+
+    def send_message(self, access_token: str, message: str, thread_id: UUID) -> Iterator[tuple[str, Step|MessagePair]]:
+        """Send a user message and stream the assistant's response.
+
+        Args:
+            access_token (str): The user's access token.
+            message (str): The message sent by the user.
+            thread_id (UUID): The unique identifier of the thread.
+
+        Yields:
+            Iterator[tuple[str, Step|MessagePair]]: Tuples containing a status message and either a `Step` or `MessagePair` object.
+                While streaming, `Step` objects are yielded. Once streaming is complete, a final `MessagePair` is yielded.
         """
         user_message = UserMessage(content=message)
 
         self.logger.info(f"[MESSAGE] Sending message {user_message.id} in thread {thread_id}")
 
+        steps = []
+        error_message = None
+        stream_completed = False
+
         try:
-            response = requests.post(
+            with httpx.stream(
+                method="POST",
                 url=f"{self.base_url}/chatbot/threads/{thread_id}/messages/",
+                headers={"Authorization": f"Bearer {access_token}"},
                 json=user_message.model_dump(mode="json"),
-                headers={"Authorization": f"Bearer {access_token}"}
+                timeout=httpx.Timeout(5.0, read=300.0),
+            ) as response:
+                response.raise_for_status()
+
+                self.logger.success(f"[MESSAGE] User message sent successfully")
+
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+
+                    payload = json.loads(line)
+                    streaming_status = payload["status"]
+                    data = payload["data"]
+
+                    if streaming_status == "running":
+                        message = Step.model_validate_json(data)
+                        steps.append(message)
+                    elif streaming_status == "complete":
+                        data["steps"] = steps
+                        message = MessagePair(**data)
+                        stream_completed = True
+
+                    yield streaming_status, message
+        except httpx.ReadTimeout:
+            self.logger.exception(f"[MESSAGE] Timeout error on sending user message:")
+            error_message=(
+                "Ops, parece que a solicitação expirou! Por favor, tente novamente. "
+                "Se o problema persistir, avise-nos. Obrigado pela paciência!"
             )
-            response.raise_for_status()
-            self.logger.success(f"[MESSAGE] User message sent successfully")
-            message_pair = response.json()
-        except requests.RequestException:
+        except Exception:
             self.logger.exception(f"[MESSAGE] Error on sending user message:")
-            message_pair = {
-                "thread": thread_id,
-                "model_uri": "",
-                "user_message": user_message.content,
-                "assistant_message": "Ops, algo deu errado! Por favor, tente novamente. "\
-                    "Se o problema persistir, avise-nos. Obrigado pela paciência!"
-            }
+            error_message=(
+                "Ops, algo deu errado! Por favor, tente novamente. "
+                "Se o problema persistir, avise-nos. Obrigado pela paciência!"
+            )
 
-        return MessagePair(**message_pair)
+        # Safeguard for unexpected stream termination. Handles cases where the server
+        # crashes ands the httpx.stream() call ends silently without raising an exception.
+        if not stream_completed:
+            if not error_message:
+                self.logger.error("[MESSAGE] Stream terminated without a 'complete' status")
+                error_message=(
+                    "Ops, a conexão com o servidor foi interrompida inesperadamente! "
+                    "Por favor, tente novamente mais tarde. Se o problema persistir, avise-nos."
+                )
+            message = MessagePair(
+                user_message=user_message.content,
+                error_message=error_message,
+                steps=steps or [],
+            )
+            yield "complete", message
 
     def send_feedback(self, access_token: str, message_pair_id: UUID, rating: int, comments: str) -> bool:
-        """Send a feedback
+        """Send a feedback.
 
         Args:
-            access_token (str): User access token
-            message_pair_id (UUID): The message pair unique identifier
-            rating (int): The rating (0 or 1)
-            comments (str): The comments
+            access_token (str): User access token.
+            message_pair_id (UUID): The message pair unique identifier.
+            rating (int): The rating (0 or 1).
+            comments (str): The comments.
 
         Returns:
-            bool: Whether the operation succeeded or not
+            bool: Whether the operation succeeded or not.
         """
         feedback_meaning = "positive" if rating else "negative"
 
         self.logger.info(f"[FEEDBACK] Sending {feedback_meaning} feedback for message pair {message_pair_id}")
 
         try:
-            response = requests.put(
+            response = httpx.put(
                 url=f"{self.base_url}/chatbot/message-pairs/{message_pair_id}/feedbacks/",
                 json={
                     "rating": rating,
@@ -150,30 +227,30 @@ def send_feedback(self, access_token: str, message_pair_id: UUID, rating: int, c
             response.raise_for_status()
             self.logger.success(f"[FEEDBACK] Feedback sent successfully")
             return True
-        except requests.exceptions.RequestException:
+        except Exception:
             self.logger.exception(f"[FEEDBACK] Error on sending feedback:")
             return False
 
-    def clear_thread(self, access_token: str, thread_id: UUID) -> bool:
-        """Clear a thread
+    def delete_thread(self, access_token: str, thread_id: UUID) -> bool:
+        """Soft delete a thread and hard delete all its checkpoints.
 
         Args:
-            access_token (str): User access token
-            thread_id (UUID): Thread unique identifier
+            access_token (str): User access token.
+            thread_id (UUID): Thread unique identifier.
 
         Returns:
-            bool: Whether the operation succeeded or not
+            bool: Whether the operation succeeded or not.
         """
         self.logger.info(f"""[CLEAR] Clearing assistant memory""")
 
         try:
-            response = requests.delete(
-                url=f"{self.base_url}/chatbot/checkpoints/{thread_id}/",
+            response = httpx.delete(
+                url=f"{self.base_url}/chatbot/threads/{thread_id}/",
                 headers={"Authorization": f"Bearer {access_token}"}
             )
             response.raise_for_status()
             self.logger.success(f"[CLEAR] Assistant memory cleared successfully")
             return True
-        except requests.exceptions.RequestException:
+        except Exception:
             self.logger.exception("[CLEAR] Error on clearing assistant memory:")
             return False

frontend/components/__init__.py

@@ -3,3 +3,13 @@
 from .stylable_containers import chart_button_container, code_button_container
 from .three_dots import three_pulsing_dots, three_waving_dots
 from .typewriter import typewrite
+
+__all__ = [
+    "render_card",
+    "render_disclaimer",
+    "chart_button_container",
+    "code_button_container",
+    "three_pulsing_dots",
+    "three_waving_dots",
+    "typewrite"
+]