agora-python-server-sdk 1.1.0__tar.gz → 2.0.5__tar.gz

agora_python_server_sdk-2.0.5/MANIFEST.in

@@ -0,0 +1 @@
+exclude agora_rtc/agora/rtc/agora_sdk/*

agora_python_server_sdk-2.0.5/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: agora_python_server_sdk
+Version: 2.0.5
+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
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

agora_python_server_sdk-2.0.5/README.md

@@ -0,0 +1,36 @@
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

agora_python_server_sdk-2.0.5/agora/rtc/__init__.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import logging
+logger = logging.getLogger(__name__)
+import ctypes
+from urllib import request
+import site
+import zipfile
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+import hashlib
+
+def get_file_md5(file_path):
+    hash_md5 = hashlib.md5()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hash_md5.update(chunk)
+    return hash_md5.hexdigest()
+
+def _check_download_and_extract_sdk():
+    agora_service_path = os.path.dirname(os.path.abspath(__file__))
+    sdk_dir = os.path.join(agora_service_path, "agora_sdk")
+    zip_path = os.path.join(agora_service_path, "agora_rtc_sdk.zip")
+
+    url = "https://download.agora.io/sdk/release/agora_rtc_sdk_linux_v4.4.30-20240928_160128-358664.zip"
+    libagora_rtc_sdk_path = os.path.join(sdk_dir, "libagora_rtc_sdk.so")
+    rtc_md5 = "2c1d3fcac8ba6a491be4254186e963fc"
+    if sys.platform == 'darwin':
+        url = "https://download.agora.io/sdk/release/agora_sdk_mac_v4.4.30_22119_FULL_20240928_1647_358680.zip"
+        libagora_rtc_sdk_path = os.path.join(sdk_dir, "libAgoraRtcKit.dylib")
+        rtc_md5 = "e0be66fa1d9a067c04fa68dca634b35e"
+
+    if os.path.exists(libagora_rtc_sdk_path) and get_file_md5(libagora_rtc_sdk_path) == rtc_md5:
+        return
+
+    logger.error("missing agora sdk, now download it, please wait for a while...")
+    if os.path.exists(sdk_dir):
+        os.system(f"rm -rf {sdk_dir}")        
+    os.makedirs(agora_service_path, exist_ok=True)
+    if os.path.exists(zip_path):
+        os.remove(zip_path)
+
+    logger.info(f"agora_service_path: {agora_service_path}")
+    logger.info(f"Downloading {url}...")
+    request.urlretrieve(url, zip_path)
+
+    logger.info(f"Extracting {zip_path}...")
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(agora_service_path)
+
+    if os.path.exists(zip_path):
+        os.remove(zip_path)
+
+
+_check_download_and_extract_sdk()
+
+sdk_dir = os.path.dirname(os.path.abspath(__file__))
+lib_path = os.path.join(sdk_dir, 'agora_sdk')
+
+try:
+    if sys.platform == 'darwin':
+        lib_agora_rtc_path =os.path.join(lib_path, 'libAgoraRtcKit.dylib')
+        agora_lib = ctypes.CDLL(lib_agora_rtc_path)
+
+    elif sys.platform == 'linux':
+        lib_agora_rtc_path =os.path.join(lib_path, 'libagora_rtc_sdk.so')
+        ctypes.CDLL(os.path.join(lib_path, 'libagora-fdkaac.so'))
+        ctypes.CDLL(os.path.join(lib_path, 'libaosl.so'))
+        agora_lib = ctypes.CDLL(lib_agora_rtc_path)    
+except OSError as e:
+    logger.error(f"Error loading the library: {e}")
+    logger.error(f"Attempted to load from: {lib_agora_rtc_path}")
+    sys.exit(1)

agora_python_server_sdk-2.0.5/agora/rtc/_audio_frame_observer.py

@@ -0,0 +1,143 @@
+import ctypes
+from .agora_base import *
+from .local_user import *
+import ctypes
+from .audio_frame_observer import *
+import logging
+logger = logging.getLogger(__name__)
+
+
+class AudioFrameInner(ctypes.Structure):
+    _fields_ = [
+        ("type", ctypes.c_int),
+        ("samples_per_channel", ctypes.c_int),
+        ("bytes_per_sample", ctypes.c_int),
+        ("channels", ctypes.c_int),
+        ("samples_per_sec", ctypes.c_int),
+        ("buffer", ctypes.c_void_p),
+        ("render_time_ms", ctypes.c_int64),
+        ("avsync_type", ctypes.c_int),
+        ("far_field_flag", ctypes.c_int),
+        ("rms", ctypes.c_int),
+        ("voice_prob", ctypes.c_int),
+        ("music_prob", ctypes.c_int),
+        ("pitch", ctypes.c_int)
+    ]
+    def _to_audio_frame(self):
+        audio_frame = AudioFrame()
+        audio_frame.type = self.type
+        audio_frame.samples_per_channel = self.samples_per_channel
+        audio_frame.bytes_per_sample = self.bytes_per_sample
+        audio_frame.channels = self.channels
+        audio_frame.samples_per_sec = self.samples_per_sec
+        cdata = ctypes.string_at(self.buffer, self.samples_per_channel * self.bytes_per_sample * self.channels)
+        audio_frame.buffer = bytearray(cdata)
+        audio_frame.render_time_ms = self.render_time_ms
+        audio_frame.avsync_type = self.avsync_type
+        audio_frame.far_field_flag = self.far_field_flag
+        audio_frame.rms = self.rms
+        audio_frame.voice_prob = self.voice_prob
+        audio_frame.music_prob = self.music_prob
+        audio_frame.pitch = self.pitch
+
+        return audio_frame
+    
+
+ON_RECORD_AUDIO_FRAME_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE, ctypes.c_char_p, ctypes.POINTER(AudioFrameInner))
+ON_PLAYBACK_AUDIO_FRAME_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE, ctypes.c_char_p, ctypes.POINTER(AudioFrameInner))
+ON_MIXED_AUDIO_FRAME_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE, ctypes.c_char_p, ctypes.POINTER(AudioFrameInner))
+ON_EAR_MONITORING_AUDIO_FRAME_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE, ctypes.POINTER(AudioFrameInner))
+ON_PLAYBACK_AUDIO_FRAME_BEFORE_MIXING_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE, ctypes.c_char_p, user_id_t, ctypes.POINTER(AudioFrameInner))
+ON_GET_AUDIO_FRAME_POSITION_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, AGORA_HANDLE)
+ON_GET_PLAYBACK_AUDIO_FRAME_PARAM_CALLBACK = ctypes.CFUNCTYPE(AudioParams, AGORA_HANDLE)
+ON_GET_RECORD_AUDIO_FRAME_PARAM_CALLBACK = ctypes.CFUNCTYPE(AudioParams, AGORA_HANDLE)
+ON_GET_MIXED_AUDIO_FRAME_PARAM_CALLBACK = ctypes.CFUNCTYPE(AudioParams, AGORA_HANDLE)
+ON_GET_EAR_MONITORING_AUDIO_FRAME_PARAM_CALLBACK = ctypes.CFUNCTYPE(AudioParams, AGORA_HANDLE)
+
+class AudioFrameObserverInner(ctypes.Structure):
+    _fields_ = [
+        ("on_record_audio_frame", ON_RECORD_AUDIO_FRAME_CALLBACK),
+        ("on_playback_audio_frame", ON_PLAYBACK_AUDIO_FRAME_CALLBACK),
+        ("on_mixed_audio_frame", ON_MIXED_AUDIO_FRAME_CALLBACK),
+        ("on_ear_monitoring_audio_frame", ON_EAR_MONITORING_AUDIO_FRAME_CALLBACK),
+
+        ("on_playback_audio_frame_before_mixing", ON_PLAYBACK_AUDIO_FRAME_BEFORE_MIXING_CALLBACK),
+        ("on_get_audio_frame_position", ON_GET_AUDIO_FRAME_POSITION_CALLBACK),
+        ("on_get_playback_audio_frame_param", ON_GET_PLAYBACK_AUDIO_FRAME_PARAM_CALLBACK),
+        ("on_get_record_audio_frame_param", ON_GET_RECORD_AUDIO_FRAME_PARAM_CALLBACK),
+        
+        ("on_get_mixed_audio_frame_param", ON_GET_MIXED_AUDIO_FRAME_PARAM_CALLBACK),
+        ("on_get_ear_monitoring_audio_frame_param", ON_GET_EAR_MONITORING_AUDIO_FRAME_PARAM_CALLBACK)
+    ]
+
+    def __init__(self, observer:IAudioFrameObserver, local_user: 'LocalUser'):
+        self.observer = observer
+        self.local_user = local_user
+        self.on_record_audio_frame = ON_RECORD_AUDIO_FRAME_CALLBACK(self._on_record_audio_frame)
+        self.on_playback_audio_frame = ON_PLAYBACK_AUDIO_FRAME_CALLBACK(self._on_playback_audio_frame)
+        self.on_mixed_audio_frame = ON_MIXED_AUDIO_FRAME_CALLBACK(self._on_mixed_audio_frame)
+        self.on_ear_monitoring_audio_frame = ON_EAR_MONITORING_AUDIO_FRAME_CALLBACK(self._on_ear_monitoring_audio_frame)
+        self.on_playback_audio_frame_before_mixing = ON_PLAYBACK_AUDIO_FRAME_BEFORE_MIXING_CALLBACK(self._on_playback_audio_frame_before_mixing)
+        self.on_get_audio_frame_position = ON_GET_AUDIO_FRAME_POSITION_CALLBACK(self._on_get_audio_frame_position)
+
+        # self.on_get_playback_audio_frame_param = ON_GET_PLAYBACK_AUDIO_FRAME_PARAM_CALLBACK(self._on_get_playback_audio_frame_param)
+        # self.on_get_record_audio_frame_param = ON_GET_RECORD_AUDIO_FRAME_PARAM_CALLBACK(self._on_get_record_audio_frame_param)
+        # self.on_get_mixed_audio_frame_param = ON_GET_MIXED_AUDIO_FRAME_PARAM_CALLBACK(self._on_get_mixed_audio_frame_param)
+        # self.on_get_ear_monitoring_audio_frame_param = ON_GET_EAR_MONITORING_AUDIO_FRAME_PARAM_CALLBACK(self._on_get_ear_monitoring_audio_frame_param)
+
+    def _on_record_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
+        logger.debug(f"AudioFrameObserverInner _on_record_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
+        channel_id_str = channel_id.decode('utf-8')
+        frame = audio_frame_inner.contents._to_audio_frame()
+        ret = self.observer.on_record_audio_frame(self.local_user, channel_id_str, frame)
+        return ret
+
+    def _on_playback_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
+        logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
+        channel_id_str = channel_id.decode('utf-8')
+        frame = audio_frame_inner.contents._to_audio_frame()
+        ret = self.observer.on_playback_audio_frame(self.local_user, channel_id_str, frame)
+        return ret
+
+    def _on_mixed_audio_frame(self, local_user_handle, channel_id, audio_frame_inner):
+        logger.debug(f"AudioFrameObserverInner _on_mixed_audio_frame: {local_user_handle}, {channel_id}, {audio_frame_inner}")
+        ret = self.observer.on_mixed_audio_frame(self.local_user, audio_frame_inner)
+        return ret
+
+    def _on_ear_monitoring_audio_frame(self, local_user_handle, audio_frame_inner):
+        logger.debug(f"AudioFrameObserverInner _on_ear_monitoring_audio_frame: {local_user_handle}, {audio_frame_inner}")
+        ret = self.observer.on_ear_monitoring_audio_frame(self.local_user, audio_frame_inner)
+        return ret
+
+    def _on_playback_audio_frame_before_mixing(self, local_user_handle, channel_id, user_id, audio_frame_inner):
+        #logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame_before_mixing: {local_user_handle}, {channel_id}, {user_id}, {audio_frame_inner}")
+        if channel_id is None:
+            channel_id_str = ""
+        else:
+            channel_id_str = channel_id.decode('utf-8')
+
+        user_id_str = user_id.decode('utf-8')
+        frame = audio_frame_inner.contents._to_audio_frame()
+        ret = self.observer.on_playback_audio_frame_before_mixing(self.local_user, channel_id_str, user_id_str, frame)
+        return ret
+    
+    def _on_get_audio_frame_position(self, local_user_handle):
+        logger.debug(f"AudioFrameObserverInner _on_get_audio_frame_position: {local_user_handle}")
+        return self.observer.on_get_audio_frame_position(self.local_user)
+
+    def _on_get_playback_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_playback_audio_frame_param: {local_user_handle}")
+        return self.observer.on_get_playback_audio_frame_param(self.local_user)
+
+    def _on_get_record_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_record_audio_frame_param: {local_user_handle}")
+        return self.observer.on_get_record_audio_frame_param(self.local_user)
+
+    def _on_get_mixed_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_mixed_audio_frame_param: {local_user_handle}")
+        return self.observer.on_get_mixed_audio_frame_param(self.local_user)
+
+    def _on_get_ear_monitoring_audio_frame_param(self, local_user_handle) -> AudioParams:
+        logger.debug(f"AudioFrameObserverInner _on_get_ear_monitoring_audio_frame_param: {local_user_handle}")
+        return self.observer.on_get_ear_monitoring_audio_frame_param(self.local_user)
+