Update app.py

app.py

@@ -1,115 +1,100 @@
 import os
-from datetime import datetime
 from queue import Queue
-from argilla.webhooks import webhook_listener
-
-import argilla as rg
 import gradio as gr
+import argilla as rg
+from argilla.webhooks import webhook_listener
+from dotenv import load_dotenv
 
+# Load environment variables
+load_dotenv()
 
-client = rg.Argilla()
+# Initialize Argilla client
+client = rg.Argilla(
+    api_url=os.getenv("API_URL"),
+    api_key=os.getenv("ARGILLA_API_KEY"),
+)
 
+# Get the webhook server
 server = rg.get_webhook_server()
-incoming_events = Queue()
-
-# Set up the webhook listeners
 
-# Delete all existing webhooks
-for webhook in client.webhooks:
-    print(f"Deleting webhook: {webhook.url}")
-    webhook.delete()
+# Queue to store events for display
+incoming_events = Queue()
 
-@webhook_listener(events="record.completed")
-async def update_validation_space_on_answer(record: rg.Record, type: str):
+# Set up the webhook listener for response creation
+@webhook_listener(events=["response.created"])
+async def update_validation_space_on_answer(response, type, timestamp):
     """
     Webhook listener that triggers when a new response is added to an answering space.
     It will automatically update the corresponding validation space with the new response.
-    
-    Args:
-        event: The webhook event containing the user response data
     """
+    # Store the event for display in the UI
+    incoming_events.put({"event": type, "data": str(response)})
     
+    # Get the record from the response
+    record = response.record
+    
+    # Check if this is from an answering space
     dataset_name = record.dataset.name
     if not dataset_name.endswith("_responder_preguntas"):
+        print(f"Ignoring event from non-answering dataset: {dataset_name}")
         return  # Not an answering space, ignore
     
     # Extract the country from the dataset name
     country = dataset_name.replace("_responder_preguntas", "")
+    print(f"Processing response for country: {country}")
     
+    # Connect to the validation space
     validation_dataset_name = f"{country}_validar_respuestas"
     try:
         validation_dataset = client.datasets(validation_dataset_name)
+        print(f"Found validation dataset: {validation_dataset_name}")
     except Exception as e:
         print(f"Error connecting to validation dataset: {e}")
+        # You would need to import the create_validation_space function
+        from your_module import create_validation_space
         validation_dataset = create_validation_space(country)
     
+    # Create a validation record
     validation_record = {
         "question": record.fields["question"],
         "answer": response.value,
     }
     
+    # Add the record to the validation space
     validation_dataset.records.log(records=[validation_record])
-    
-    incoming_events.put({"event": type,  "data": record})
     print(f"Added new response to validation space for {country}")
 
-
-# Create a webhook for record events
-# @rg.webhook_listener(events=["record.deleted", "record.completed"])
-# async def record_events(record: rg.Record, type: str, timestamp: datetime):
-#     print(f"Received event type {type} at {timestamp}: ", record)
-
-#     incoming_events.put({"event": type,  "data": record})
-
-
-# Create a webhook for dataset events
-# @rg.webhook_listener(events=["dataset.created", "dataset.updated", "dataset.deleted", "dataset.published"])
-# async def dataset_events(dataset: rg.Dataset, type: str, timestamp: datetime):
-#     print(f"Received event type {type} at {timestamp}: ", dataset)
-
-#     incoming_events.put({"event": type,  "data": dataset})
-
-
-# Create a webhook for response events
-# @rg.webhook_listener(events=["response.created", "response.updated"])
-# async def response_events(response: rg.UserResponse, type: str, timestamp: datetime):
-#     print(f"Received event type {type} at {timestamp}: ", response)
-
-#     incoming_events.put({"event": type,  "data": response})
-
-
+# Function to read the next event from the queue
 def read_next_event():
-    event = incoming_events.get()
-
-    return event
-
+    if not incoming_events.empty():
+        return incoming_events.get()
+    return {}
 
+# Create Gradio interface
 with gr.Blocks() as demo:
     argilla_server = client.http_client.base_url
-    gr.Markdown("## Argilla Webhooks")
+    gr.Markdown("## Argilla Webhooks - Validation Space Updater")
     gr.Markdown(f"""
-        This demo shows the incoming events from the [Argilla Server]({argilla_server}).
+        This application listens for new responses in Argilla answering spaces and automatically 
+        adds them to the corresponding validation spaces.
         
-        The application defines three webhook listeners for the following events:
-
-        - Record events: `record.deleted`, `record.completed`
-        - Dataset events: `dataset.created`, `dataset.updated`, `dataset.deleted`, `dataset.published`
-        - Response events: `response.created`, `response.updated`
-                
-        The events are stored in a queue and displayed in the JSON component and the incoming events is updated every second.
+        Connected to Argilla server: {argilla_server}
         
-        You can view the incoming events in the JSON component below.
+        The webhook listens for:
+        - `response.created` events from datasets ending with `_responder_preguntas`
         
-        This application is just a demonstration of how to use the Argilla webhook listeners.
+        When a new response is created, it is added to the corresponding validation space
+        named `[country]_validar_respuestas`.
         
-        You can visit the [Argilla documentation](https://docs.argilla.io/dev/how_to_guides/webhooks) for more information.
+        You can view the incoming events in the JSON component below.
     """)
-    json_component = gr.JSON(label="Incoming argilla events:", value={})
+    json_component = gr.JSON(label="Incoming response events:", value={})
     gr.Timer(1, active=True).tick(read_next_event, outputs=json_component)
 
+# Mount the Gradio app to the FastAPI server
 gr.mount_gradio_app(server, demo, path="/")
 
 # Start the FastAPI server
-import uvicorn
-
-uvicorn.run(server, host="0.0.0.0", port=7860)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(server, host="0.0.0.0", port=7860)