agora-python-server-sdk 2.4.1__tar.gz → 2.4.3__tar.gz

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: agora_python_server_sdk
-Version: 2.4.1
+Version: 2.4.3
 Summary: A Python SDK for Agora Server
 Home-page: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
 Classifier: Intended Audience :: Developers
@@ -12,6 +12,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
 
 # Note
 - This is a Python SDK wrapper for the Agora RTC SDK.
@@ -64,6 +70,33 @@ python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx
 ```
 
 # Change log
+
+## 2026.01.15 Release Version 2.4.3
+
+- **Bugfix**: Fixed a bug to reset `pcm_consumer_` when calling `interrupt_audio`.
+
+## 2025.12.29 Release Version 2.4.2
+
+- Added **incremental send mode** support.
+- New `connection::send_intra_request` API, allowing you to initiate an intra request to remote users and trigger them to send a key frame.
+
+#### Example usage of incremental send mode
+
+```python
+# Configure incremental send parameters
+publish_config.send_external_audio_parameters = SendExternalAudioParameters(
+    enabled=True,
+    send_ms=2000,
+    send_speed=2,
+    deliver_mute_data_for_fake_adm=False
+)
+
+# Create an RTC connection
+connection = agora_service.create_rtc_connection(con_config, publish_config)
+```
+
+
+
 ## 2025.12.17 Release 2.4.1
 
 - Updated RTC SDK to version 154.

agora_python_server_sdk-2.4.1/agora_python_server_sdk.egg-info/PKG-INFO → agora_python_server_sdk-2.4.3/README.md

@@ -1,18 +1,3 @@
-Metadata-Version: 2.1
-Name: agora_python_server_sdk
-Version: 2.4.1
-Summary: A Python SDK for Agora Server
-Home-page: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Topic :: Multimedia :: Sound/Audio
-Classifier: Topic :: Multimedia :: Video
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
 # Note
 - This is a Python SDK wrapper for the Agora RTC SDK.
 - It supports Linux and Mac platforms.
@@ -64,6 +49,33 @@ python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx
 ```
 
 # Change log
+
+## 2026.01.15 Release Version 2.4.3
+
+- **Bugfix**: Fixed a bug to reset `pcm_consumer_` when calling `interrupt_audio`.
+
+## 2025.12.29 Release Version 2.4.2
+
+- Added **incremental send mode** support.
+- New `connection::send_intra_request` API, allowing you to initiate an intra request to remote users and trigger them to send a key frame.
+
+#### Example usage of incremental send mode
+
+```python
+# Configure incremental send parameters
+publish_config.send_external_audio_parameters = SendExternalAudioParameters(
+    enabled=True,
+    send_ms=2000,
+    send_speed=2,
+    deliver_mute_data_for_fake_adm=False
+)
+
+# Create an RTC connection
+connection = agora_service.create_rtc_connection(con_config, publish_config)
+```
+
+
+
 ## 2025.12.17 Release 2.4.1
 
 - Updated RTC SDK to version 154.
@@ -570,4 +582,4 @@ VAD: Good afternoon, what are some fun places to visit in Beijing?
 
 
 
-If latency is a concern, you can lower this value, or consult with the development team to determine how to manage latency while ensuring semantic continuity in speech recognition. This will help avoid the AI being interrupted too sensitively.
+If latency is a concern, you can lower this value, or consult with the development team to determine how to manage latency while ensuring semantic continuity in speech recognition. This will help avoid the AI being interrupted too sensitively.

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/_ctypes_handle/_local_user_observer.py

