Add lite transcription support (#4)

Author: marceln

README.md

@@ -26,14 +26,34 @@ pip install salad-cloud-transcription
 
 ```python
 from salad_cloud_transcription import SaladCloudTranscriptionSdk
+from salad_cloud_transcription_sdk.models.transcription_engine import TranscriptionEngine
+from salad_cloud_transcription_sdk.models.transcription_request import TranscriptionRequest
+from salad_cloud_transcription_sdk.models.transcription_job_input import TranscriptionJobInput
 
 # Initialize the SDK
 sdk = SaladCloudTranscriptionSdk(api_key="your_api_key")
 
-# Transcribe an audio file
+# Setup the request
+request_object = TranscriptionRequest(
+    options=TranscriptionJobInput(
+        language_code="en",
+        return_as_file=False,
+        sentence_level_timestamps=True,
+        word_level_timestamps=True,
+        diarization=True,
+        srt=True
+    ),
+    metadata={"project": "example_project"}
+)
+
+# Transcribe a video file using the Full Transcription engine
 result = sdk.transcription_client.transcribe(
-    "path/to/audio.mp3",
-    auto_poll = True)
+    "path/to/video.mp4",
+    organization_name="your_organization_name",
+    request=request_object,
+    engine=TranscriptionEngine.Full,
+    auto_poll=True
+)
 
 # Print the transcription
 print(result.text)
@@ -59,6 +79,33 @@ If you need to set or update the API key after initializing the SDK, you can use
 sdk.set_api_key("YOUR_API_KEY")
 ```
 
+## Transcription Engines
+The SDK supports two transcription modes: `Full` and `Lite`. The desired mode can be specified via the `engine` parameter of the `transcribe` method. When omitted it defaults to `Full`. 
+
+When using the `Lite` engine, the request object has to specify explicit defaults for a few of the properties:
+
+```python
+    request = TranscriptionRequest(
+        options=TranscriptionJobInput(
+            language_code="en",
+            return_as_file=True,
+            translate="to_eng",
+            sentence_level_timestamps=True,
+            word_level_timestamps=True,
+            diarization=True,
+            sentence_diarization=True,
+            srt=True,
+
+            # Adding required parameters with null/empty values
+            summarize=0,
+            custom_vocabulary="",
+            llm_translation=[],
+            srt_translation=[],
+        ),
+        metadata={"test_id": "integration_test", "environment": "testing"},
+    )
+```
+
 ## Sample Usage
 
 ### The *source* parameter
@@ -74,18 +121,35 @@ When a remote file is specified, that URL is passed as-is to the transcription e
 
 ```python
 from salad_cloud_transcription import SaladCloudTranscriptionSdk
+from salad_cloud_transcription_sdk.models.transcription_engine import TranscriptionEngine
+from salad_cloud_transcription_sdk.models.transcription_request import TranscriptionRequest
+from salad_cloud_transcription_sdk.models.transcription_job_input import TranscriptionJobInput
 
 # Initialize the SDK
 sdk = SaladCloudTranscriptionSdk(api_key="your_api_key")
 
+# Setup the request
+request_object = TranscriptionRequest(
+    options=TranscriptionJobInput(
+        language_code="en",
+        return_as_file=False,
+        sentence_level_timestamps=True,
+        word_level_timestamps=True,
+        diarization=True,
+        srt=True
+    ),
+    metadata={"project": "example_project"}
+)
+
 # Start a transcription job and wait for the result
-# When the job is processed, this function returns a InferenceEndpointJob
 result = sdk.transcription_client.transcribe(
-    source = "path/to/audio.mp3",
-    auto_poll = True)
+    source="path/to/audio.mp3",
+    organization_name="your_organization_name",
+    request=request_object,
+    auto_poll=True
+)
 
-# The output property of the InferenceEndpointJob is a either a TranscriptionJobFileOutput 
-# or a TranscriptionJobOutput. You can print it to examine job results.
+# Print the transcription job output
 print(result.output)
 ```
 
@@ -97,13 +161,28 @@ from salad_cloud_transcription import SaladCloudTranscriptionSdk
 # Initialize the SDK
 sdk = SaladCloudTranscriptionSdk(api_key="your_api_key")
 
+# Setup the request
+request_object = TranscriptionRequest(
+    options=TranscriptionJobInput(
+        language_code="en",
+        return_as_file=False,
+        sentence_level_timestamps=True,
+        word_level_timestamps=True,
+        diarization=True,
+        srt=True
+    ),
+    metadata={"project": "example_project"}
+)
+
 # Start a transcription job. auto_poll = False
-job = sdk.transcription_client.start_transcription_job(
-    source = "path/to/audio.mp3")
+job = sdk.transcription_client.transcribe(
+    source = "path/to/audio.mp3",
+    request = request_object,
+    auto_poll = False)
 
 # Poll for the job status
 while True:
-    job = self._get_transcription_job_internal(organization_name, job.id_)
+    job = self.get_transcription_job(organization_name, job.id_)
     if job.status in [
         Status.SUCCEEDED.value,
         Status.FAILED.value,
@@ -118,17 +197,31 @@ if job.status == Status.SUCCEEDED.value:
 
 ### Start a Transcription Job and Get Updates via a Webhook
 
-First, initialize a transcription job.
-
 ```python
 from salad_cloud_transcription import SaladCloudTranscriptionSdk
+from salad_cloud_transcription_sdk.models.transcription_request import TranscriptionRequest
+from salad_cloud_transcription_sdk.models.transcription_job_input import TranscriptionJobInput
 
 # Initialize the SDK
 sdk = SaladCloudTranscriptionSdk(api_key="your_api_key")
 
+# Setup the request
+request_object = TranscriptionRequest(
+    options=TranscriptionJobInput(
+        language_code="en",
+        return_as_file=False,
+        sentence_level_timestamps=True,
+        word_level_timestamps=True,
+        diarization=True,
+        srt=True
+    ),
+    metadata={"project": "example_project"}
+)
+
 # Start a transcription job with a webhook URL
-job = sdk.transcription_client.start_transcription_job(
-    source = "path/to/audio.mp3",
+job = sdk.transcription_client.transcribe(
+    source="path/to/audio.mp3",
+    request=request_object,
     webhook_url="https://your-webhook-endpoint.com"
 )
 

src/salad_cloud_transcription_sdk/models/transcription_engine.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class TranscriptionEngine(Enum):
+    """
+    Enum representing the different transcription engine options.
+
+    Options:
+        - Full: Full transcription engine which supports all features
+        - Lite: Lightweight transcription engine with less features, aimed at being faster
+    """
+
+    Full = "full"
+    Lite = "lite"

src/salad_cloud_transcription_sdk/models/transcription_job_output.py

@@ -112,18 +112,20 @@ class TranscriptionJobOutput(BaseModel):
     :type sentence_level_timestamps: List[SentenceTimestamp]
     :param srt_content: SRT formatted content for subtitles
     :type srt_content: str
-    :param summary: Summary of the transcription content
-    :type summary: str
-    :param llm_translation: Translations of the transcription in different languages
-    :type llm_translation: Dict[str, str]
-    :param srt_translation: Translations of the SRT content in different languages
-    :type srt_translation: Dict[str, str]
     :param duration_in_seconds: Duration of the audio in seconds
     :type duration_in_seconds: float
-    :param duration: Duration in hours (optional)
-    :type duration: float
     :param processing_time: Processing time in seconds
     :type processing_time: float
+    :param summary: Summary of the transcription content (optional)
+    :type summary: Optional[str]
+    :param llm_translation: Translations of the transcription in different languages (optional)
+    :type llm_translation: Optional[Dict[str, str]]
+    :param srt_translation: Translations of the SRT content in different languages (optional)
+    :type srt_translation: Optional[Dict[str, str]]
+    :param duration: Duration in hours (optional)
+    :type duration: Optional[float]
+    :param overall_processing_time: Overall processing time in seconds (optional)
+    :type overall_processing_time: Optional[float]
     """
 
     def __init__(
@@ -132,12 +134,13 @@ def __init__(
         word_segments: List[Dict[str, Any]],
         sentence_level_timestamps: List[Dict[str, Any]],
         srt_content: str,
-        summary: str,
-        llm_translation: Dict[str, str],
-        srt_translation: Dict[str, str],
         duration_in_seconds: float,
-        duration: float,
         processing_time: float,
+        summary: Optional[str] = None,  # optional in Lite
+        llm_translation: Optional[Dict[str, str]] = None,  # optional in Lite
+        srt_translation: Optional[Dict[str, str]] = None,  # optional in Lite
+        duration: Optional[float] = None,  # optional in Lite
+        overall_processing_time: Optional[float] = None,  # optional in Lite
         **kwargs,
     ):
         self.text = self._define_str("text", text)
@@ -146,14 +149,19 @@ def __init__(
             SentenceTimestamp(**sentence) for sentence in sentence_level_timestamps
         ]
         self.srt_content = self._define_str("srt_content", srt_content)
-        self.summary = self._define_str("summary", summary)
+        self.summary = summary
         self.llm_translation = llm_translation
         self.srt_translation = srt_translation
         self.duration_in_seconds = self._define_number(
             "duration_in_seconds", duration_in_seconds
         )
-        self.duration = self._define_number("duration", duration)
+        self.duration = self._define_number("duration", duration) if duration else None
         self.processing_time = self._define_number("processing_time", processing_time)
+        self.overall_processing_time = (
+            self._define_number("overall_processing_time", overall_processing_time)
+            if overall_processing_time
+            else None
+        )
         self._kwargs = kwargs
 
     def to_dict(self) -> Dict[str, Any]:
@@ -162,21 +170,31 @@ def to_dict(self) -> Dict[str, Any]:
         :return: Dictionary representation of this instance
         :rtype: Dict[str, Any]
         """
-        return {
+        result = {
             "text": self.text,
             "word_segments": [segment.to_dict() for segment in self.word_segments],
             "sentence_level_timestamps": [
                 sentence.to_dict() for sentence in self.sentence_level_timestamps
             ],
             "srt_content": self.srt_content,
-            "summary": self.summary,
-            "llm_translation": self.llm_translation,
-            "srt_translation": self.srt_translation,
             "duration_in_seconds": self.duration_in_seconds,
-            "duration": self.duration,
             "processing_time": self.processing_time,
         }
 
+        # Add optional fields if they exist
+        if self.summary is not None:
+            result["summary"] = self.summary
+        if self.llm_translation is not None:
+            result["llm_translation"] = self.llm_translation
+        if self.srt_translation is not None:
+            result["srt_translation"] = self.srt_translation
+        if self.duration is not None:
+            result["duration"] = self.duration
+        if self.overall_processing_time is not None:
+            result["overall_processing_time"] = self.overall_processing_time
+
+        return result
+
     @classmethod
     def from_json(
         cls, json_data: Union[str, bytes, Dict[str, Any]]

src/salad_cloud_transcription_sdk/net/environment/environment.py

@@ -5,7 +5,8 @@
 from enum import Enum
 from urllib.parse import urlparse
 
-TRANSCRIPTION_ENDPOINT_NAME = "transcribe"
+FULL_TRANSCRIPTION_ENDPOINT_NAME = "transcribe"
+LITE_TRANSCRIPTION_ENDPOINT_NAME = "transcription-lite"
 
 
 class Environment(Enum):