sora-sdk 2026.2.0.dev1__tar.gz → 2026.2.0.dev3__tar.gz

{sora_sdk-2026.2.0.dev1/src/sora_sdk.egg-info → sora_sdk-2026.2.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sora_sdk
-Version: 2026.2.0.dev1
+Version: 2026.2.0.dev3
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>

sora_sdk-2026.2.0.dev3/VERSION

@@ -0,0 +1 @@
+2026.2.0.dev3

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/pyproject.toml

@@ -25,7 +25,7 @@ Source = "https://github.com/shiguredo/sora-python-sdk"
 
 [dependency-groups]
 dev = [
-  "nanobind==3.0.1",
+  "nanobind==3.1.0",
   { include-group = "test" },
 ]
 test = [

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/setup.py

@@ -46,7 +46,12 @@ def run_setup(build_platform, target_platform):
         def get_tag(self):
             _, _, plat2 = super().get_tag()
             impl = "cp" + sysconfig.get_config_var("py_version_nodot")
-            return impl, impl, plat if plat is not None else plat2
+            abi = impl
+            # free-threaded ビルド (3.13t 以降) は ABI タグに t を付ける (例: cp313-cp313t)。
+            # interpreter タグは cp313 のままで、t は ABI タグにのみ付く
+            if sysconfig.get_config_var("Py_GIL_DISABLED"):
+                abi += "t"
+            return impl, abi, plat if plat is not None else plat2
 
     setup(
         version=version,

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/src/sora_sdk/sora_sdk_ext.pyi

@@ -25,6 +25,8 @@ class SoraSignalingErrorCode(enum.IntEnum):
 
     ICE_FAILED = 8
 
+    DATACHANNEL_CLOSED = 9
+
 class SoraSignalingType(enum.IntEnum):
     WEBSOCKET = 0
 
@@ -183,6 +185,8 @@ class SoraConnection:
 
     def send_data_channel(self, label: str, data: bytes) -> bool: ...
 
+    def send_rpc(self, id: int | None, method: str, params: object | None = None) -> bool: ...
+
     def get_stats(self) -> str: ...
 
     @property

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3/src/sora_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sora_sdk
-Version: 2026.2.0.dev1
+Version: 2026.2.0.dev3
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/src/sora_sdk.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ tests/test_openh264_simulcast.py
 tests/test_opus.py
 tests/test_raspberry_pi.py
 tests/test_re_offer_re_answer_sdp.py
+tests/test_rpc.py
 tests/test_rtc_log_refcount.py
 tests/test_send_data_channel_get_stats_after_disconnect.py
 tests/test_sendonly_recvonly.py

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_amd_amf.py

@@ -83,7 +83,25 @@ def test_amd_amf_key_frame_request(settings, video_codec_type):
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(3)
+    # RequestKeyFrame はキーフレームを受け取る相手がいる配信者にだけ PLI を送るため、
+    # 同じチャンネルに視聴者 (recvonly) を 1 本用意して受信を開始するまで待つ。
+    # ハードウェアエンコーダの映像はハードウェアデコーダを指定しないと受信できない
+    recvonly = SoraClient(
+        settings,
+        SoraRole.RECVONLY,
+        audio=False,
+        video=True,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    decoder=SoraVideoCodecImplementation.AMD_AMF,
+                ),
+            ]
+        ),
+    )
+    recvonly.connect()
+    recvonly.wait_video_received()
 
     assert sendonly.connection_id is not None
 
@@ -100,6 +118,7 @@ def test_amd_amf_key_frame_request(settings, video_codec_type):
     sendonly_stats = sendonly.get_stats()
 
     sendonly.disconnect()
+    recvonly.disconnect()
 
     # outbound-rtp が無かったら StopIteration 例外が上がる
     outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_field_trials.py

@@ -64,6 +64,29 @@ def connect_sendonly(settings, field_trials: str | None) -> SoraClient:
     return sendonly
 
 
