chore: py client tests

Author: abcxff

clients/python/README.md

@@ -0,0 +1,65 @@
+# ActorCore Python Client
+
+_The Python client for ActorCore, the Stateful Serverless Framework_
+
+Use this client to connect to ActorCore services from Python applications.
+
+## Resources
+
+- [Quickstart](https://actorcore.org/introduction)
+- [Documentation](https://actorcore.org/clients/python)
+- [Examples](https://github.com/rivet-gg/actor-core/tree/main/examples)
+
+## Getting Started
+
+### Step 1: Installation
+
+```bash
+pip install python-actor-core-client
+```
+
+### Step 2: Connect to Actor
+
+```python
+from python_actor_core_client import AsyncClient as ActorClient
+import asyncio
+
+async def main():
+    # Create a client connected to your ActorCore manager
+    client = ActorClient("http://localhost:6420")
+
+    # Connect to a chat room actor
+    chat_room = await client.get("chat-room", tags=[("room", "general")])
+
+    # Listen for new messages
+    chat_room.on_event("newMessage", lambda msg: print(f"New message: {msg}"))
+
+    # Send message to room
+    await chat_room.action("sendMessage", ["alice", "Hello, World!"])
+
+    # When finished
+    await chat_room.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Features
+
+- Async-first design with `AsyncClient`
+- Event subscription support via `on_event`
+- Action invocation with JSON-serializable arguments
+- Simple event handling with `receive` method
+- Clean disconnection handling via `disconnect`
+
+## Community & Support
+
+- Join our [Discord](https://rivet.gg/discord)
+- Follow us on [X](https://x.com/rivet_gg)
+- Follow us on [Bluesky](https://bsky.app/profile/rivet.gg)
+- File bug reports in [GitHub Issues](https://github.com/rivet-gg/actor-core/issues)
+- Post questions & ideas in [GitHub Discussions](https://github.com/rivet-gg/actor-core/discussions)
+
+## License
+
+Apache 2.0

clients/python/pyproject.toml

@@ -1,15 +1,44 @@
-[build-system]
-requires = ["maturin>=1.8,<2.0"]
-build-backend = "maturin"
-
 [project]
 name = "python_actor_core_client"
+version = "0.7.7"
+authors = [
+  { name="Rivet Gaming, LLC", email="[email protected]" },
+]
+description = "Python client for ActorCore - the Stateful Serverless Framework for building AI agents, realtime apps, and game servers"
+readme = "README.md"
+license = "Apache-2.0"
 requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dynamic = ["version"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/rivet-gg/actor-core"
+Issues = "https://github.com/rivet-gg/actor-core/issues"
+
+[project.optional-dependencies]
+tests = [
+    "asyncio==3.4.3",
+    "iniconfig==2.1.0",
+    "packaging==24.2",
+    "pluggy==1.5.0",
+    "pytest==8.3.5",
+    "pytest-aio==1.9.0",
+]
+
+
+[build-system]
+requires = ["maturin>=1.8,<2.0"]
+build-backend = "maturin"
+
 [tool.maturin]
 features = ["pyo3/extension-module"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+log_cli = true
+log_level = "DEBUG"

clients/python/requirements.txt

@@ -1,3 +1,10 @@
 -e .
+asyncio==3.4.3
+iniconfig==2.1.0
 maturin==1.8.3
+packaging==24.2
+pluggy==1.5.0
+pytest==8.3.5
+pytest-aio==1.9.0
+
 # source .venv/bin/activate

clients/python/src/simple/async/client.rs

@@ -5,7 +5,7 @@ use pyo3::prelude::*;
 
 use crate::util::{try_opts_from_kwds, PyKwdArgs};
 
-use super::handle::{ActorHandle, InnerActorData};
+use super::handle::ActorHandle;
 
 #[pyclass(name = "AsyncSimpleClient")]
 pub struct Client {
@@ -48,10 +48,7 @@ impl Client {
             let handle = client.get(&name, opts).await;
 
             match handle {
-                Ok(handle) => Ok(ActorHandle {
-                    handle,
-                    data: InnerActorData::new(),
-                }),
+                Ok(handle) => Ok(ActorHandle::new(handle)),
                 Err(e) => Err(py_runtime_err!(
                     "Failed to get actor: {}",
                     e
@@ -70,10 +67,7 @@ impl Client {
             let handle = client.get_with_id(&id, opts).await;
 
             match handle {
-                Ok(handle) => Ok(ActorHandle {
-                    handle,
-                    data: InnerActorData::new(),
-                }),
+                Ok(handle) => Ok(ActorHandle::new(handle)),
                 Err(e) => Err(py_runtime_err!(
                     "Failed to get actor: {}",
                     e
@@ -92,10 +86,7 @@ impl Client {
             let handle = client.create(&name, opts).await;
 
             match handle {
-                Ok(handle) => Ok(ActorHandle {
-                    handle,
-                    data: InnerActorData::new(),
-                }),
+                Ok(handle) => Ok(ActorHandle::new(handle)),
                 Err(e) => Err(py_runtime_err!(
                     "Failed to get actor: {}",
                     e

clients/python/src/simple/async/handle.rs

@@ -1,61 +1,40 @@
-use std::sync::Arc;
 use actor_core_client::{self as actor_core_rs};
 use futures_util::FutureExt;
 use pyo3::{prelude::*, types::{PyList, PyString, PyTuple}};
-use tokio::sync::{mpsc, Mutex};
+use tokio::sync::mpsc;
 
 use crate::util;
 
+const EVENT_BUFFER_SIZE: usize = 100;
+
 struct ActorEvent {
     name: String,
     args: Vec<serde_json::Value>,
 }
 
-pub struct InnerActorData {
-    event_tx: Mutex<Option<mpsc::Sender<ActorEvent>>>,
-}
-
-impl InnerActorData {
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            event_tx: Mutex::new(None),
-        })
-    }
+#[pyclass]
+pub struct ActorHandle {
+    handle: actor_core_rs::handle::ActorHandle,
+    event_rx: Option<mpsc::Receiver<ActorEvent>>,
+    event_tx: mpsc::Sender<ActorEvent>,
 }
 
-impl InnerActorData {
-    pub async fn on_event(
-        &self,
-        event_name: String,
-        args: &Vec<serde_json::Value>
-    ) {
-        let tx = &self.event_tx.lock().await;
-        let Some(tx) = tx.as_ref() else {
-            return;
-        };
-
-        tx.send(ActorEvent {
-            name: event_name,
-            args: args.clone(),
-        }).await.map_err(|e| {
-            py_runtime_err!(
-                "Failed to send via inner tx: {}",
-                e
-            )
-        }).ok();
+impl ActorHandle {
+    pub fn new(handle: actor_core_rs::handle::ActorHandle) -> Self {
+        let (event_tx, event_rx) = mpsc::channel(EVENT_BUFFER_SIZE);
+
+        Self {
+            handle,
+            event_tx,
+            event_rx: Some(event_rx),
+        }
     }
 }
 
-#[pyclass]
-pub struct ActorHandle {
-    pub handle: actor_core_rs::handle::ActorHandle,
-    pub data: Arc<InnerActorData>,
-}
-
 #[pymethods]
 impl ActorHandle {
     #[new]
-    pub fn new() -> PyResult<Self> {
+    pub fn py_new() -> PyResult<Self> {
         Err(py_runtime_err!(
             "Actor handle cannot be instantiated directly",
         ))
@@ -106,17 +85,27 @@ impl ActorHandle {
         event_name: &str
     ) -> PyResult<Bound<'a, PyAny>> {
         let event_name = event_name.to_string();
-        let data = self.data.clone();
         let handle = self.handle.clone();
+        let tx = self.event_tx.clone();
 
         pyo3_async_runtimes::tokio::future_into_py(py, async move {
             handle.on_event(&event_name.clone(), move |args| {
                 let event_name = event_name.clone();
                 let args = args.clone();
-                let data = data.clone();
+                let tx = tx.clone();
 
                 tokio::spawn(async move {
-                    data.on_event(event_name, &args).await;
+                    let event = ActorEvent {
+                        name: event_name,
+                        args: args.clone(),
+                    };
+                    // Send this upstream(?)
+                    tx.send(event).await.map_err(|e| {
+                        py_runtime_err!(
+                            "Failed to send via inner tx: {}",
+                            e
+                        )
+                    }).ok();
                 });
             }).await;
 
@@ -126,17 +115,16 @@ impl ActorHandle {
 
     #[pyo3(signature=(count, timeout=None))]
     pub fn receive<'a>(
-        &self,
+        &mut self,
         py: Python<'a>,
         count: u32,
         timeout: Option<f64>
     ) -> PyResult<Bound<'a, PyAny>>  {
-        let (tx, mut rx) = mpsc::channel(count as usize);
+        let mut rx = self.event_rx.take().ok_or_else(|| {
+            py_runtime_err!("Two .receive() calls cannot co-exist")
+        })?;
 
-        let data = self.data.clone();
         pyo3_async_runtimes::tokio::future_into_py(py, async move {
-            data.event_tx.lock().await.replace(tx);
-
             let result: Vec<ActorEvent> = {
                 let mut events: Vec<ActorEvent> = Vec::new();
 

clients/python/src/simple/sync/client.rs

@@ -1,7 +1,7 @@
 use actor_core_client::{self as actor_core_rs, CreateOptions, GetOptions, GetWithIdOptions};
 use pyo3::prelude::*;
 
-use super::handle::{ActorHandle, InnerActorData};
+use super::handle::ActorHandle;
 use crate::util::{try_opts_from_kwds, PyKwdArgs, SYNC_RUNTIME};
 
 #[pyclass(name = "SimpleClient")]
@@ -43,10 +43,7 @@ impl Client {
         let handle = SYNC_RUNTIME.block_on(handle);
 
         match handle {
-            Ok(handle) => Ok(ActorHandle {
-                handle,
-                data: InnerActorData::new(),
-            }),
+            Ok(handle) => Ok(ActorHandle::new(handle)),
             Err(e) => Err(py_runtime_err!(
                 "Failed to get actor: {}",
                 e
@@ -61,10 +58,7 @@ impl Client {
         let handle = SYNC_RUNTIME.block_on(handle);
 
         match handle {
-            Ok(handle) => Ok(ActorHandle {
-                handle,
-                data: InnerActorData::new(),
-            }),
+            Ok(handle) => Ok(ActorHandle::new(handle)),
             Err(e) => Err(py_runtime_err!(
                 "Failed to get actor: {}",
                 e
@@ -79,10 +73,7 @@ impl Client {
         let handle = SYNC_RUNTIME.block_on(handle);
 
         match handle {
-            Ok(handle) => Ok(ActorHandle {
-                handle,
-                data: InnerActorData::new(),
-            }),
+            Ok(handle) => Ok(ActorHandle::new(handle)),
             Err(e) => Err(py_runtime_err!(
                 "Failed to get actor: {}",
                 e