add template recordings to python sdk

Author: czerwiukk

fishjam/_fishjam_openapi_client/api/recordings/create_recording.py

@@ -5,15 +5,16 @@
 
 from ... import errors
 from ...client import AuthenticatedClient, Client
+from ...models.create_recording_files_body import CreateRecordingFilesBody
 from ...models.error import Error
 from ...models.recording_config import RecordingConfig
 from ...models.recording_details_response import RecordingDetailsResponse
-from ...types import Response
+from ...types import UNSET, Response, Unset
 
 
 def _get_kwargs(
     *,
-    body: RecordingConfig,
+    body: RecordingConfig | CreateRecordingFilesBody | Unset = UNSET,
 ) -> dict[str, Any]:
     headers: dict[str, Any] = {}
 
@@ -22,9 +23,12 @@ def _get_kwargs(
         "url": "/recordings",
     }
 
-    _kwargs["json"] = body.to_dict()
+    if isinstance(body, RecordingConfig):
+        _kwargs["json"] = body.to_dict()
 
-    headers["Content-Type"] = "application/json"
+        headers["Content-Type"] = "application/json"
+    if isinstance(body, CreateRecordingFilesBody):
+        _kwargs["files"] = body.to_multipart()
 
     _kwargs["headers"] = headers
     return _kwargs
