Add agents to room api and add Agent class

Author: AHGIJMKLKKZNPJKQR

compile_proto.sh

@@ -8,7 +8,8 @@ git submodule sync --recursive >>/dev/null
 git submodule update --recursive --remote --init >>/dev/null
 printf "DONE\n\n"
 
-server_file="./protos/fishjam/server_notifications.proto"
-printf "Compiling: file $server_file\n"
-protoc -I . --python_betterproto_out=./fishjam/events/_protos $server_file
+FILES=("protos/fishjam/agent_notifications.proto" "protos/fishjam/server_notifications.proto")
+
+printf "Compiling file: %s\n" "${FILES[@]}"
+protoc -I protos --python_betterproto_out="./fishjam/events/_protos" "${FILES[@]}"
 printf "\tDONE\n"

fishjam/__init__.py

@@ -1,5 +1,5 @@
 """
-    .. include:: ../README.md
+.. include:: ../README.md
 """
 
 # pylint: disable=locally-disabled, no-name-in-module, import-error
@@ -10,7 +10,7 @@
 # pylint: disable=locally-disabled, no-name-in-module, import-error
 
 # Exceptions and Server Messages
-from fishjam import errors, events, peer, room
+from fishjam import agent, errors, events, peer, room
 
 # API
 from fishjam._webhook_notifier import receive_binary
@@ -35,6 +35,7 @@
     "errors",
     "room",
     "peer",
+    "agent",
 ]
 
 __docformat__ = "restructuredtext"

fishjam/_openapi_client/models/__init__.py

@@ -7,11 +7,20 @@
 from .peer import Peer
 from .peer_details_response import PeerDetailsResponse
 from .peer_details_response_data import PeerDetailsResponseData
+from .peer_options_agent import PeerOptionsAgent
 from .peer_options_web_rtc import PeerOptionsWebRTC
 from .peer_options_web_rtc_metadata import PeerOptionsWebRTCMetadata
+from .peer_options_web_rtc_subscribe import PeerOptionsWebRTCSubscribe
+from .peer_options_web_rtc_subscribe_audio_format import (
+    PeerOptionsWebRTCSubscribeAudioFormat,
+)
+from .peer_options_web_rtc_subscribe_audio_sample_rate import (
+    PeerOptionsWebRTCSubscribeAudioSampleRate,
+)
 from .peer_refresh_token_response import PeerRefreshTokenResponse
 from .peer_refresh_token_response_data import PeerRefreshTokenResponseData
 from .peer_status import PeerStatus
+from .peer_type import PeerType
 from .room import Room
 from .room_config import RoomConfig
 from .room_config_room_type import RoomConfigRoomType
@@ -33,11 +42,16 @@
     "Peer",
     "PeerDetailsResponse",
     "PeerDetailsResponseData",
+    "PeerOptionsAgent",
     "PeerOptionsWebRTC",
     "PeerOptionsWebRTCMetadata",
+    "PeerOptionsWebRTCSubscribe",
+    "PeerOptionsWebRTCSubscribeAudioFormat",
+    "PeerOptionsWebRTCSubscribeAudioSampleRate",
     "PeerRefreshTokenResponse",
     "PeerRefreshTokenResponseData",
     "PeerStatus",
+    "PeerType",
     "Room",
     "RoomConfig",
     "RoomConfigRoomType",

fishjam/_openapi_client/models/add_peer_json_body.py

@@ -1,9 +1,20 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.peer_type import PeerType
+
 if TYPE_CHECKING:
+    from ..models.peer_options_agent import PeerOptionsAgent
     from ..models.peer_options_web_rtc import PeerOptionsWebRTC
 
 
@@ -14,18 +25,26 @@
 class AddPeerJsonBody:
     """ """
 
-    options: "PeerOptionsWebRTC"
-    """Options specific to the WebRTC peer"""
-    type: str
+    options: Union["PeerOptionsAgent", "PeerOptionsWebRTC"]
+    """Peer-specific options"""
+    type: PeerType
     """Peer type"""
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
     """@private"""
 
     def to_dict(self) -> Dict[str, Any]:
         """@private"""