+def connect_recvonly(settings, simulcast_request_rid: str) -> SoraClient:
+    """
+    同じチャンネルに視聴者 (recvonly) を接続する。
+
+    RequestKeyFrame はキーフレームを受け取る相手がいる配信者にだけ、その相手が
+    受信している rid へ PLI を送るため、視聴者が受信する rid を明示しておく。
+    視聴者の downstream が確定するまで固定で 5 秒待ってから返す (条件待ちはしていない)。
+    """
+    recvonly = SoraClient(
+        settings,
+        SoraRole.RECVONLY,
+        audio=False,
+        video=True,
+        simulcast_request_rid=simulcast_request_rid,
+    )
+    recvonly.connect()
+
+    # 視聴者の downstream が確定するまで待つ
+    recvonly.wait_video_received()
+
+    return recvonly
+
+
 def test_field_trials(settings):
     """
     WebRTC-Video-PerSsrcKeyframes を指定した Sora でキーフレーム要求が動作すること。
@@ -74,7 +97,7 @@ def test_field_trials(settings):
 
     期待:
     - 不正な文字列では RuntimeError になる
-    - キーフレーム要求 API の呼び出しで有効な全レイヤのキーフレーム数が増える
+    - キーフレーム要求 API の呼び出しで PLI が届いた rid のキーフレーム数が増える
     """
     # 文字列の末尾に "/" が無い場合は不正なフィールドトライアル文字列として扱われる
     with pytest.raises(RuntimeError):
@@ -84,37 +107,50 @@ def test_field_trials(settings):
         )
 
     sendonly = connect_sendonly(settings, "WebRTC-Video-PerSsrcKeyframes/Enabled/")
+    recvonly = connect_recvonly(settings, "r0")
 
     # connection_id は None になり得るため、API 呼び出しに使う前に絞り込む
     assert sendonly.connection_id is not None
 
-    before = get_key_frames_encoded(get_active_video_stats_by_rid(sendonly))
+    before_stats = get_active_video_stats_by_rid(sendonly)
+    before = get_key_frames_encoded(before_stats)
     print("キーフレーム要求前のキーフレーム数:", before)
 
     response = request_key_frame_api(settings.api_url, sendonly.channel_id, sendonly.connection_id)
 
     time.sleep(5)
 
-    after = get_key_frames_encoded(get_active_video_stats_by_rid(sendonly))
+    after_stats = get_active_video_stats_by_rid(sendonly)
+    after = get_key_frames_encoded(after_stats)
     print("キーフレーム要求後のキーフレーム数:", after)
 
     sendonly.disconnect()
+    recvonly.disconnect()
 
     # 接続を閉じてから確認する。ここで失敗しても接続が残らない
     assert response.status_code == 200, response.text
 
     # サイマルキャストの全レイヤが有効になっていること