@@ -78,14 +82,18 @@ def _build_response(
 def sync_detailed(
     *,
     client: AuthenticatedClient,
-    body: RecordingConfig,
+    body: RecordingConfig | CreateRecordingFilesBody | Unset = UNSET,
 ) -> Response[Error | RecordingDetailsResponse]:
     """Create a recording
 
      Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+    A source naming an `outputId` records an output the composition already has and is sent as JSON. A
+    template source renders its own scene and has to be sent as `multipart/form-data`: the configuration
+    in a `config` part, the React bundle in a `template` part.
 
     Args:
         body (RecordingConfig): Recording configuration
+        body (CreateRecordingFilesBody):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -109,14 +117,18 @@ def sync_detailed(
 def sync(
     *,
     client: AuthenticatedClient,
-    body: RecordingConfig,
+    body: RecordingConfig | CreateRecordingFilesBody | Unset = UNSET,
 ) -> Error | RecordingDetailsResponse | None:
     """Create a recording
 
      Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+    A source naming an `outputId` records an output the composition already has and is sent as JSON. A
+    template source renders its own scene and has to be sent as `multipart/form-data`: the configuration
+    in a `config` part, the React bundle in a `template` part.
 
     Args:
         body (RecordingConfig): Recording configuration
+        body (CreateRecordingFilesBody):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -135,14 +147,18 @@ def sync(
 async def asyncio_detailed(
     *,
     client: AuthenticatedClient,
-    body: RecordingConfig,
+    body: RecordingConfig | CreateRecordingFilesBody | Unset = UNSET,
 ) -> Response[Error | RecordingDetailsResponse]:
     """Create a recording
 
      Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+    A source naming an `outputId` records an output the composition already has and is sent as JSON. A
+    template source renders its own scene and has to be sent as `multipart/form-data`: the configuration
+    in a `config` part, the React bundle in a `template` part.
 
     Args:
         body (RecordingConfig): Recording configuration
+        body (CreateRecordingFilesBody):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
@@ -164,14 +180,18 @@ async def asyncio_detailed(
 async def asyncio(
     *,
     client: AuthenticatedClient,
-    body: RecordingConfig,
+    body: RecordingConfig | CreateRecordingFilesBody | Unset = UNSET,
 ) -> Error | RecordingDetailsResponse | None:
     """Create a recording
 
      Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+    A source naming an `outputId` records an output the composition already has and is sent as JSON. A
+    template source renders its own scene and has to be sent as `multipart/form-data`: the configuration
+    in a `config` part, the React bundle in a `template` part.
 
     Args:
         body (RecordingConfig): Recording configuration
+        body (CreateRecordingFilesBody):
 
     Raises:
         errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.

fishjam/_fishjam_openapi_client/models/__init__.py

@@ -5,6 +5,7 @@
 from .audio_sample_rate import AudioSampleRate
 from .composition_info import CompositionInfo
 from .composition_source import CompositionSource
+from .create_recording_files_body import CreateRecordingFilesBody
 from .error import Error
 from .list_recordings_metadata import ListRecordingsMetadata
 from .moq_access import MoqAccess
@@ -52,6 +53,8 @@
 from .subscribe_mode import SubscribeMode
 from .subscribe_tracks_body import SubscribeTracksBody
 from .subscriptions import Subscriptions
+from .template_source import TemplateSource
+from .template_source_resolution import TemplateSourceResolution
 from .track import Track
 from .track_forwarding import TrackForwarding
 from .track_forwarding_info import TrackForwardingInfo
@@ -69,6 +72,7 @@
     "AudioSampleRate",
     "CompositionInfo",
     "CompositionSource",
+    "CreateRecordingFilesBody",
     "Error",
     "ListRecordingsMetadata",
     "MoqAccess",
@@ -116,6 +120,8 @@
     "SubscribeMode",
     "SubscribeTracksBody",
     "Subscriptions",
+    "TemplateSource",
+    "TemplateSourceResolution",
     "Track",
     "TrackForwarding",
     "TrackForwardingInfo",

fishjam/_fishjam_openapi_client/models/composition_source.py

@@ -4,7 +4,6 @@
 from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
-from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
@@ -25,7 +24,6 @@ class CompositionSource:
     composition_url: str
     output_id: str
     scale_ratio: float | Unset = 1.0
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         composition_url = self.composition_url
@@ -35,7 +33,7 @@ def to_dict(self) -> dict[str, Any]:
         scale_ratio = self.scale_ratio
 
         field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
+
         field_dict.update({
             "compositionURL": composition_url,
             "outputId": output_id,
@@ -60,21 +58,4 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
             scale_ratio=scale_ratio,
         )
 
-        composition_source.additional_properties = d
         return composition_source
-
-    @property
-    def additional_keys(self) -> list[str]:
-        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/_fishjam_openapi_client/models/create_recording_files_body.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import File
+
+if TYPE_CHECKING:
+    from ..models.recording_config import RecordingConfig
+
+
+T = TypeVar("T", bound="CreateRecordingFilesBody")
+
+
+@_attrs_define
+class CreateRecordingFilesBody:
+    """
+    Attributes:
+        config (RecordingConfig): Recording configuration
+        template (File): The React template bundle to render, at most 1 MiB
+    """
+
+    config: RecordingConfig
+    template: File
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        config = self.config.to_dict()
+
+        template = self.template.to_tuple()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "config": config,
+            "template": template,
+        })
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        files.append((
+            "config",
+            (None, json.dumps(self.config.to_dict()).encode(), "application/json"),
+        ))
+
+        files.append(("template", self.template.to_tuple()))
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.recording_config import RecordingConfig
+
+        d = dict(src_dict)
+        config = RecordingConfig.from_dict(d.pop("config"))
+
+        template = File(payload=BytesIO(d.pop("template")))
+
+        create_recording_files_body = cls(
+            config=config,
+            template=template,
+        )
+
+        create_recording_files_body.additional_properties = d
+        return create_recording_files_body
+
+    @property
+    def additional_keys(self) -> list[str]:
+        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/_fishjam_openapi_client/models/recording.py

@@ -13,6 +13,7 @@
     from ..models.composition_source import CompositionSource
     from ..models.recording_file import RecordingFile
     from ..models.recording_metadata_type_0 import RecordingMetadataType0
+    from ..models.template_source import TemplateSource
 
 
 T = TypeVar("T", bound="Recording")
@@ -26,20 +27,21 @@ class Recording:
         files (list[RecordingFile]): Media files of the recording, in playback order. Empty until the recording is
             `available`.
         id (str): Assigned recording id
-        source (CompositionSource): Recording source coming from composition
+        source (CompositionSource | TemplateSource): The source for the recording
         status (RecordingStatus): Lifecycle status of a recording
         metadata (None | RecordingMetadataType0 | Unset): Free-form, user-supplied metadata used to organize and filter
             recordings
     """
 
     files: list[RecordingFile]
     id: str
-    source: CompositionSource
+    source: CompositionSource | TemplateSource
     status: RecordingStatus
     metadata: None | RecordingMetadataType0 | Unset = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.composition_source import CompositionSource
         from ..models.recording_metadata_type_0 import RecordingMetadataType0
 
         files = []
@@ -49,7 +51,11 @@ def to_dict(self) -> dict[str, Any]:
 
         id = self.id
 
-        source = self.source.to_dict()
+        source: dict[str, Any]
+        if isinstance(self.source, CompositionSource):
+            source = self.source.to_dict()
+        else:
+            source = self.source.to_dict()
 
         status = self.status.value
 
@@ -79,6 +85,7 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.composition_source import CompositionSource
         from ..models.recording_file import RecordingFile
         from ..models.recording_metadata_type_0 import RecordingMetadataType0
+        from ..models.template_source import TemplateSource
 
         d = dict(src_dict)
         files = []
@@ -90,7 +97,24 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
 
         id = d.pop("id")
 
-        source = CompositionSource.from_dict(d.pop("source"))
+        def _parse_source(data: object) -> CompositionSource | TemplateSource:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_recording_source_type_0 = CompositionSource.from_dict(
+                    data
+                )
+
+                return componentsschemas_recording_source_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_recording_source_type_1 = TemplateSource.from_dict(data)
+
+            return componentsschemas_recording_source_type_1
+
+        source = _parse_source(d.pop("source"))
 
         status = RecordingStatus(d.pop("status"))