-        options = self.options.to_dict()
+        from ..models.peer_options_web_rtc import PeerOptionsWebRTC
+
+        options: Dict[str, Any]
+
+        if isinstance(self.options, PeerOptionsWebRTC):
+            options = self.options.to_dict()
+
+        else:
+            options = self.options.to_dict()
 
-        type = self.type
+        type = self.type.value
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -41,12 +60,33 @@ def to_dict(self) -> Dict[str, Any]:
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         """@private"""
+        from ..models.peer_options_agent import PeerOptionsAgent
         from ..models.peer_options_web_rtc import PeerOptionsWebRTC
 
         d = src_dict.copy()
-        options = PeerOptionsWebRTC.from_dict(d.pop("options"))
 
-        type = d.pop("type")
+        def _parse_options(
+            data: object,
+        ) -> Union["PeerOptionsAgent", "PeerOptionsWebRTC"]:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_peer_options_type_0 = PeerOptionsWebRTC.from_dict(
+                    data
+                )
+
+                return componentsschemas_peer_options_type_0
+            except:  # noqa: E722
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_peer_options_type_1 = PeerOptionsAgent.from_dict(data)
+
+            return componentsschemas_peer_options_type_1
+
+        options = _parse_options(d.pop("options"))
+
+        type = PeerType(d.pop("type"))
 
         add_peer_json_body = cls(
             options=options,

fishjam/_openapi_client/models/peer.py

@@ -4,6 +4,7 @@
 from attrs import field as _attrs_field
 
 from ..models.peer_status import PeerStatus
+from ..models.peer_type import PeerType
 
 if TYPE_CHECKING:
     from ..models.track import Track
@@ -24,7 +25,7 @@ class Peer:
     """Informs about the peer status"""
     tracks: List["Track"]
     """List of all peer's tracks"""
-    type: str
+    type: PeerType
     """Peer type"""
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
     """@private"""
@@ -41,7 +42,7 @@ def to_dict(self) -> Dict[str, Any]:
 
             tracks.append(tracks_item)
 
-        type = self.type
+        type = self.type.value
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -76,7 +77,7 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
 
             tracks.append(tracks_item)
 
-        type = d.pop("type")
+        type = PeerType(d.pop("type"))
 
         peer = cls(
             id=id,

fishjam/_openapi_client/models/peer_options_agent.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PeerOptionsAgent")
+
+
+@_attrs_define
+class PeerOptionsAgent:
+    """Options specific to the Agent peer"""
+
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+    """@private"""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """@private"""
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        """@private"""
+        d = src_dict.copy()
+        peer_options_agent = cls()
+
+        peer_options_agent.additional_properties = d
+        return peer_options_agent
+
+    @property
+    def additional_keys(self) -> List[str]:
+        """@private"""
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

fishjam/_openapi_client/models/peer_options_web_rtc.py

@@ -7,6 +7,7 @@
 
 if TYPE_CHECKING:
     from ..models.peer_options_web_rtc_metadata import PeerOptionsWebRTCMetadata
+    from ..models.peer_options_web_rtc_subscribe import PeerOptionsWebRTCSubscribe
 
 
 T = TypeVar("T", bound="PeerOptionsWebRTC")
@@ -20,6 +21,8 @@ class PeerOptionsWebRTC:
     """Enables the peer to use simulcast"""
     metadata: Union[Unset, "PeerOptionsWebRTCMetadata"] = UNSET
     """Custom peer metadata"""
+    subscribe: Union[Unset, None, "PeerOptionsWebRTCSubscribe"] = UNSET
+    """Configure server-side subscriptions to the peer's tracks"""
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
     """@private"""
 
@@ -30,20 +33,27 @@ def to_dict(self) -> Dict[str, Any]:
         if not isinstance(self.metadata, Unset):
             metadata = self.metadata.to_dict()
 
+        subscribe: Union[Unset, None, Dict[str, Any]] = UNSET
+        if not isinstance(self.subscribe, Unset):
+            subscribe = self.subscribe.to_dict() if self.subscribe else None
+
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
         if enable_simulcast is not UNSET:
             field_dict["enableSimulcast"] = enable_simulcast
         if metadata is not UNSET:
             field_dict["metadata"] = metadata
+        if subscribe is not UNSET:
+            field_dict["subscribe"] = subscribe
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         """@private"""
         from ..models.peer_options_web_rtc_metadata import PeerOptionsWebRTCMetadata
+        from ..models.peer_options_web_rtc_subscribe import PeerOptionsWebRTCSubscribe
 
         d = src_dict.copy()
         enable_simulcast = d.pop("enableSimulcast", UNSET)
@@ -55,9 +65,19 @@ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
         else:
             metadata = PeerOptionsWebRTCMetadata.from_dict(_metadata)
 
+        _subscribe = d.pop("subscribe", UNSET)
+        subscribe: Union[Unset, None, PeerOptionsWebRTCSubscribe]
+        if _subscribe is None:
+            subscribe = None
+        elif isinstance(_subscribe, Unset):
+            subscribe = UNSET
+        else:
+            subscribe = PeerOptionsWebRTCSubscribe.from_dict(_subscribe)
+
         peer_options_web_rtc = cls(
             enable_simulcast=enable_simulcast,
             metadata=metadata,
+            subscribe=subscribe,
         )
 
         peer_options_web_rtc.additional_properties = d

fishjam/_openapi_client/models/peer_options_web_rtc_subscribe.py

@@ -0,0 +1,78 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+
+from ..models.peer_options_web_rtc_subscribe_audio_format import (
+    PeerOptionsWebRTCSubscribeAudioFormat,
+)
+from ..models.peer_options_web_rtc_subscribe_audio_sample_rate import (
+    PeerOptionsWebRTCSubscribeAudioSampleRate,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PeerOptionsWebRTCSubscribe")
+
+
+@_attrs_define
+class PeerOptionsWebRTCSubscribe:
+    """Configure server-side subscriptions to the peer's tracks
+
+    Example:
+        {'audioFormat': 'pcm16'}
+
+    """
+
+    audio_format: Union[
+        Unset, PeerOptionsWebRTCSubscribeAudioFormat
+    ] = PeerOptionsWebRTCSubscribeAudioFormat.PCM16
+    """The format to use for the output audio"""
+    audio_sample_rate: Union[
+        Unset, PeerOptionsWebRTCSubscribeAudioSampleRate
+    ] = PeerOptionsWebRTCSubscribeAudioSampleRate.VALUE_16000
+    """The sample rate to use for the output audio"""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """@private"""
+        audio_format: Union[Unset, str] = UNSET
+        if not isinstance(self.audio_format, Unset):
+            audio_format = self.audio_format.value
+
+        audio_sample_rate: Union[Unset, int] = UNSET
+        if not isinstance(self.audio_sample_rate, Unset):
+            audio_sample_rate = self.audio_sample_rate.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update({})
+        if audio_format is not UNSET:
+            field_dict["audioFormat"] = audio_format
+        if audio_sample_rate is not UNSET:
+            field_dict["audioSampleRate"] = audio_sample_rate
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        """@private"""
+        d = src_dict.copy()
+        _audio_format = d.pop("audioFormat", UNSET)
+        audio_format: Union[Unset, PeerOptionsWebRTCSubscribeAudioFormat]
+        if isinstance(_audio_format, Unset):
+            audio_format = UNSET
+        else:
+            audio_format = PeerOptionsWebRTCSubscribeAudioFormat(_audio_format)
+
+        _audio_sample_rate = d.pop("audioSampleRate", UNSET)
+        audio_sample_rate: Union[Unset, PeerOptionsWebRTCSubscribeAudioSampleRate]
+        if isinstance(_audio_sample_rate, Unset):
+            audio_sample_rate = UNSET
+        else:
+            audio_sample_rate = PeerOptionsWebRTCSubscribeAudioSampleRate(
+                _audio_sample_rate
+            )
+
+        peer_options_web_rtc_subscribe = cls(
+            audio_format=audio_format,
+            audio_sample_rate=audio_sample_rate,
+        )
+
+        return peer_options_web_rtc_subscribe