restore playground/ to main branch version

Author: tibo-pdn

playground/app/core/configuration.py

@@ -103,7 +103,7 @@ class ConfigFile(ConfigBaseModel):
     The following parameters allow you to configure the Playground application. The configuration file can be shared with the API, as the sections are
     identical and compatible. Some parameters are common to both the API and the Playground (for example, `app_title`).
 
-    For Playground deployment, some environment variables are required to be set, like Reflex backend URL. See
+    For Plagroud deployment, some environment variables are required to be set, like Reflex backend URL. See
     [Environment variables](/configuration/environment_variable/#playground) for more information.
     """
 

playground/app/features/chat/state.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any
 
 import httpx
@@ -126,136 +125,142 @@ def set_stop_sequences(self, sequences: str):
         """Set the stop sequences."""
         self.stop_sequences = sequences
 
-    @rx.event(background=True)
+    @rx.event
     async def process_question(self, form_data: dict[str, Any]):
+        # Get the question from the form
         question = form_data["question"]
+
+        # Check if the question is empty
         if not question:
             return
 
-        # Check auth, set up initial state, and snapshot all needed values
-        async with self:
-            if not self.is_authenticated or not self.api_key:
-                return
-
-            qa = QA(question=question, answer="")
-            self._messages.append(qa)
-            self.processing = True
-
-            url = self.opengatellm_url
-            api_key = self.api_key
-            model = self.model
-            temperature = self.temperature
-            top_p = self.top_p
-            max_completion_tokens = self.max_completion_tokens
-            frequency_penalty = self.frequency_penalty
-            presence_penalty = self.presence_penalty
-            stream = self.stream
-            seed_str = self.seed_str
-            stop_sequences_str = self.stop_sequences
-            messages_snapshot = list(self._messages)
-            yield
+        async for value in self.api_process_question(question):
+            yield value
+
+    @rx.event
+    async def api_process_question(self, question: str):
+        """Get the response from the API.
+
+        Args:
+            question: The user's question.
+        """
+
+        # Check if authenticated
+        if not self.is_authenticated or not self.api_key:
+            return
 
-        # Build messages outside the lock
+        # Add the question to the list of questions.
+        qa = QA(question=question, answer="")
+        self._messages.append(qa)
+
+        # Clear the input and start the processing.
+        self.processing = True
+        yield
+
+        # Build the messages.
         messages = []
-        for qa in messages_snapshot:
+        for qa in self._messages:
             messages.append({"role": "user", "content": qa["question"]})
             if qa["answer"]:
                 messages.append({"role": "assistant", "content": qa["answer"]})
 
+        # Remove the last empty answer.
         if messages and messages[-1]["role"] == "assistant" and not messages[-1]["content"]:
             messages = messages[:-1]
 
+        # Prepare the request payload
         payload = {
-            "model": model,
+            "model": self.model,
             "messages": messages,
-            "temperature": temperature,
-            "top_p": top_p,
-            "max_completion_tokens": max_completion_tokens,
-            "frequency_penalty": frequency_penalty,
-            "presence_penalty": presence_penalty,
-            "stream": stream,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "max_completion_tokens": self.max_completion_tokens,
+            "frequency_penalty": self.frequency_penalty,
+            "presence_penalty": self.presence_penalty,
+            "stream": self.stream,
         }
 
-        if seed_str:
+        # Add optional parameters
+        if self.seed_str:
             try:
-                payload["seed"] = int(seed_str)
+                payload["seed"] = int(self.seed_str)
             except ValueError:
                 pass
 
-        if stop_sequences_str:
-            stop_list = [s.strip() for s in stop_sequences_str.split("\n") if s.strip()]
+        if self.stop_sequences:
+            stop_list = [s.strip() for s in self.stop_sequences.split("\n") if s.strip()]
             if stop_list:
                 payload["stop"] = stop_list
 
         try:
-            if stream:
+            if self.stream:
+                # Streaming response
                 async with httpx.AsyncClient() as client:
                     async with client.stream(
                         "POST",
-                        f"{url}/v1/chat/completions",
+                        f"{self.opengatellm_url}/v1/chat/completions",
                         headers={
-                            "Authorization": f"Bearer {api_key}",
+                            "Authorization": f"Bearer {self.api_key}",
                             "Content-Type": "application/json",
                         },
                         json=payload,
                         timeout=configuration.settings.playground_opengatellm_timeout,
                     ) as response:
                         if response.status_code != 200:
                             error_text = await response.aread()
-                            async with self:
-                                self._messages[-1]["answer"] = f"Error: {error_text.decode()}"
-                                self.processing = False
-                                yield
+                            self._messages[-1]["answer"] = f"Error: {error_text.decode()}"
+                            self.processing = False
+                            yield
                             return
 
                         async for line in response.aiter_lines():
                             if line.startswith("data: "):
                                 data = line[6:]
                                 if data == "[DONE]":
                                     break
+
                                 try:
+                                    import json
+
                                     chunk = json.loads(data)
                                     if chunk.get("choices") and len(chunk["choices"]) > 0:
                                         delta = chunk["choices"][0].get("delta", {})
                                         content = delta.get("content")
                                         if content:
-                                            async with self:
-                                                self._messages[-1]["answer"] += content
-                                                self._messages = self._messages
-                                                yield
+                                            self._messages[-1]["answer"] += content
+                                            self._messages = self._messages
+                                            yield
                                 except Exception:
                                     continue
             else:
+                # Non-streaming response
                 async with httpx.AsyncClient() as client:
                     response = await client.post(
-                        f"{url}/v1/chat/completions",
+                        f"{self.opengatellm_url}/v1/chat/completions",
                         headers={
-                            "Authorization": f"Bearer {api_key}",
+                            "Authorization": f"Bearer {self.api_key}",
                             "Content-Type": "application/json",
                         },
                         json=payload,
                         timeout=configuration.settings.playground_opengatellm_timeout,
                     )
 
-                async with self:
                     if response.status_code != 200:
                         self._messages[-1]["answer"] = f"Error: {response.text}"
                     else:
                         data = response.json()
                         if data.get("choices") and len(data["choices"]) > 0:
                             content = data["choices"][0]["message"]["content"]
                             self._messages[-1]["answer"] = content
+
                     yield
 
         except httpx.TimeoutException:
-            async with self:
-                self._messages[-1]["answer"] = "Error: Request timeout"
-                yield
+            self._messages[-1]["answer"] = "Error: Request timeout"
+            yield
         except Exception as e:
-            async with self:
-                self._messages[-1]["answer"] = f"Error: {str(e)}"
-                yield
-        finally:
-            async with self:
-                self.processing = False
-                yield
+            self._messages[-1]["answer"] = f"Error: {str(e)}"
+            yield
+
+        # Toggle the processing flag.
+        self.processing = False

playground/app/features/keys/state.py

@@ -33,62 +33,46 @@ def keys(self) -> list[Key]:
         """Get keys list with correct typing for Reflex."""
         return self.entities
 
-    @rx.event(background=True)
+    @rx.event
     async def load_entities(self):
         """Load entities."""
-        async with self:
-            if not self.is_authenticated or not self.api_key:
-                return
-            self.entities_loading = True
-            url = self.opengatellm_url
-            api_key = self.api_key
-            page = self.page
-            per_page = self.per_page
-            order_by = self.order_by_value
-            order_direction = self.order_direction_value
-            yield
+        if not self.is_authenticated or not self.api_key:
+            return
+
+        self.entities_loading = True
+        yield
 
         params = {
-            "offset": (page - 1) * per_page,
-            "limit": per_page,
-            "order_by": order_by,
-            "order_direction": order_direction,
+            "offset": (self.page - 1) * self.per_page,
+            "limit": self.per_page,
+            "order_by": self.order_by_value,
+            "order_direction": self.order_direction_value,
         }
 
         response = None
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.get(
-                    url=f"{url}/v1/me/keys",
+                    url=f"{self.opengatellm_url}/v1/me/keys",
                     params=params,
-                    headers={"Authorization": f"Bearer {api_key}"},
+                    headers={"Authorization": f"Bearer {self.api_key}"},
                     timeout=configuration.settings.playground_opengatellm_timeout,
                 )
+
                 response.raise_for_status()
                 data = response.json()
-                entities = [
-                    Key(
-                        id=k["id"],
-                        name=k["name"],
-                        token=k["token"],
-                        expires=dt.datetime.fromtimestamp(k["expires"]).strftime("%Y-%m-%d %H:%M") if k["expires"] else "never",
-                        created=dt.datetime.fromtimestamp(k["created"]).strftime("%Y-%m-%d %H:%M"),
-                    )
-                    for k in data.get("data", [])
-                    if k["name"] != "playground"
-                ]
-            has_more = len(entities) == per_page
-            async with self:
-                self.entities = entities
-                self.has_more_page = has_more
-                yield
+                self.entities = []
+
+                for key in data.get("data", []):
+                    if key["name"] != "playground":
+                        self.entities.append(self._format_key(key))
+
+            self.has_more_page = len(self.entities) == self.per_page
         except Exception as e:
-            async with self:
-                yield httpx_error_toast(exception=e, response=response)
+            yield httpx_error_toast(exception=e, response=response)
         finally:
-            async with self:
-                self.entities_loading = False
-                yield
+            self.entities_loading = False
+            yield
 
     ############################################################
     # Delete entity
@@ -128,7 +112,8 @@ async def delete_entity(self):
 
                 self.handle_delete_entity_dialog_change(is_open=False)
                 yield rx.toast.success("Key deleted successfully", position="bottom-right")
-                yield type(self).load_entities()
+                async for _ in self.load_entities():
+                    yield
 
         except Exception as e:
             yield httpx_error_toast(exception=e, response=response)
@@ -209,7 +194,8 @@ async def create_entity(self):
                 self.is_created_dialog_open = True
 
                 yield rx.toast.success("Key created successfully", position="bottom-right")
-                yield type(self).load_entities()
+                async for _ in self.load_entities():
+                    yield
 
         except Exception as e:
             yield httpx_error_toast(exception=e, response=response)
@@ -228,34 +214,38 @@ async def create_entity(self):
     order_direction_value: str = "asc"
     order_by_options: list[str] = ["id", "name", "created"]
 
-    @rx.event(background=True)
+    @rx.event
     async def set_order_by(self, value: str):
         """Set order by field and reload."""
-        async with self:
-            self.order_by_value = value
-            self.page = 1
-            self.has_more_page = False
-            yield type(self).load_entities()
+        self.order_by_value = value
+        self.page = 1
+        self.has_more_page = False
+        yield
+        async for _ in self.load_entities():
+            yield
 
-    @rx.event(background=True)
+    @rx.event
     async def set_order_direction(self, value: str):
         """Set order direction and reload."""
-        async with self:
-            self.order_direction_value = value
-            self.page = 1
-            self.has_more_page = False
-            yield type(self).load_entities()
+        self.order_direction_value = value
+        self.page = 1
+        self.has_more_page = False
+        yield
+        async for _ in self.load_entities():
+            yield
 
-    @rx.event(background=True)
+    @rx.event
     async def prev_page(self):
-        async with self:
-            if self.page > 1:
-                self.page -= 1
-                yield type(self).load_entities()
+        if self.page > 1:
+            self.page -= 1
+            yield
+            async for _ in self.load_entities():
+                yield
 
-    @rx.event(background=True)
+    @rx.event
     async def next_page(self):
-        async with self:
-            if self.has_more_page:
-                self.page += 1
-                yield type(self).load_entities()
+        if self.has_more_page:
+            self.page += 1
+            yield
+            async for _ in self.load_entities():
+                yield