-    assert len(after) == 3
-    # キーフレーム要求により有効な全レイヤのキーフレーム数が増えていること
-    for rid, count in before.items():
-        assert after.get(rid, 0) > count, f"rid={rid} のキーフレーム数が増えていない"
+    assert len(after_stats) == 3
+    # rid を指定しない要求は視聴者が受信している rid に PLI を送る。視聴者が受信している
+    # rid は視聴環境によって変わり得るため、PLI が届いた rid を対象にキーフレーム数を確認する
+    increased_rids = [
+        rid
+        for rid in sorted(before_stats)
+        if after_stats[rid]["pliCount"] > before_stats[rid]["pliCount"]
+    ]
+    assert increased_rids, "キーフレーム要求で PLI が届いていない"
+    for rid in increased_rids:
+        assert after[rid] > before[rid], (
+            f"rid={rid} のキーフレーム数が増えていない: before={before[rid]}, after={after[rid]}"
+        )
 
 
 @pytest.mark.parametrize(
     ("field_trials", "increased_rids"),
     [
         # フィールドトライアル有効時は PLI を受けた rid のレイヤだけがキーフレームを生成する
-        ("WebRTC-Video-PerSsrcKeyframes/Enabled/", {"r2"}),
+        ("WebRTC-Video-PerSsrcKeyframes/Enabled/", {"r0"}),
         # フィールドトライアル無効時はどの rid への PLI でも全レイヤがキーフレームを生成する
         (None, {"r0", "r1", "r2"}),
     ],
@@ -132,7 +168,7 @@ def test_per_ssrc_keyframes(settings, field_trials, increased_rids):
     - RequestKeyFrame API の rid 指定は Sora 2026.2.0-canary.15 以降で利用できる
 
     期待:
-    - フィールドトライアル有効: rid=r2 のキーフレーム要求で r2 のみキーフレーム数が増える
+    - フィールドトライアル有効: rid=r0 のキーフレーム要求で r0 のみキーフレーム数が増える
     - フィールドトライアル無効: r0 / r1 / r2 すべてのキーフレーム数が増える
 
     前提が崩れた場合:
@@ -141,6 +177,7 @@ def test_per_ssrc_keyframes(settings, field_trials, increased_rids):
       いない場合は skip する
     """
     sendonly = connect_sendonly(settings, field_trials)
+    recvonly = connect_recvonly(settings, "r0")
 
     # connection_id は None になり得るため、API 呼び出しに使う前に絞り込む
     assert sendonly.connection_id is not None
@@ -151,7 +188,7 @@ def test_per_ssrc_keyframes(settings, field_trials, increased_rids):
 
     # rid を指定すると、その rid の SSRC にのみ PLI が送られる
     response = request_key_frame_api(
-        settings.api_url, sendonly.channel_id, sendonly.connection_id, rid="r2"
+        settings.api_url, sendonly.channel_id, sendonly.connection_id, rid="r0"
     )
 
     # Sora はキーフレームを受け取るまで 1 秒間隔で PLI を再送するため、再送が終わるまで待つ
@@ -162,6 +199,7 @@ def test_per_ssrc_keyframes(settings, field_trials, increased_rids):
     print("キーフレーム要求後のキーフレーム数:", key_frames_after)
 
     sendonly.disconnect()
+    recvonly.disconnect()
 
     # 接続を閉じてから確認する。ここで失敗しても接続が残らない
     assert response.status_code == 200, response.text

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_intel_vpl.py

@@ -91,7 +91,25 @@ def test_intel_vpl_key_frame_request(settings, video_codec_type):
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(3)
+    # RequestKeyFrame はキーフレームを受け取る相手がいる配信者にだけ PLI を送るため、
+    # 同じチャンネルに視聴者 (recvonly) を 1 本用意して受信を開始するまで待つ。
+    # ハードウェアエンコーダの映像はハードウェアデコーダを指定しないと受信できない
+    recvonly = SoraClient(
+        settings,
+        SoraRole.RECVONLY,
+        audio=False,
+        video=True,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    decoder=SoraVideoCodecImplementation.INTEL_VPL,
+                ),
+            ]
+        ),
+    )
+    recvonly.connect()
+    recvonly.wait_video_received()
 
     assert sendonly.connection_id is not None
 
@@ -108,6 +126,7 @@ def test_intel_vpl_key_frame_request(settings, video_codec_type):
     sendonly_stats = sendonly.get_stats()
 
     sendonly.disconnect()
+    recvonly.disconnect()
 
     # outbound-rtp が無かったら StopIteration 例外が上がる
     outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")

sora_sdk-2026.2.0.dev3/tests/test_key_frame_request.py

@@ -0,0 +1,131 @@
+import time
+
+import pytest
+from api import request_key_frame_api
+from client import (
+    SoraClient,
+    SoraRole,
+    codec_type_string_to_codec_type,
+)
+
+from sora_sdk import (
+    SoraVideoCodecImplementation,
+    SoraVideoCodecPreference,
+)
+
+
+@pytest.mark.parametrize(
+    "video_codec_type",
+    [
+        "VP9",
+        "VP8",
+        "AV1",
+    ],
+)
+def test_key_frame_request(settings, video_codec_type):
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    # RequestKeyFrame はキーフレームを受け取る相手がいる配信者にだけ PLI を送るため、
+    # 同じチャンネルに視聴者 (recvonly) を 1 本用意して受信を開始するまで待つ
+    recvonly = SoraClient(settings, SoraRole.RECVONLY, audio=False, video=True)
+    recvonly.connect()
+    recvonly.wait_video_received()
+
+    assert sendonly.connection_id is not None
+
+    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
+    api_count = 3
+    for _ in range(api_count):
+        response = request_key_frame_api(
+            settings.api_url, sendonly.channel_id, sendonly.connection_id
+        )
+        assert response.status_code == 200
+        time.sleep(3)
+
+    # 統計を取得する
+    sendonly_stats = sendonly.get_stats()
+
+    sendonly.disconnect()
+    recvonly.disconnect()
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+
+    # 3 回以上
+    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
+    assert outbound_rtp_stats["pliCount"] >= api_count
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
+
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
+    print(
+        "keyFramesEncoded >= pliCount * 0.7:",
+        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
+    )
+
+
+def video_outbound_rtp(stats):
+    """outbound-rtp の映像統計を取り出す。無ければ StopIteration 例外が上がる。"""
+    return next(s for s in stats if s.get("type") == "outbound-rtp" and s.get("kind") == "video")
+
+
+def test_key_frame_request_without_consumer(settings):
+    """
+    キーフレームを受け取る相手がいない配信者へのキーフレーム要求では PLI が送られないこと。
+
+    前提:
+    - RequestKeyFrame API はキーフレームを受け取る相手 (視聴者、クラスターのリレー、
+      録画、 RTP 転送) がいない配信者には PLI を送らない
+    - 送らない場合も API は成功を返す
+
+    期待:
+    - 視聴者がいない状態で API を呼ぶと 200 が返る
+    - PLI が送られないため pliCount が増えない
+    """
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type="VP8",
+    )
+    sendonly.connect(fake_video=True)
+
+    # 視聴者を用意せず、録画と RTP 転送も使わない状態にする
+    time.sleep(5)
+
+    assert sendonly.connection_id is not None
+
+    stats_before = video_outbound_rtp(sendonly.get_stats())
+
+    response = request_key_frame_api(settings.api_url, sendonly.channel_id, sendonly.connection_id)
+
+    # Sora はキーフレームを受け取るまで 1 秒間隔で最大 5 回 PLI を再送するため、その間待つ
+    time.sleep(5)
+
+    stats_after = video_outbound_rtp(sendonly.get_stats())
+
+    sendonly.disconnect()
+
+    # 相手がいない場合も API は成功を返す
+    assert response.status_code == 200, response.text
+    # キーフレームを受け取る相手がいないため PLI は送られない
+    assert stats_after["pliCount"] == stats_before["pliCount"], (
+        f"pliCount が増えている: before={stats_before['pliCount']}, after={stats_after['pliCount']}"
+    )

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_nvidia_video_codec.py

@@ -66,7 +66,7 @@ def test_nvidia_video_codec_sdk_available():
         "H265",
     ],
 )
-def test_intel_vpl_key_frame_request(settings, video_codec_type):
+def test_nvidia_video_codec_key_frame_request(settings, video_codec_type):
     sendonly = SoraClient(
         settings,
         SoraRole.SENDONLY,
@@ -84,7 +84,25 @@ def test_intel_vpl_key_frame_request(settings, video_codec_type):
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(3)
+    # RequestKeyFrame はキーフレームを受け取る相手がいる配信者にだけ PLI を送るため、
+    # 同じチャンネルに視聴者 (recvonly) を 1 本用意して受信を開始するまで待つ。
+    # ハードウェアエンコーダの映像はハードウェアデコーダを指定しないと受信できない
+    recvonly = SoraClient(
+        settings,
+        SoraRole.RECVONLY,
+        audio=False,
+        video=True,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    decoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
+                ),
+            ]
+        ),
+    )
+    recvonly.connect()
+    recvonly.wait_video_received()
 
     assert sendonly.connection_id is not None
 
@@ -101,6 +119,7 @@ def test_intel_vpl_key_frame_request(settings, video_codec_type):
     sendonly_stats = sendonly.get_stats()
 
     sendonly.disconnect()
+    recvonly.disconnect()
 
     # outbound-rtp が無かったら StopIteration 例外が上がる
     outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")

sora_sdk-2026.2.0.dev3/tests/test_rpc.py

@@ -0,0 +1,202 @@
+"""
+Sora の RPC 機能 (JSON-RPC 2.0 over DataChannel) の E2E テスト。
+
+SoraConnection.send_rpc() が rpc ラベルへ JSON-RPC 2.0 のリクエストを送信し、
+応答が on_rpc に届くことを確認する。rpc ラベルは Sora の RPC 機能が有効な場合に
+だけ offer に含まれるため、rpc ラベルを必要とするテストは含まれない環境では
+送信できないことを確認して skip する。
+"""
+
+from __future__ import annotations
+
+from queue import Empty
+from typing import Any
+
+import pytest
+from client import SoraClient, SoraRole
+
+NOT_EXIST_METHOD = "9999.0.0/not_exist"
+
+
+def _create_rpc_client(settings) -> SoraClient:
+    """
+    RPC のテストで使うクライアントを生成する (Sora への接続は with 文で行う)。
+
+    rpc ラベルは DataChannel 経由のシグナリングでのみ使うため data_channel_signaling を
+    有効にする。RPC は音声・映像とは独立して使えるため両方無効にするが、この構成では
+    ユーザー定義の DataChannel が 1 つも無いと Sora が接続メッセージを 4490
+    INVALID-MESSAGE で拒否するため、ダミーの #test ラベルを 1 つ用意する。
+    """
+    return SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        data_channel_signaling=True,
+        audio=False,
+        video=False,
+        data_channels=[{"label": "#test", "direction": "sendonly"}],
+    )
+
+
+def test_send_rpc_request_and_response(settings):
+    """
+    send_rpc() で送信した JSON-RPC 2.0 のリクエストに応答が返ることを確認する。
+
+    前提:
+    - RPC が有効な Sora に data_channel_signaling を有効にして接続する
+    - 払い出される rpc_methods に依存しないよう、存在しないメソッドを指定する
+
+    期待:
+    - send_rpc() が True を返す
+    - 応答が on_rpc に届き、送信した id と一致する
+    - 存在しないメソッドなので error を含む応答になる
+    - params に None / Array を指定した場合と、params を省略した場合も送信できる
+    """
+    with _create_rpc_client(settings) as client:
+        if not client.wait_rpc_ready(timeout=5):
+            # rpc ラベルが使えない環境では送信されず False が返る
+            assert client.send_rpc(1, NOT_EXIST_METHOD, {"key": "value"}) is False
+            pytest.skip("rpc ラベルが使えない環境のため送信できない")
+
+        # 送信した id がそのまま応答に含まれることを確認する (0 と 2^64-1 は境界値)
+        for request_id in [0, 1, 2**64 - 1]:
+            assert client.send_rpc(request_id, NOT_EXIST_METHOD, {"key": "value"})
+
+            response = client.recv_rpc(timeout=5)
+            assert response["id"] == request_id
+            assert "error" in response
+
+        # params に None を指定した場合は params を含めずに送信する
+        assert client.send_rpc(2, NOT_EXIST_METHOD, None)
+
+        response = client.recv_rpc(timeout=5)
+        assert response["id"] == 2
+
+        # params には Object だけでなく Array も指定できる
+        assert client.send_rpc(3, NOT_EXIST_METHOD, [])
+
+        response = client.recv_rpc(timeout=5)
+        assert response["id"] == 3
+
+        # params を省略した 2 引数呼び出しではバインディングの既定値 (None) が使われる。
+        # ヘルパは常に params を渡すため、ここでは SDK を直接呼ぶ
+        assert client._connection.send_rpc(4, NOT_EXIST_METHOD)
+
+        response = client.recv_rpc(timeout=5)
+        assert response["id"] == 4
+
+
+def test_send_rpc_notification_has_no_response(settings):
+    """
+    id に None を指定した Notification には Sora が応答を返さないことを確認する。
+
+    前提:
+    - RPC が有効な Sora に接続する
+    - id に None を指定してリクエストを送る
+
+    期待:
+    - send_rpc() が True を返す
+    - 応答が返らないため recv_rpc() が Empty でタイムアウトする
+    """
+    with _create_rpc_client(settings) as client:
+        if not client.wait_rpc_ready(timeout=5):
+            pytest.skip("rpc ラベルが使えない環境のため送信できない")
+
+        assert client.send_rpc(None, NOT_EXIST_METHOD, {"key": "value"})
+
+        # Notification には Sora が応答を返さない
+        with pytest.raises(Empty):
+            client.recv_rpc(timeout=3)
+
+
+def test_send_rpc_invalid_params(settings):
+    """
+    params に送信できない値を指定したときの挙動を確認する。
+
+    JSON-RPC 2.0 の params は Object か Array でなければならないため、それ以外の値に
+    変換される場合は送信せず False が返る。JSON の値として扱えない型の場合は既存の
+    Sora::ConvertJsonValue() と同じく TypeError、int64 の範囲を超える整数とキーが
+    文字列でない dict は同じく RuntimeError になる。TypeError と RuntimeError は引数の
+    変換時に発生するため rpc ラベルの有無に依存しない。False はラベルが無い場合も
+    Object / Array 以外の場合も返る。
+    """
+    with _create_rpc_client(settings) as client:
+        # 文字列・整数・浮動小数点数・真偽値は JSON の値には変換できるが params の要件を満たさない
+        for params in ["not-structured", 1, 1.5, True]:
+            assert client.send_rpc(1, NOT_EXIST_METHOD, params) is False
+
+        # JSON の値として扱えない型は TypeError になる
+        # 0.1 は float32 で厳密に表現できないため (Sora::ConvertJsonValue() の既知の制限)
+        for invalid_params in [
+            {"key": set()},
+            {"key": (1, 2)},
+            {"key": b"bytes"},
+            {"key": 0.1},
+        ]:
+            with pytest.raises(TypeError, match="Invalid JSON value in params"):
+                client.send_rpc(1, NOT_EXIST_METHOD, invalid_params)
+
+        # int64 の範囲を超える整数は nb::cast_error 由来の RuntimeError になる
+        with pytest.raises(RuntimeError):
+            client.send_rpc(1, NOT_EXIST_METHOD, {"key": 2**70})
+
+        # キーが文字列でない dict も nb::cast_error 由来の RuntimeError になる
+        with pytest.raises(RuntimeError):
+            client.send_rpc(1, NOT_EXIST_METHOD, {1: "value"})
+
+
+def test_send_rpc_invalid_id(settings):
+    """
+    id に None でも 0 以上 2^64-1 以下の整数でもない値を指定すると TypeError になることを確認する。
+
+    C++ SDK の SendRpc() の id は std::optional<uint64_t> のため、文字列・負の整数・
+    2^64 以上の整数は指定できない。
+    """
+    with _create_rpc_client(settings) as client:
+        # 型注釈 (int | None) では通せない値も実行時に渡すため、Any のリストを経由する
+        invalid_ids: list[Any] = ["id", -1, 2**64]
+        for invalid_id in invalid_ids:
+            with pytest.raises(TypeError):
+                client.send_rpc(invalid_id, NOT_EXIST_METHOD, {"key": "value"})
+
+
+def test_send_rpc_without_rpc_label_returns_false(settings):
+    """
+    rpc ラベルが使えない接続では send_rpc() が送信せず False を返すことを確認する。
+
+    前提:
+    - DataChannel 経由のシグナリングを使わずに接続する (offer の data_channels に
+      rpc ラベルが含まれない)
+
+    期待:
+    - send_rpc() が送信せず False を返す
+    - Sora の RPC 機能の有効無効に依存せず検証できる
+    """
+    with SoraClient(
+        settings,
+        SoraRole.RECVONLY,
+        audio=True,
+        video=True,
+        data_channel_signaling=False,
+        ignore_disconnect_websocket=False,
+    ) as client:
+        assert client.send_rpc(1, NOT_EXIST_METHOD, {"key": "value"}) is False
+
+
+def test_send_rpc_after_disconnect_raises_runtime_error(settings):
+    """
+    disconnect() 後の send_rpc() が SEGV ではなく RuntimeError になることを確認する。
+
+    前提:
+    - Sora に接続してから disconnect() する
+    - disconnect() 後の SoraConnection インスタンスをそのまま使う
+
+    期待:
+    - RuntimeError が発生する (メッセージに Already disconnected を含む)
+    - プロセスが SEGV で落ちない
+    """
+    with _create_rpc_client(settings) as client:
+        connection = client._connection
+        client.disconnect()
+
+        with pytest.raises(RuntimeError, match="Already disconnected"):
+            connection.send_rpc(1, NOT_EXIST_METHOD, {"key": "value"})

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_type_disconnect.py

@@ -27,7 +27,7 @@ def test_websocket_signaling_only_disconnect(settings):
 
         assert conn.disconnect_code == SoraSignalingErrorCode.CLOSE_SUCCEEDED
         assert (
-            conn.disconnect_reason == "Succeeded to close WebSocket (DC signaling is not enabled)"
+            conn.disconnect_reason == "Succeeded to close WebSocket (DC signaling is not available)"
         )
 
 

{sora_sdk-2026.2.0.dev1 → sora_sdk-2026.2.0.dev3}/tests/test_type_switched.py

@@ -8,6 +8,8 @@ def test_websocket_signaling_only_type_switched(settings):
     """
     - WebSocket シグナリングのみ
     - type: switched 送られてこない
+    - signaling の redirect で張り直した WebSocket のクローズ (SELF-CLOSED) は
+      接続中の WebSocket のクローズではないため ws_close には記録されない
     """
 
     with SoraClient(
@@ -29,6 +31,8 @@ def test_hybrid_signaling_type_switched(settings):
     """
     - WebSocket シグナリング + DataChannel シグナリング
     - type: switched 送られてくる
+    - signaling の redirect で張り直した WebSocket のクローズ (SELF-CLOSED) は
+      接続中の WebSocket のクローズではないため ws_close には記録されない
     """
     with SoraClient(
         settings,
@@ -49,7 +53,7 @@ def test_datachannel_signaling_only_type_switched(settings):
     """
     - DataChannel シグナリングのみ
     - type: switched 送られてくる
-    - Python SDK は WebSocket を自分で切断する
+    - Python SDK は WebSocket を自分で切断する (switched によるクローズは記録される)
     """
     with SoraClient(
         settings,

sora_sdk-2026.2.0.dev1/VERSION

@@ -1 +0,0 @@
-2026.2.0.dev1

sora_sdk-2026.2.0.dev1/tests/test_key_frame_request.py

@@ -1,75 +0,0 @@
-import time
-
-import pytest
-from api import request_key_frame_api
-from client import (
-    SoraClient,
-    SoraRole,
-    codec_type_string_to_codec_type,
-)
-
-from sora_sdk import (
-    SoraVideoCodecImplementation,
-    SoraVideoCodecPreference,
-)
-
-
-@pytest.mark.parametrize(
-    "video_codec_type",
-    [
-        "VP9",
-        "VP8",
-        "AV1",
-    ],
-)
-def test_key_frame_request(settings, video_codec_type):
-    sendonly = SoraClient(
-        settings,
-        SoraRole.SENDONLY,
-        audio=False,
-        video=True,
-        video_codec_type=video_codec_type,
-        video_codec_preference=SoraVideoCodecPreference(
-            codecs=[
-                SoraVideoCodecPreference.Codec(
-                    type=codec_type_string_to_codec_type(video_codec_type),
-                    encoder=SoraVideoCodecImplementation.INTERNAL,
-                ),
-            ]
-        ),
-    )
-    sendonly.connect(fake_video=True)
-
-    time.sleep(3)
-
-    assert sendonly.connection_id is not None
-
-    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
-    api_count = 3
-    for _ in range(api_count):
-        response = request_key_frame_api(
-            settings.api_url, sendonly.channel_id, sendonly.connection_id
-        )
-        assert response.status_code == 200
-        time.sleep(3)
-
-    # 統計を取得する
-    sendonly_stats = sendonly.get_stats()
-
-    sendonly.disconnect()
-
-    # outbound-rtp が無かったら StopIteration 例外が上がる
-    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
-
-    # 3 回以上
-    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
-    assert outbound_rtp_stats["pliCount"] >= api_count
-    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
-    print("pliCount:", outbound_rtp_stats["pliCount"])
-
-    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
-    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
-    print(
-        "keyFramesEncoded >= pliCount * 0.7:",
-        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
-    )