Creating a gradio APP

main.py

@@ -1,76 +1,61 @@
-import os
-from datetime import datetime
+from queue import Queue
 
 import argilla as rg
+import gradio as gr
 
-# Environment variables with defaults
-API_KEY = os.environ.get("ARGILLA_API_KEY", "argilla.apikey")
-API_URL = os.environ.get("ARGILLA_API_URL", "http://localhost:6900")
+client = rg.Argilla()
 
-# Initialize Argilla client
-client = rg.Argilla(api_key=API_KEY, api_url=API_URL)
+server = rg.get_webhook_server()
+incoming_events = Queue()
+
+# Set up the webhook listeners
 
-# Show the existing webhooks in the argilla server
+# Delete all existing webhooks
 for webhook in client.webhooks:
-    print(webhook.url)
-
-
-# Create a webhook listener using the decorator
-# This decorator will :
-# 1. Create the webhook in the argilla server
-# 2. Create a POST endpoint in the server
-# 3. Handle the incoming requests to verify the webhook signature
-# 4. Ignoring the events other than the ones specified in the `events` argument
-# 5. Parse the incoming request and call the decorated function with the parsed data
-#
-# Each event will be passed as a keyword argument to the decorated function depending on the event type.
-# The event types are:
-# - record: created, updated, deleted and completed
-# - response: created, updated, deleted
-# - dataset: created, updated, published, deleted
-# Related resources will be passed as keyword arguments to the decorated function
-# (for example the dataset for a record-related event, or the record for a response-related event)
-# When a resource is deleted
-@rg.webhook_listener(events=["record.created", "record.completed"])
-async def listen_record(
-    record: rg.Record, dataset: rg.Dataset, type: str, timestamp: datetime
-):
-    print(f"Received record event of type {type} at {timestamp}")
-
-    action = "completed" if type == "record.completed" else "created"
-    print(f"A record with id {record.id} has been {action} for dataset {dataset.name}!")
-
-
-@rg.webhook_listener(events="response.updated")
-async def trigger_something_on_response_updated(response: rg.UserResponse, **kwargs):
-    print(
-        f"The user response {response.id} has been updated with the following responses:"
-    )
-    print([response.serialize() for response in response.responses])
+    webhook.delete()
+
+# Create a webhook for record events
+@rg.webhook_listener(events=["record.created", "record.updated", "record.completed"])
+async def record_events(record: rg.Record, **kwargs):
+    print(f"Received event {kwargs['type']} for record {record.id}")
 
+    incoming_events.put(record)
 
+# Create a webhook for dataset events
 @rg.webhook_listener(events=["dataset.created", "dataset.updated", "dataset.published"])
-async def with_raw_payload(
-    type: str,
-    timestamp: datetime,
-    dataset: rg.Dataset,
-    **kwargs,
-):
-    print(f"Event type {type} at {timestamp}")
-    print(dataset.settings)
+async def dataset_events(type: str, dataset: rg.Dataset | None = None, **kwargs):
 
+    if "deleted" in type:
+        print(f"Received event {type} for dataset {kwargs['data']}")
+        incoming_events.put((type, kwargs["data"]))
+    else:
+        print(f"Received event {type} for dataset {dataset.id}")
+        incoming_events.put((type, dataset))
 
-@rg.webhook_listener(events="dataset.deleted")
-async def on_dataset_deleted(
-    data: dict,
-    **kwargs,
-):
-    print(f"Dataset {data} has been deleted!")
 
+# Create a webhook for response events
+@rg.webhook_listener(events=["response.created", "response.updated", "response.deleted"])
+async def response_events(response: rg.UserResponse, **kwargs):
+    print(f"Received event {kwargs['type']} for response {response.id}")
 
-# Set the webhook server. The server is a FastAPI instance, so you need to expose it in order to run it using uvicorn:
-# ```bash
-# uvicorn main:webhook_server --reload
-# ```
+    incoming_events.put(response)
 
-server = rg.get_webhook_server()
+
+def check_incoming_events():
+    """
+    This function is called every 5 seconds to check if there are any incoming
+    events and send data to update the JSON component.
+    """
+    events = []
+    while not incoming_events.empty():
+        events.append(incoming_events.get())
+
+    return {"events": events}
+
+
+with gr.Blocks() as demo:
+    json_component = gr.JSON(label="Incoming argilla events:")
+    gr.Timer(5, active=True).tick(check_incoming_events, outputs=json_component)
+
+
+gr.mount_gradio_app(server, demo, path="/gradio")

requirements.txt

@@ -1,3 +1,2 @@
+gradio
 argilla @ git+https://github.com/argilla-io/argilla.git@feat/argilla/working-with-webhooks#subdirectory=argilla
-fastapi
-uvicorn[standard]