vrchatapi-async 1.21.0.post3__tar.gz → 1.21.0.post4__tar.gz

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vrchatapi-async
-Version: 1.21.0.post3
+Version: 1.21.0.post4
 Summary: VRChat API Library for Python (async version)
 Home-page: https://github.com/hi94740/vrchatapi-python-async
 Author: hi94740

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/setup.py

@@ -232,7 +232,7 @@ from setuptools import setup, find_packages  # noqa: H301
 # prerequisite: setuptools
 # http://pypi.python.org/pypi/setuptools
 NAME = "vrchatapi-async"
-VERSION = "1.21.0post3"
+VERSION = "1.21.0post4"
 PYTHON_REQUIRES = ">= 3.10"
 REQUIRES = [
     "python-dateutil >= 2.8.2",

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/tests/test_highlevel.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from datetime import datetime, timedelta, timezone
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 from test_async_sdk import MockVRCServer
@@ -20,7 +20,7 @@ from vrchatapi.highlevel import (
     WorldCache,
 )
 from vrchatapi.highlevel.presence import is_user_in_game
-from vrchatapi.websocket import VRChatEvent
+from vrchatapi.websocket import VRChatEvent, VRChatWebSocketError
 
 CURRENT = {
     "id": "usr_self",
@@ -127,6 +127,32 @@ async def test_cookie_copy_user_agent_and_close() -> None:
     await api.close()
 
 
+async def test_proxy_is_preserved_by_api_copy() -> None:
+    async with VRChatAPI({"proxy": "http://proxy.example:8080"}) as api:
+        assert api.api_client.configuration.proxy == "http://proxy.example:8080"
+        async with api.copy() as copied:
+            assert copied.api_client.configuration.proxy == "http://proxy.example:8080"
+
+
+async def test_ws_connect_uses_proxy_and_registers_errors_before_connect() -> None:
+    api = VRChatAPI({"proxy": "http://proxy.example:8080"})
+    api.cookie = {"auth": "token"}
+    handler = Mock()
+    operations = []
+    ws = Mock(
+        on_error=Mock(side_effect=lambda callback: operations.append("on_error")),
+        connect=AsyncMock(side_effect=lambda: operations.append("connect")),
+        close=AsyncMock(),
+    )
+    with patch("vrchatapi.highlevel.api.VRChatWebSocket.from_client") as factory:
+        factory.return_value = ws
+        await api.ws_connect(on_error=handler)
+    assert factory.call_args.kwargs["proxy"] == "http://proxy.example:8080"
+    ws.on_error.assert_called_once_with(handler)
+    assert operations == ["on_error", "connect"]
+    await api.close()
+
+
 async def test_cookie_uses_configured_host() -> None:
     server = MockVRCServer()
     await server.start()
@@ -424,7 +450,7 @@ async def test_recovery_replaces_and_closes_connection(account: VRChatAccount) -
     replacement.get_user = AsyncMock(return_value=FRIEND)
     replacement.get_friends = AsyncMock(return_value=[])
     replacement.ws_connect = AsyncMock(
-        side_effect=lambda: operations.append("connect") or Pipeline()
+        side_effect=lambda **kwargs: operations.append("connect") or Pipeline()
     )
     replacement.close = AsyncMock()
     old.copy.return_value = replacement
@@ -458,7 +484,7 @@ async def test_timeout_recovery_keeps_account_available(
     replacement.get_user = AsyncMock(return_value=FRIEND)
     replacement.get_friends = AsyncMock(return_value=[])
     replacement.ws_connect = AsyncMock(
-        side_effect=lambda: operations.append("connect") or Pipeline()
+        side_effect=lambda **kwargs: operations.append("connect") or Pipeline()
     )
     replacement.close = AsyncMock()
     old.copy.return_value = replacement
@@ -511,7 +537,7 @@ async def test_timeout_keeps_processing_old_pipeline_until_replacement(
     )
     result = getattr(replacement, stage).return_value
 
-    async def wait_for_replacement() -> object:
+    async def wait_for_replacement(**kwargs: object) -> object:
         started.set()
         await proceed.wait()
         return result
@@ -676,6 +702,59 @@ async def test_pipeline_events_processed_in_order(account: VRChatAccount) -> Non
     assert account.users["usr_friend"].data["displayName"] == "Friend"
 
 
+async def test_on_event_receives_snapshot_and_survives_recovery(
+    account: VRChatAccount,
+) -> None:
+    await account.start()
+    seen = []
+    notified = asyncio.Event()
+
+    def on_event(event, old_user) -> None:
+        seen.append((event, old_user))
+        notified.set()
+
+    account.on_event = on_event
+    old_data = account.users["usr_friend"].data.copy()
+    account.ws.events.put_nowait(
+        VRChatEvent(
+            "user-update",
+            {"userId": "usr_friend", "user": {"statusDescription": "first"}},
+        )
+    )
+    await asyncio.wait_for(notified.wait(), 1)
+    assert seen[0][0].content["userId"] == "usr_friend"
+    assert seen[0][1] == old_data
+
+    new_ws = Pipeline()
+    old_api = account.api
+    old_api.copy.return_value = Mock(
+        get_current_user=AsyncMock(return_value=CURRENT.copy()),
+        get_friends=AsyncMock(return_value=[]),
+        get_user=AsyncMock(return_value=FRIEND.copy()),
+        ws_connect=AsyncMock(return_value=new_ws),
+        close=AsyncMock(side_effect=new_ws.close),
+    )
+    await account._recover(old_api)
+    notified.clear()
+    new_ws.events.put_nowait(
+        VRChatEvent(
+            "user-update",
+            {"userId": "usr_friend", "user": {"statusDescription": "second"}},
+        )
+    )
+    await asyncio.wait_for(notified.wait(), 1)
+    assert seen[1][0].content["user"]["statusDescription"] == "second"
+    assert seen[1][1]["displayName"] == "Friend"
+
+
+async def test_on_event_receives_pipeline_error(account: VRChatAccount) -> None:
+    seen = []
+    account.on_event = lambda event, old_user: seen.append((event, old_user))
+    error = VRChatWebSocketError("denied", raw='{"err":"denied"}')
+    account._handle_ws_error(error)
+    assert seen == [(error, None)]
+
+
 async def test_disconnect_auth_failure_notifies_and_stops(
     account: VRChatAccount,
 ) -> None:

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/tests/test_websocket.py

@@ -9,6 +9,7 @@ import asyncio
 import json
 import time
 from types import SimpleNamespace
+from unittest.mock import AsyncMock
 
 import aiohttp
 import pytest
@@ -158,6 +159,23 @@ async def test_auth_token_is_url_encoded(pipeline_server):
     assert query["authToken"] == token
 
 
+@pytest.mark.asyncio
+async def test_connect_uses_configured_proxy():
+    socket = SimpleNamespace(closed=False, close=AsyncMock())
+    session = SimpleNamespace(ws_connect=AsyncMock(return_value=socket))
+    ws = VRChatWebSocket(
+        auth_token="authcookie_test",
+        session=session,
+        proxy="http://proxy.example:8080",
+        heartbeat_interval=None,
+    )
+
+    await ws._connect_once()
+
+    assert session.ws_connect.await_args.kwargs["proxy"] == "http://proxy.example:8080"
+    await ws.close()
+
+
 # ---------------------------------------------------------------------------
 # Decoding
 # ---------------------------------------------------------------------------

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/vrchatapi/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.21.0post3"
+__version__ = "1.21.0post4"
 
 # Define package exports
 __all__ = [

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/vrchatapi/highlevel/account.py

@@ -9,7 +9,7 @@ from typing import Any, cast
 
 import vrchatapi
 from vrchatapi.exceptions import UnauthorizedException
-from vrchatapi.websocket import VRChatEvent, VRChatWebSocket
+from vrchatapi.websocket import VRChatEvent, VRChatWebSocket, VRChatWebSocketError
 
 from .api import VRChatAPI
 from .presence import (
@@ -60,6 +60,10 @@ class VRChatAccount:
         worlds: WorldCache | None = None,
         on_user: Callable[[VRChatUser, bool], None] | None = None,
         on_remove: Callable[[str], None] | None = None,
+        on_event: Callable[
+            [VRChatEvent | VRChatWebSocketError, HighLevelUserData | None], None
+        ]
+        | None = None,
         on_available: Callable[[bool], None] | None = None,
         on_auth_error: Callable[[Exception], None] | None = None,
         on_authenticated: Callable[[VRChatAPI], Awaitable[None]] | None = None,
@@ -78,6 +82,7 @@ class VRChatAccount:
         self._owns_worlds = worlds is None
         self.on_user = on_user
         self.on_remove = on_remove
+        self.on_event = on_event
         self.on_available = on_available
         self.on_auth_error = on_auth_error
         self.on_authenticated = on_authenticated
@@ -133,7 +138,7 @@ class VRChatAccount:
     async def start(self, initial: CurrentUser | None = None) -> None:
         try:
             await self.authenticate(initial)
-            self.ws = await self.api.ws_connect()
+            self.ws = await self._connect_ws(self.api)
             await self.fetch_users()
             self._set_available(True)
             self._receiver = asyncio.create_task(self._receive(self.ws))
@@ -142,6 +147,13 @@ class VRChatAccount:
             await self.close()
             raise
 
+    async def _connect_ws(self, api: VRChatAPI) -> VRChatWebSocket:
+        return await api.ws_connect(on_error=self._handle_ws_error)
+
+    def _handle_ws_error(self, error: Exception) -> None:
+        if isinstance(error, VRChatWebSocketError) and error.raw is not None:
+            self._notify(self.on_event, error, None)
+
     async def _get_friends(self, offline: bool) -> list[User]:
         ids = self.current_user_data["offlineFriends" if offline else "onlineFriends"]
         pages = await _gather(
@@ -194,6 +206,7 @@ class VRChatAccount:
     async def handle_event(self, event: VRChatEvent) -> None:
         content = event.content
         if not isinstance(content, dict):
+            self._notify(self.on_event, event, None)
             return
         if isinstance(world := content.get("world"), dict) and (
             world_id := process_vrchat_string(world.get("id"))
@@ -204,7 +217,19 @@ class VRChatAccount:
         if world_id and world_id not in VRCHAT_SPECIAL_LOCATION_STRINGS:
             content["travelingToWorldId"] = world_id
             self.create_task(self.worlds.get(world_id).get_data())
-        if (user_id := content.get("userId")) is None:
+        user_id = content.get("userId")
+        old_user = self.users.get(user_id) if user_id is not None else None
+        self._notify(
+            self.on_event,
+            VRChatEvent(
+                type=event.type,
+                content=content,
+                raw=event.raw,
+                raw_content=event.raw_content,
+            ),
+            old_user.data.copy() if old_user is not None else None,
+        )
+        if user_id is None:
             return
         if event.type == "friend-delete":
             self.remove_user(user_id)
@@ -246,7 +271,7 @@ class VRChatAccount:
             self.api = replacement
             try:
                 await self.authenticate()
-                new_ws = await replacement.ws_connect()
+                new_ws = await self._connect_ws(replacement)
                 await self._stop_receiver()
                 # Discard old pipeline work before applying the replacement snapshot.
                 pending = list(self._event_tasks.values())

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/vrchatapi/highlevel/api.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from enum import Enum
 from functools import cached_property
 from http.cookiejar import Cookie
@@ -11,7 +11,10 @@ from typing import cast
 from urllib.parse import urlsplit
 
 import vrchatapi
-from vrchatapi.websocket import DEFAULT_USER_AGENT, VRChatWebSocket
+from vrchatapi.websocket import (
+    DEFAULT_USER_AGENT,
+    VRChatWebSocket,
+)
 
 from .types import CurrentUser, User, VRChatAuthCookie, World
 
@@ -83,6 +86,7 @@ class VRChatAPI:
             vrchatapi.Configuration(
                 username=self.config.get("username"),
                 password=self.config.get("password"),
+                proxy=self.config.get("proxy"),
             )
         )
         self.api_client.user_agent = user_agent
@@ -153,9 +157,19 @@ class VRChatAPI:
     async def get_world(self, world_id: str) -> World:
         return cast(World, await self.worlds_api.get_world(world_id))
 
-    async def ws_connect(self) -> VRChatWebSocket:
+    async def ws_connect(
+        self,
+        *,
+        on_error: Callable[[Exception], None] | None = None,
+    ) -> VRChatWebSocket:
         # The account owns authentication recovery and reconnect snapshots.
-        ws = VRChatWebSocket.from_client(self.api_client, auto_reconnect=False)
+        ws = VRChatWebSocket.from_client(
+            self.api_client,
+            auto_reconnect=False,
+            proxy=self.api_client.configuration.proxy,
+        )
+        if on_error is not None:
+            ws.on_error(on_error)
         try:
             await ws.connect()
         except BaseException:

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/vrchatapi/websocket.py

@@ -235,6 +235,7 @@ class VRChatWebSocket:
         reconnect_max_delay: float = 60.0,
         heartbeat_interval: Optional[float] = DEFAULT_HEARTBEAT_INTERVAL,
         session: Optional[aiohttp.ClientSession] = None,
+        proxy: Optional[str] = None,
     ) -> None:
         if not auth_token:
             raise ValueError("auth_token is required")
@@ -244,6 +245,7 @@ class VRChatWebSocket:
         self._auto_reconnect = auto_reconnect
         self._reconnect_max_delay = max(0.0, reconnect_max_delay)
         self._heartbeat_interval = heartbeat_interval
+        self._proxy = proxy
 
         self._session = session
         self._owned_session = session is None
@@ -465,7 +467,7 @@ class VRChatWebSocket:
         url = f"{self._endpoint.rstrip('/')}/?authToken={quote(self._auth_token, safe='')}"
         headers = {"User-Agent": self._user_agent}
         try:
-            ws = await session.ws_connect(url, headers=headers)
+            ws = await session.ws_connect(url, headers=headers, proxy=self._proxy)
         except Exception:
             # Do not leak a freshly-created session on a failed connect;
             # close it so callers do not accumulate resources.

{vrchatapi_async-1.21.0.post3 → vrchatapi_async-1.21.0.post4}/vrchatapi_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vrchatapi-async
-Version: 1.21.0.post3
+Version: 1.21.0.post4
 Summary: VRChat API Library for Python (async version)
 Home-page: https://github.com/hi94740/vrchatapi-python-async
 Author: hi94740