vrchatapi-async 1.20.8.dev1__tar.gz → 1.20.8.post1__tar.gz

{vrchatapi_async-1.20.8.dev1 → vrchatapi_async-1.20.8.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vrchatapi-async
-Version: 1.20.8.dev1
+Version: 1.20.8.post1
 Summary: VRChat API Library for Python (async version)
 Home-page: https://github.com/hi94740/vrchatapi-python-async
 Author: hi94740
@@ -134,4 +134,50 @@ Compared to [the synchronous SDK](https://github.com/vrchatapi/vrchatapi-python)
 ## Contributing
 
 Contributions are welcome, but do not add features that should be handled by the OpenAPI specification.
+
+## Websocket (Pipeline) API
+
+The SDK also ships a hand-written async client for VRChat's real-time
+WebSocket (Pipeline) API (`wss://pipeline.vrchat.cloud`), which pushes invites,
+friend requests, friend online/offline events, user and group updates to the
+authenticated client. The connection is receive-only; every message's
+double-encoded `content` field is automatically unpacked into a plain dict.
+
+```python
+import asyncio
+
+import vrchatapi
+from vrchatapi.api import authentication_api
+from vrchatapi.websocket import VRChatWebSocket
+
+
+async def main():
+    configuration = vrchatapi.Configuration(username="username", password="password")
+    async with vrchatapi.ApiClient(configuration) as api_client:
+        api_client.user_agent = "ExampleProgram/0.0.1 my@email.com"
+        await authentication_api.AuthenticationApi(api_client).get_current_user()
+
+        # Reads the auth cookie + User-Agent from the logged-in client.
+        ws = VRChatWebSocket.from_client(api_client)
+
+        @ws.on("friend-online")
+        async def on_friend_online(event):
+            print("online:", event.content["user"]["displayName"])
+
+        # Or consume the same stream as an async iterator:
+        #   async for event in ws:
+        #       print(event.type, event.content)
+
+        await ws.run()  # blocks; reconnects automatically by default
+```
+
+`VRChatWebSocket` supports callback registration (`ws.on("friend-online", ...)`
+/ `@ws.on(...)`, a catch-all `ws.on_event(...)`), an async iterator over the
+same event stream, error/connect/disconnect/reconnect hooks, automatic
+reconnection with exponential backoff (`auto_reconnect=False` disables it), and
+a configurable application-level heartbeat (default 30s;
+`heartbeat_interval=None` disables it). See
+[examples/examples-source/websocket.py](examples/examples-source/websocket.py)
+and the [Websocket API reference](https://vrchat.community/websocket) for
+details.
     

{vrchatapi_async-1.20.8.dev1 → vrchatapi_async-1.20.8.post1}/README.md

@@ -103,3 +103,49 @@ Compared to [the synchronous SDK](https://github.com/vrchatapi/vrchatapi-python)
 ## Contributing
 
 Contributions are welcome, but do not add features that should be handled by the OpenAPI specification.
+
+## Websocket (Pipeline) API
+
+The SDK also ships a hand-written async client for VRChat's real-time
+WebSocket (Pipeline) API (`wss://pipeline.vrchat.cloud`), which pushes invites,
+friend requests, friend online/offline events, user and group updates to the
+authenticated client. The connection is receive-only; every message's
+double-encoded `content` field is automatically unpacked into a plain dict.
+
+```python
+import asyncio
+
+import vrchatapi
+from vrchatapi.api import authentication_api
+from vrchatapi.websocket import VRChatWebSocket
+
+
+async def main():
+    configuration = vrchatapi.Configuration(username="username", password="password")
+    async with vrchatapi.ApiClient(configuration) as api_client:
+        api_client.user_agent = "ExampleProgram/0.0.1 my@email.com"
+        await authentication_api.AuthenticationApi(api_client).get_current_user()
+
+        # Reads the auth cookie + User-Agent from the logged-in client.
+        ws = VRChatWebSocket.from_client(api_client)
+
+        @ws.on("friend-online")
+        async def on_friend_online(event):
+            print("online:", event.content["user"]["displayName"])
+
+        # Or consume the same stream as an async iterator:
+        #   async for event in ws:
+        #       print(event.type, event.content)
+
+        await ws.run()  # blocks; reconnects automatically by default
+```
+
+`VRChatWebSocket` supports callback registration (`ws.on("friend-online", ...)`
+/ `@ws.on(...)`, a catch-all `ws.on_event(...)`), an async iterator over the
+same event stream, error/connect/disconnect/reconnect hooks, automatic
+reconnection with exponential backoff (`auto_reconnect=False` disables it), and
+a configurable application-level heartbeat (default 30s;
+`heartbeat_interval=None` disables it). See
+[examples/examples-source/websocket.py](examples/examples-source/websocket.py)
+and the [Websocket API reference](https://vrchat.community/websocket) for
+details.

{vrchatapi_async-1.20.8.dev1 → vrchatapi_async-1.20.8.post1}/setup.py

@@ -107,6 +107,52 @@ Compared to [the synchronous SDK](https://github.com/vrchatapi/vrchatapi-python)
 
 Contributions are welcome, but do not add features that should be handled by the OpenAPI specification.
 
+## Websocket (Pipeline) API
+
+The SDK also ships a hand-written async client for VRChat's real-time
+WebSocket (Pipeline) API (`wss://pipeline.vrchat.cloud`), which pushes invites,
+friend requests, friend online/offline events, user and group updates to the
+authenticated client. The connection is receive-only; every message's
+double-encoded `content` field is automatically unpacked into a plain dict.
+
+```python
+import asyncio
+
+import vrchatapi
+from vrchatapi.api import authentication_api
+from vrchatapi.websocket import VRChatWebSocket
+
+
+async def main():
+    configuration = vrchatapi.Configuration(username="username", password="password")
+    async with vrchatapi.ApiClient(configuration) as api_client:
+        api_client.user_agent = "ExampleProgram/0.0.1 my@email.com"
+        await authentication_api.AuthenticationApi(api_client).get_current_user()
+
+        # Reads the auth cookie + User-Agent from the logged-in client.
+        ws = VRChatWebSocket.from_client(api_client)
+
+        @ws.on("friend-online")
+        async def on_friend_online(event):
+            print("online:", event.content["user"]["displayName"])
+
+        # Or consume the same stream as an async iterator:
+        #   async for event in ws:
+        #       print(event.type, event.content)
+
+        await ws.run()  # blocks; reconnects automatically by default
+```
+
+`VRChatWebSocket` supports callback registration (`ws.on("friend-online", ...)`
+/ `@ws.on(...)`, a catch-all `ws.on_event(...)`), an async iterator over the
+same event stream, error/connect/disconnect/reconnect hooks, automatic
+reconnection with exponential backoff (`auto_reconnect=False` disables it), and
+a configurable application-level heartbeat (default 30s;
+`heartbeat_interval=None` disables it). See
+[examples/examples-source/websocket.py](examples/examples-source/websocket.py)
+and the [Websocket API reference](https://vrchat.community/websocket) for
+details.
+
     The version of the OpenAPI document: 1.20.8
     Contact: vrchatapi.lpv0t@aries.fyi
     Generated by OpenAPI Generator (https://openapi-generator.tech)
@@ -124,7 +170,7 @@ from setuptools import setup, find_packages  # noqa: H301
 # prerequisite: setuptools
 # http://pypi.python.org/pypi/setuptools
 NAME = "vrchatapi-async"
-VERSION = "1.20.8dev1"
+VERSION = "1.20.8.post1"
 PYTHON_REQUIRES = ">= 3.10"
 REQUIRES = [
     "python-dateutil >= 2.8.2",
@@ -254,6 +300,52 @@ Compared to [the synchronous SDK](https://github.com/vrchatapi/vrchatapi-python)
 ## Contributing
 
 Contributions are welcome, but do not add features that should be handled by the OpenAPI specification.
+
+## Websocket (Pipeline) API
+
+The SDK also ships a hand-written async client for VRChat's real-time
+WebSocket (Pipeline) API (`wss://pipeline.vrchat.cloud`), which pushes invites,
+friend requests, friend online/offline events, user and group updates to the
+authenticated client. The connection is receive-only; every message's
+double-encoded `content` field is automatically unpacked into a plain dict.
+
+```python
+import asyncio
+
+import vrchatapi
+from vrchatapi.api import authentication_api
+from vrchatapi.websocket import VRChatWebSocket
+
+
+async def main():
+    configuration = vrchatapi.Configuration(username="username", password="password")
+    async with vrchatapi.ApiClient(configuration) as api_client:
+        api_client.user_agent = "ExampleProgram/0.0.1 my@email.com"
+        await authentication_api.AuthenticationApi(api_client).get_current_user()
+
+        # Reads the auth cookie + User-Agent from the logged-in client.
+        ws = VRChatWebSocket.from_client(api_client)
+
+        @ws.on("friend-online")
+        async def on_friend_online(event):
+            print("online:", event.content["user"]["displayName"])
+
+        # Or consume the same stream as an async iterator:
+        #   async for event in ws:
+        #       print(event.type, event.content)
+
+        await ws.run()  # blocks; reconnects automatically by default
+```
+
+`VRChatWebSocket` supports callback registration (`ws.on("friend-online", ...)`
+/ `@ws.on(...)`, a catch-all `ws.on_event(...)`), an async iterator over the
+same event stream, error/connect/disconnect/reconnect hooks, automatic
+reconnection with exponential backoff (`auto_reconnect=False` disables it), and
+a configurable application-level heartbeat (default 30s;
+`heartbeat_interval=None` disables it). See
+[examples/examples-source/websocket.py](examples/examples-source/websocket.py)
+and the [Websocket API reference](https://vrchat.community/websocket) for
+details.
     """,  # noqa: E501
     package_data={"vrchatapi": ["py.typed"]},
 )

{vrchatapi_async-1.20.8.dev1 → vrchatapi_async-1.20.8.post1}/tests/test_async_sdk.py

@@ -15,6 +15,7 @@ the async conversion:
 
 import base64
 import json
+from unittest.mock import AsyncMock, Mock
 
 import aiohttp
 from multidict import CIMultiDict
@@ -277,6 +278,29 @@ async def test_request_timeout_maps_to_client_timeout():
     await rest_client.close()
 
 
+@pytest.mark.asyncio
+async def test_ssl_context_is_built_lazily_off_the_event_loop(monkeypatch):
+    from vrchatapi import rest as rest_module
+
+    config = Configuration(host="http://localhost")
+    build_context = Mock()
+    monkeypatch.setattr(rest_module.ssl, "create_default_context", build_context)
+    build_context.reset_mock()
+    rest_client = rest_module.RESTClientObject(config)
+
+    build_context.assert_not_called()
+
+    ssl_context = Mock()
+    to_thread = AsyncMock(return_value=ssl_context)
+    monkeypatch.setattr(rest_module.asyncio, "to_thread", to_thread)
+    monkeypatch.setattr(rest_client, "_create_pool_manager", Mock(return_value=Mock()))
+
+    await rest_client._ensure_session()
+
+    to_thread.assert_awaited_once_with(rest_client._build_ssl_context)
+    assert rest_client.ssl_context is ssl_context
+
+
 @pytest.mark.asyncio
 async def test_without_preload_content_returns_raw_response(server):
     config = Configuration(host=server.base_url)