@@ -171,7 +171,7 @@ class RTCLocalUserObserverInner(ctypes.Structure):
     def _on_audio_track_publication_failure(self, local_user_handle, local_audio_track_handle, error_code):
         logger.debug(f"LocalUserCB _on_audio_track_publication_failure: {local_user_handle}, {local_audio_track_handle}, {error_code}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
-        self.local_user.del_audio_map(local_audio_track_handle)
+        self.local_user._del_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_publication_failure(self.local_user, audio_track, error_code)
 
     def _on_local_audio_track_state_changed(self, local_user_handle, local_audio_track_handle, state, error):

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/_ctypes_handle/_rtc_connection_observer.py

@@ -288,7 +288,7 @@ class CapabilitiesObserverInner(ctypes.Structure):
         self.on_capabilities_changed = ON_CAPABILITIES_CHANGED_CALLBACK(self._on_capabilities_changed)
         
     def _on_capabilities_changed(self, agora_capabilities_observer, ptr_caps_inner, size):
-        print(f"ConnCB _on_capabilities_changed: {agora_capabilities_observer}, {ptr_caps_inner}, {size}")
+        logger.debug(f"ConnCB _on_capabilities_changed: {agora_capabilities_observer}, {ptr_caps_inner}, {size}")
         
         # 正确解析C指针数组
         # 方法1: 使用ctypes.cast将指针转换为数组

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/agora_base.py

@@ -427,6 +427,18 @@ class SenderOptions:
     cc_mode: TCcMode = TCcMode.CC_ENABLED
     codec_type: VideoCodecType = VideoCodecType.VIDEO_CODEC_H264
 
+'''
+note: DeliverMuteDataForFakeAdm can only set to rtc engine level, can not
+set to connection level
+so if once a connection has set to true, wihich will affect all the connections,
+'''
+@dataclass(kw_only=True)
+class SendExternalAudioParameters:
+    enabled: bool = False
+    send_ms: int = 0
+    send_speed: int = 0
+    deliver_mute_data_for_fake_adm: bool = False
+
 
 @dataclass(kw_only=True)
 class RtcConnectionPublishConfig:
@@ -437,6 +449,7 @@ class RtcConnectionPublishConfig:
 	audio_publish_type: AudioPublishType = AudioPublishType.AUDIO_PUBLISH_TYPE_PCM
 	video_publish_type: VideoPublishType = VideoPublishType.VIDEO_PUBLISH_TYPE_NONE
 	video_encoded_image_sender_options: 'SenderOptions' = field(default_factory=SenderOptions)
+	send_external_audio_parameters: 'SendExternalAudioParameters | None' = None
 
 @dataclass(kw_only=True)
 class VideoSubscriptionOptions:

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/agora_service.py

@@ -186,11 +186,11 @@ class AgoraService:
         return RTCConnection(self, con_config, publish_config)
 
     # createCustomAudioTrackPcm: creatae a custom audio track from pcm data sender
-    def _create_custom_audio_track_pcm(self, audio_pcm_data_sender: AudioPcmDataSender, scenario: AudioScenarioType) -> LocalAudioTrack:
+    def _create_custom_audio_track_pcm(self, audio_pcm_data_sender: AudioPcmDataSender, scenario: AudioScenarioType, is_extra_audio: bool) -> LocalAudioTrack:
         if not self.inited:
             logger.error("AgoraService is not initialized. Please call initialize() first.")
             return None
-        if scenario == AudioScenarioType.AUDIO_SCENARIO_AI_SERVER:
+        if scenario == AudioScenarioType.AUDIO_SCENARIO_AI_SERVER and is_extra_audio == False:
             custom_audio_track = agora_service_create_direct_custom_audio_track_pcm(self.service_handle, audio_pcm_data_sender.sender_handle)
         else:
             custom_audio_track = agora_service_create_custom_audio_track_pcm(self.service_handle, audio_pcm_data_sender.sender_handle)
@@ -198,10 +198,10 @@ class AgoraService:
             return None
         local_track =  LocalAudioTrack(custom_audio_track)
         #default for ai senario to set min delay to 10ms
-        if scenario != AudioScenarioType.AUDIO_SCENARIO_AI_SERVER:
-            local_track.set_send_delay_ms(10)
-            local_track.set_max_buffer_audio_frame_number(100000)
+       
+        local_track.set_max_buffer_audio_frame_number(100000)
         #and set enable to true
+        local_track.set_send_delay_ms(10)
         local_track.set_enabled(True)
         return local_track
     # mix_mode: MIX_ENABLED = 0, MIX_DISABLED = 1

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/local_user.py

@@ -230,7 +230,9 @@ agora_local_user_send_aduio_meta_data = agora_lib.agora_local_user_send_audio_me
 agora_local_user_send_aduio_meta_data.restype = AGORA_API_C_INT
 agora_local_user_send_aduio_meta_data.argtypes = [AGORA_HANDLE, ctypes.c_char_p, ctypes.c_size_t]
 
-
+agora_local_user_send_intra_request = agora_lib.agora_local_user_send_intra_request
+agora_local_user_send_intra_request.restype = AGORA_API_C_INT
+agora_local_user_send_intra_request.argtypes = [AGORA_HANDLE, ctypes.c_char_p]
 
 
 class LocalUser:
@@ -628,3 +630,16 @@ class LocalUser:
         ret = self.connection._set_apm_filter_properties(remote_audio_track_handle, user_id_str)
         print(f"**********LocalUser _set_apm_filter_properties: {ret}")
         return ret
+        pass
+    def _send_intra_request(self, remote_uid: str) -> int:
+        #validity check
+        if remote_uid is None:
+            return -1000
+        if self.user_handle is None:
+            return -1001
+        uid_str = remote_uid.encode('utf-8')
+        ret = agora_local_user_send_intra_request(self.user_handle, ctypes.c_char_p(uid_str))
+        if ret < 0:
+            logger.error("Failed to send intra request")
+        return ret
+        pass

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/agora/rtc/rtc_connection.py

@@ -83,6 +83,13 @@ agora_local_user_unregister_capabilities_observer = agora_lib.agora_local_user_u
 agora_local_user_unregister_capabilities_observer.restype = AGORA_API_C_INT
 agora_local_user_unregister_capabilities_observer.argtypes = [AGORA_HANDLE, AGORA_HANDLE]
 
+agora_local_audio_track_set_total_extra_send_ms = agora_lib.agora_local_audio_track_set_total_extra_send_ms
+agora_local_audio_track_set_total_extra_send_ms.restype = AGORA_API_C_INT
+agora_local_audio_track_set_total_extra_send_ms.argtypes = [AGORA_HANDLE, ctypes.c_uint64]
+
+#global variable
+_is_deliver_mute_data_has_set: bool = False
+
 class RTCConnection:
     def __init__(self, service: AgoraService, conn_config: RTCConnConfig, publish_config: RtcConnectionPublishConfig) -> None:
         self.conn_handle = None
@@ -90,6 +97,7 @@ class RTCConnection:
         self.local_user = None
         self.rtc_engine = service
         self._con_observer = None
+        self._agora_parameter = None
         #1 create conn_handle
         self.conn_handle = agora_rtc_conn_create(self.rtc_engine.service_handle, ctypes.byref(RTCConnConfigInner.create(conn_config)))
         if self.conn_handle is None:
@@ -98,6 +106,7 @@ class RTCConnection:
         self.local_user_handle = agora_rtc_conn_get_local_user(self.conn_handle)
         if self.local_user_handle:
             self.local_user = LocalUser(self.local_user_handle, self)
+        self._agora_parameter = self._init_agora_parameter()
         #keep publish_config
         self.publish_config = publish_config
         #and prepare track and sender for publish
@@ -107,6 +116,9 @@ class RTCConnection:
         self._audio_encoded_sender = None
         self._video_sender = None
         self._video_encoded_sender = None
+        # for external audio parameters
+        self._send_external_audio_parameters = publish_config.send_external_audio_parameters
+        
         self._pcm_consume_stats = PcmConsumeStats()
         self._prepare_publish_track_and_sender()
         #3 set profile and scenario
@@ -123,12 +135,15 @@ class RTCConnection:
         self._capabilities_observer_obj = None
         if self.publish_config.audio_scenario == AudioScenarioType.AUDIO_SCENARIO_AI_SERVER:
             self._register_capabilities_observer()
+        # for external audio parameters
+        self._set_send_external_send_frame_speed(self._send_external_audio_parameters)
 
     def _prepare_publish_track_and_sender(self)->int:
         if self.publish_config.is_publish_audio:
            if self.publish_config.audio_publish_type == AudioPublishType.AUDIO_PUBLISH_TYPE_PCM:
                self._audio_sender = self.rtc_engine.media_node_factory.create_audio_pcm_data_sender()
-               self._audio_track = self.rtc_engine._create_custom_audio_track_pcm(self._audio_sender, self.publish_config.audio_scenario)
+               is_extra_audio = self._is_support_send_external_audio()
+               self._audio_track = self.rtc_engine._create_custom_audio_track_pcm(self._audio_sender, self.publish_config.audio_scenario, is_extra_audio)
            elif self.publish_config.audio_publish_type == AudioPublishType.AUDIO_PUBLISH_TYPE_ENCODED_PCM:
                self._audio_encoded_sender = self.rtc_engine.media_node_factory.create_audio_encoded_frame_sender()
                self._audio_track = self.rtc_engine.create_custom_audio_track_encoded(self._audio_encoded_sender, 1)#mix_mode: MIX_ENABLED = 0, MIX_DISABLED = 1
@@ -203,11 +218,13 @@ class RTCConnection:
         return ret
 
     #
-    def get_agora_parameter(self):
+    def _init_agora_parameter(self):
         agora_parameter = agora_rtc_conn_get_agora_parameter(self.conn_handle)
         if not agora_parameter:
             return None
         return AgoraParameter(agora_parameter)
+    def get_agora_parameter(self):
+        return self._agora_parameter
 
     #
 
@@ -337,6 +354,8 @@ class RTCConnection:
         ret = -1000
         if self.local_user and self._audio_track:
             ret = self.local_user._unpublish_audio(self._audio_track)
+        #reset pcm consumer state now
+        self._pcm_consume_stats.reset()
         return ret
     def publish_video(self)->int:
         ret = -1000
@@ -357,6 +376,9 @@ class RTCConnection:
             self.publish_audio()
         elif self._audio_track:
             self._audio_track.clear_sender_buffer()
+
+        # reset pcm consumer to new state now
+        self._pcm_consume_stats.reset()
         return ret
     def send_audio_meta_data(self, data)->int:
         ret = -1000
@@ -397,6 +419,11 @@ class RTCConnection:
         frame.samples_per_channel = readLen // (channels * 2)
         frame.present_time_ms = start_pts
 
+        #check if a new round or not. if new round should call _set_total_extra_send_ms()
+        is_new_round = self._pcm_consume_stats.is_new_round()
+        if is_new_round:
+            self._set_total_extra_send_ms()
+
         ret = self._audio_sender.send_audio_pcm_data(frame)
         self._pcm_consume_stats.add_pcm_data(readLen, sample_rate, channels)
         return ret
@@ -431,8 +458,9 @@ class RTCConnection:
         
         updated_track = None
         delayed_del_track = None
+        is_extra_audio = False
         if self._audio_sender:
-            updated_track = self.rtc_engine._create_custom_audio_track_pcm(self._audio_sender, scenario)
+            updated_track = self.rtc_engine._create_custom_audio_track_pcm(self._audio_sender, scenario, is_extra_audio)
         elif self._audio_encoded_sender:
             updated_track = self.rtc_engine.create_custom_audio_track_encoded(self._audio_encoded_sender, scenario)
             
@@ -440,6 +468,8 @@ class RTCConnection:
             delayed_del_track = self._audio_track
             self._audio_track = updated_track
             self._audio_track.set_enabled(True)
+            self._audio_track.set_send_delay_ms(10)
+            self._audio_track.set_max_buffer_audio_frame_number(100000)
       
         if delayed_del_track:
             delayed_del_track.release()
@@ -467,10 +497,10 @@ class RTCConnection:
         item_index = 0
         for cap in capabilities:
             item_index = 0
-            print(f"Capability[{index}] - Type: {cap.capability_type}")
+            logger.debug(f"Capability[{index}] - Type: {cap.capability_type}")
             index += 1
             for item in cap.item_map.item:
-                print(f"Item[{item_index}] - ID: {item.id}, Name: {item.name}")
+                logger.debug(f"Item[{item_index}] - ID: {item.id}, Name: {item.name}")
                 item_index += 1
                 if cap.capability_type == 19 and item.name and item.name.upper() == "SUPPORT":
                     fallback_scenario = False
@@ -541,5 +571,64 @@ class RTCConnection:
             print(f"**********APM: to enable apm_dump, error: {ret}")
         return ret
     
+    def _set_send_external_send_frame_speed(self, send_external_audio_parameters: SendExternalAudioParameters)->int:
+        ret = -1000
+        if send_external_audio_parameters == None or send_external_audio_parameters.enabled == False or send_external_audio_parameters.send_ms <= 0 or send_external_audio_parameters.send_speed <= 1:
+            return -1001
+        speed = send_external_audio_parameters.send_speed
+        if speed < 1:
+            speed = 1
+        if speed > 5:
+            speed = 5
+        #set send speed for fake adm to connection level
+        params = '{"che.audio.extra_send_frames_per_interval_for_fake_adm": %d}' % speed
+
+        if (self._agora_parameter is None):
+            return -1002
+        ret = self._agora_parameter.set_parameters(params)
+       
+    
+        # set deliver mute data for fake adm to service level and only once
+        self._set_deliver_mute_data_for_fake_adm(send_external_audio_parameters.deliver_mute_data_for_fake_adm)
+        
+        return ret
+        pass
+
+    def _set_deliver_mute_data_for_fake_adm(self, deliver_mute_data_for_fake_adm: bool)->int:
+        ret = -1000
+        global _is_deliver_mute_data_has_set
+        if deliver_mute_data_for_fake_adm == False and _is_deliver_mute_data_has_set == False:
+            params = '{"che.audio.deliver_mute_data_for_fake_adm": false}'
+            rtc_parameter = self.rtc_engine.get_agora_parameter()
+            if rtc_parameter is not None:
+                ret = rtc_parameter.set_parameters(params)
+                _is_deliver_mute_data_has_set = True
+        return ret
+    def _is_support_send_external_audio(self)->bool:
+        ret = False
+        if ((self._send_external_audio_parameters is not None)
+         and (self._send_external_audio_parameters.enabled == True)
+         and (self._send_external_audio_parameters.send_ms > 0)
+         and (self._send_external_audio_parameters.send_speed > 1)):
+            ret = True
+        return ret
+        pass
+    #only valid after call this api
+    #and default call before each round
+    def _set_total_extra_send_ms(self)->int:
+        is_support = self._is_support_send_external_audio()
+        if is_support == False:
+            return 0
+        send_ms = self._send_external_audio_parameters.send_ms
+        ret = agora_local_audio_track_set_total_extra_send_ms(self._audio_track.track_handle, ctypes.c_uint64(send_ms))
     
+        return ret
+        pass
+    def send_intra_request(self, remote_uid: str) -> int:
+        ret = -1000
+        if self.local_user is None:
+            return -1001
+        ret = self.local_user._send_intra_request(remote_uid)
+        return ret
+        pass
     

agora_python_server_sdk-2.4.1/README.md → agora_python_server_sdk-2.4.3/agora_python_server_sdk.egg-info/PKG-INFO

@@ -1,3 +1,24 @@
+Metadata-Version: 2.2
+Name: agora_python_server_sdk
+Version: 2.4.3
+Summary: A Python SDK for Agora Server
+Home-page: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
 # Note
 - This is a Python SDK wrapper for the Agora RTC SDK.
 - It supports Linux and Mac platforms.
@@ -49,6 +70,33 @@ python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx
 ```
 
 # Change log
+
+## 2026.01.15 Release Version 2.4.3
+
+- **Bugfix**: Fixed a bug to reset `pcm_consumer_` when calling `interrupt_audio`.
+
+## 2025.12.29 Release Version 2.4.2
+
+- Added **incremental send mode** support.
+- New `connection::send_intra_request` API, allowing you to initiate an intra request to remote users and trigger them to send a key frame.
+
+#### Example usage of incremental send mode
+
+```python
+# Configure incremental send parameters
+publish_config.send_external_audio_parameters = SendExternalAudioParameters(
+    enabled=True,
+    send_ms=2000,
+    send_speed=2,
+    deliver_mute_data_for_fake_adm=False
+)
+
+# Create an RTC connection
+connection = agora_service.create_rtc_connection(con_config, publish_config)
+```
+
+
+
 ## 2025.12.17 Release 2.4.1
 
 - Updated RTC SDK to version 154.
@@ -555,4 +603,4 @@ VAD: Good afternoon, what are some fun places to visit in Beijing?
 
 
 
-If latency is a concern, you can lower this value, or consult with the development team to determine how to manage latency while ensuring semantic continuity in speech recognition. This will help avoid the AI being interrupted too sensitively.
+If latency is a concern, you can lower this value, or consult with the development team to determine how to manage latency while ensuring semantic continuity in speech recognition. This will help avoid the AI being interrupted too sensitively.

{agora_python_server_sdk-2.4.1 → agora_python_server_sdk-2.4.3}/setup.py

@@ -126,7 +126,7 @@ class CustomInstallCommand(install):
 
 setup(
     name='agora_python_server_sdk',
-    version='2.4.1',
+    version='2.4.3',
     description='A Python SDK for Agora Server',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',