feat: v0.0.1 functional

.env.dist

@@ -1,11 +1,18 @@
 #ODTP COMPONENT VARIABLES
-VARIABLES=
+HF_TOKEN=
+MODEL=
+TASK=
+LANGUAGE=
+INPUT_FILE=
+OUTPUT_FILE=
+
 # ODTP ENV VARIABLES TO CONNECT
 ODTP_MONGO_SERVER=
 ODTP_S3_SERVER=
 ODTP_BUCKET_NAME=
 ODTP_ACCESS_KEY=
 ODTP_SECRET_KEY=
+
 # ODTP ENV VARIABLES DB REFERENCES
 ODTP_USER_ID=
 ODTP_DIGITAL_TWIN=

.gitignore

@@ -1,3 +1,7 @@
+# ODTP dev
+odtp-input
+odtp-output
+
 # Mac crap
 .DS_Store
 

Dockerfile

@@ -1,31 +1,8 @@
-FROM ubuntu:22.04
+FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
 
-RUN apt update
-RUN apt install python3.10 python3-pip -y 
+RUN apt-get update && apt-get install -y apt-utils
 
-##################################################
-# Ubuntu setup
-##################################################
-
-RUN  apt-get update \
-  && apt-get install -y wget \
-  && rm -rf /var/lib/apt/lists/*
-
-RUN apt-get update && apt-get -y upgrade \
-  && apt-get install -y --no-install-recommends \
-    unzip \
-    nano \
-    git \ 
-    g++ \
-    gcc \
-    htop \
-    zip \
-    ca-certificates \
-    && rm -rf /var/lib/apt/lists/*
-
-##################################################
-# ODTP setup
-##################################################
+RUN apt-get install -y python3.11 python3.11-venv python3-pip
 
 COPY odtp-component-client/requirements.txt /tmp/odtp.requirements.txt
 RUN pip install -r /tmp/odtp.requirements.txt
@@ -39,6 +16,17 @@ RUN pip install -r /tmp/odtp.requirements.txt
 COPY requirements.txt /tmp/requirements.txt
 RUN pip install -r /tmp/requirements.txt
 
+# Dependencies
+
+RUN apt-get update && \
+    apt-get install -y zip git && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# ffmpeg
+COPY --link --from=mwader/static-ffmpeg:6.1.1 /ffmpeg /usr/local/bin/
+COPY --link --from=mwader/static-ffmpeg:6.1.1 /ffprobe /usr/local/bin/
+
 
 ######################################################################
 # ODTP COMPONENT CONFIGURATION. 
@@ -70,4 +58,12 @@ COPY ./odtp-component-client /odtp/odtp-component-client
 COPY ./app /odtp/odtp-app
 WORKDIR /odtp
 
+##################################################
+# Fix for end of the line issue on Windows
+##################################################
+
+RUN sed -i 's/\r$//' /odtp/odtp-component-client/odtp-app.sh
+RUN sed -i 's/\r$//' /odtp/odtp-component-client/startup.sh
+RUN sed -i 's/\r$//' /odtp/odtp-app/app.sh
+
 ENTRYPOINT ["bash", "/odtp/odtp-component-client/startup.sh"]

README.md

@@ -1,276 +1,149 @@
-# ODTP Component Template
+# Name of the component
 
-This is a template that facilitates the development of new `odtp-components`. An `odtp` compatible component is a docker container able to perform a functional unit of computing in the digital twin. You can think of it as a blackbox that takes inputs files and/or parameters and perfom a task. Usually this lead to some files as a result (Ephemeral component), or to a visualization (Interactive component).
-
-Internally a component will run a bash script `./app/app.sh` that must include the commands for running your tool, and managing the input/output logic. While input files are located in the folder `/odtp/odtp-input`, parameters values are represented by environment variables within the component. In this way you can access to them by using `$` before the name of your variable. Finally, the output files generated are requested to be placed in `/odtp/odtp-output/`.
-
-## How to clone this repository? 
+Add here your badges:
+[![Launch in your ODTP](https://img.shields.io/badge/Launch%20in%20your-ODTP-blue?logo=launch)](http://localhost:8501/launch-component)
+[![Compatible with ODTP v0.5.x](https://img.shields.io/badge/Compatible%20with-ODTP%20v0.5.0-green)]("")
 
 > [!NOTE]  
 > This repository makes use of submodules. Therefore, when cloning it you need to include them.
 >  
-> `git clone --recurse-submodules https://github.com/odtp-org/odtp-component-template`
-
-
-## How to create an odtp compatible component using this template?
-
-1. Identify which parameters would you like to expose.
-2. Configure the Dockerfile to install all the OS requirements needed for your tool to run. 
-    1. (Optional) If your tool requires python, and the dependencies offered in the repo are not compatible with the docker image you can configure custom dependencies in requirements.txt
-3. Configure the `app/app.sh` file to:
-    1. Clone the repository of your tool and checkout to one specific commit. 
-    2. (Optional) If your app uses a config file (i.e. `config.yml` or `config.json`), you need to provide a templace including placeholders for the variables you would like to expose. Placeholders can be defined by using double curly braces wrapping the name of the variable, such as `{{VARIABLE}}`. Then you can run `python3 /odtp/odtp-component-client/parameters.py PATH_TO_TEMPLATE PATH_TO_OUTPUT_CONFIG_FILE` and every placeholder will be replaced by the value in the environment variable.
-    3. Copy (`cp -r`) or create symbolic links (`ln -s`) to locate the input files in `/odpt/odtp-input/` in the folder. 
-    4. Run the tool. You can access to the parameters as environemnt variables (i.e. `$PARAMETER_A`)
-    5. Manage the output exporting. At the end of the component execution all generated output should be located in `/odtp/odtp-output`. Copy all output files into this folder. 
-4. Describe all the metadata in `odtp.yml`. Please check below for instructions.
-5. Publish your tool in the ODTP Zoo. (Temporaly unavailable)
+> `git clone --recurse-submodules https://github.com/sdsc-ordes/odtp-pyannote-whisper`
+
+This pipeline processes a `.wav` audio file by detecting the number of speakers present in the recording using `pyannote.audio`. For each detected speaker segment, it employs `OpenAI's Whisper model` to transcribe or translate the speech individually. This approach ensures accurate and speaker-specific transcriptions or translations, providing a clear understanding of who said what throughout the audio.
+
+Note: This application utilizes `pyannote.audio` and OpenAI's Whisper model. You must accept the terms of use on Hugging Face for the `pyannote/segmentation` and `pyannote/speaker-diarization` models before using this application.
+
+## Table of Contents
+
+- [Tools Information](#tools-information)
+- [How to add this component to your ODTP instance](#how-to-add-this-component-to-your-odtp-instance)
+- [Data sheet](#data-sheet)
+    - [Parameters](#parameters)
+    - [Secrets](#secrets)
+    - [Input Files](#input-files)
+    - [Output Files](#output-files)
+- [Tutorial](#tutorial)
+    - [How to run this component as docker](#how-to-run-this-component-as-docker)
+    - [Development Mode](#development-mode)
+    - [Running with GPU](#running-with-gpu)
+    - [Running in API Mode](#running-in-api-mode)
+- [Credits and References](#credits-and-references)
+
+## Tools Information
+
+| Tool | Semantic Versioning | Commit | Documentation |
+| --- | --- | --- | --- |
+| Tool                                            | Version    | Commit Hash | Documentation                                                      |
+|-------------------------------------------------|------------|-------------|--------------------------------------------------------------------|
+| [OpenAI Whisper](https://github.com/openai/whisper)          | Latest     | [Commit History](https://github.com/openai/whisper/commits/main) | [Whisper Documentation](https://github.com/openai/whisper#readme)  |
+| [pyannote.audio](https://github.com/pyannote/pyannote-audio)  | Latest     | [Commit History](https://github.com/pyannote/pyannote-audio/commits/master) | [pyannote.audio Documentation](https://pyannote.github.io/pyannote-audio/) |
+
+## How to add this component to your ODTP instance
+
+In order to add this component to your ODTP CLI, you can use. If you want to use the component directly, please refer to the docker section. 
+
+``` bash
+odtp new odtp-component-entry \
+--name odtp-pyannote-whisper \
+--component-version v0.0.1 \
+--repository https://github.com/sdsc-ordes/odtp-pyannote-whisper 
+```
 
-### Semantic Validation
+## Data sheet
 
-ODTP will be able to validate the input/output files. In order to do this we use SHACL validation. However, the developer should provide a schema of the input/output schema. This section is still under development and it will be available soon. 
+### Parameters
 
-## Internal data structure of a component
+| Parameter    | Description                                            | Type   | Required | Default Value | Possible Values                                                   | Constraints                        |
+|--------------|--------------------------------------------------------|--------|----------|---------------|-------------------------------------------------------------------|------------------------------------|
+| `MODEL`      | Whisper model to use for transcription or translation  | String | Yes      | `large-v3`    | `tiny`, `base`, `small`, `medium`, `large`, `large-v2`, `large-v3` | Must be a valid Whisper model name |
+| `TASK`       | Task to perform on the audio input                     | String | Yes      | `transcribe`  | `transcribe`, `translate`                                         | Must be `transcribe` or `translate` |
+| `LANGUAGE`   | Source language code for the audio input               | String | No       | `auto`        | `auto`, `en`, `es`, `fr`, `de`, `it`, `pt`, `nl`, `ja`, `zh`, `ru` | Must be a supported language code  |
+| `INPUT_FILE` | Path to the input `.wav` audio file                    | String | Yes      | N/A           | Any valid file path to a `.wav` file                              | File must exist and be accessible  |
+| `OUTPUT_FILE`| Base name for the output files (without extension)     | String | Yes      | `output`      | Any valid file name                                               | Should not contain invalid characters |
 
-It's important to remark that when the container is built an specific folder structure is generated:
+### Secrets
 
-- `/odtp`: The main folder.
-- `/odtp/odtp-component-client`: This is the odtp client that will manage the execution, logging, and input/output functions of the component. It is include as a submodule, and the user doesn't need to modify it.
-- `/odtp/odtp-app`: This folder have the content of `/app` folder in this template. It contains the tool execution bash script and the tool configuration files. 
-- `/odtp/odtp-workdir`: This is the working directory where the tool repository should be placed and all the middle files such as cache folders.
-- `/odtp/odtp-input`: Input folder that is be mounted as volume for the docker container.
-- `/odtp/odtp-output`: Output folder that is mounted as volume for the docker container.
-- `/odtp/odtp-logs`: Folder reserved for internal loggings. 
-- `/odtp/odtp-config`: Folder reserved for odtp configuration. 
+| Secret Name | Description                             | Type   | Required | Default Value | Constraints    | Notes                                                         |
+|-------------|-----------------------------------------|--------|----------|---------------|----------------|---------------------------------------------------------------|
+| HF_TOKEN    | Hugging Face API token for model access | String | Yes      | None          | Valid API Token | Obtain from your Hugging Face account settings   |
 
-## Testing the component
+### Input Files
 
-There are 3 main ways in which you can test a component and the different odtp features. 
+| File/Folder     | Description                       | File Type | Required | Format      | Notes                                            |
+|-----------------|-----------------------------------|-----------|----------|-------------|--------------------------------------------------|
+| `INPUT_FILE`    | Input audio file for processing   | `.wav`    | Yes      | WAV format  | Path specified by `INPUT_FILE` parameter         |
 
-1. Testing it as a docker container
-2. Testing it as a single component using `odtp`
-3. Testing it in a `odtp` digital twin execution
+### Output Files
 
-When developing we recomend to start by testing the component via docker and then follow with the others.  
+| File/Folder          | Description                          | File Type | Contents                     | Usage                                            |
+|----------------------|--------------------------------------|-----------|------------------------------|--------------------------------------------------|
+| `OUTPUT_FILE.srt`    | Transcribed subtitles in SRT format  | `.srt`    | Transcribed text with timings | Use with video players to display subtitles      |
+| `OUTPUT_FILE.json`   | Transcription data in JSON format    | `.json`   | Detailed transcription data   | For programmatic access and data analysis        |
 
-### Testing the component as a docker container
+## Tutorial
 
-The user will need to manually create the input/output folders and build the docker image.
+### How to run this component as docker
 
-1. Prepare the following folder structure:
+Build the dockerfile.
 
-```
-- testing-folder
-    - data-input
-    - data-output
+``` bash
+docker build -t odtp-pyannote-whisper .
 ```
 
-Place all required input files in `testing-folder/data-input`.
+Run the following command. Mount the correct volumes for input/output/logs folders.
 
-2. Create your `.env` file with the following parameters.
-
-```
-# ODTP COMPONENT VARIABLES
-PARAMETER-A=.....
-PARAMETER-B=.....
+``` bash
+docker run -it --rm \
+-v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-input \
+-v {PATH_TO_YOUR_OUTPUT_VOLUME}:/odtp/odtp-output \
+-v {PATH_TO_YOUR_LOGS_VOLUME}:/odtp/odtp-logs \
+--env-file .env odtp-pyannote-whisper
 ```
 
-3. Build the dockerfile. 
+### Development Mode
 
-```
-docker build -t odtp-component .
-```
+To run the component in development mode, mount the app folder inside the container:
 
-4. Run the following command.
-
-```
-docker run -it --rm \ 
+``` bash
+docker run -it --rm \
 -v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-input \
--v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-output \
---env-file .env \
-odtp-component
-```
-
-This command will run the component. If you want debug some errors and execute the docker in an interactive manner, you can use the flag `--entrypoint bash` when running docker.
-
-Also if your tool is interactive such as an Streamlit app, don't forget to map the ports by using `-p XXXX:XXXX`. 
-
-### Testing the component as part of odtp
-
-To execute the command as part of `odtp` please refer to our `odtp` documentation: 
-
-https://odtp-org.github.io/odtp-manuals/
-
-## `odtp.yml`
-
-ODTP requires a set of metadata to work. These fields should be filled by the developers.
-
-```yml
-# This file should contain basic component information for your component.
-component-name: Component Name
-component-author: Component Author
-component-version: Component Version
-component-repository: Component Repository
-component-license: Component License
-component-type: ephemeral or interactive
-component-description: Description
-tags:
-  - tag1
-  - tag2
-
-# Information about the tools
-tools:
-  - tool-name: tool's name
-    tool-author: Tool's author
-    tool-version: Tool version
-    tool-repository: Tool's repository
-    tool-license: Tool's license
-
-# If your tool require some secrets token to be passed as ENV to the component
-# This won't be traced
-secrets:
-  - name: Key of the argument
-  - description: Description of the secret
-
-# If the tool requires some building arguments such as Matlab license
-build-args:
-  - name: Key of the argument
-  - description: Descriptio of the building argument
-  - secret: Bool
-
-# If applicable, ports exposed by the component
-# Include Name, Description, and Port Value for each port
-ports:
-  - name: PORT A
-    description: Description of Port A
-    port-value: XXXX
-  - name: PORT B
-    description: Description of Port B
-    port-value: YYYY
-
-# If applicable, parameters exposed by the component
-# Datatype can be str, int, float, or bool.
-parameters:
-  - name: PARAMETER A
-    default-value: DEFAULT_VALUE_A
-    datatype: DATATYPE_A
-    description: Description of Parameter A
-    parameter-bounds: # Boundaries for int and float datatype
-      - 0 # Lower bound
-      - inf # Upper bound
-    options: null
-    allow-custom-value: false # If true the user can add a custom value out of parameter-bounds, or options
-
-  - name: PARAMETER B
-    default-value: DEFAULT_VALUE_B
-    datatype: DATATYPE_B
-    description: Description of Parameter B
-    parameter-bounds: null
-    options: # If your string parameter is limited to a few option, please list them here. 
-      - OptionA
-      - OptionB
-      - OptionC
-    allow-custom-value: false # If true the user can add a custom value out of parameter-bounds, or options
-
-# If applicable, data-input list required by the component
-data-inputs:
-  - name: INPUT A
-    type: TYPE_A # Folder or filetype
-    path: VALUE_A  
-    description: Description of Input A
-  - name: INPUT B
-    type: TYPE_B # Folder or filetype
-    path: VALUE_B  
-    description: Description of Input B
-
-# If applicable, data-output list produced by the component
-data-output:
-  - name: OUTPUT A
-    type: TYPE_A # Folder or filetype
-    path: VALUE_A
-    description: Description of Output A
-  - name: OUTPUT B
-    type: TYPE_B # Folder or filetype
-    path: VALUE_B
-    description: Description of Output B
-
-# If applicable, path to schemas to perform semantic validation.
-# Still under development. Ignore.
-schema-input: PATH_TO_INPUT_SCHEMA
-schema-output: PATH_TO_OUTPUT_SCHEMA
-
-# If applicable, define devices needed such as GPU.
-devices:
-  gpu: Bool
+-v {PATH_TO_YOUR_OUTPUT_VOLUME}:/odtp/odtp-output \
+-v {PATH_TO_YOUR_LOGS_VOLUME}:/odtp/odtp-logs \
+-v {PATH_TO_YOUR_APP_FOLDER}:/odtp/app \
+--env-file .env odtp-pyannote-whisper
 ```
 
-## Changelog
-
-- v0.4.0
-  - Update default Base and Python in Dockerfile to `ubuntu:22.04` and `python3.10`
+### Running with GPU
 
-- v0.3.4
-  - Inclusion of `secrets` and `build-args` in `odtp.yml`
-  - Tools as list
+To run the component with GPU support, use the following command:
 
-- v0.3.3
-  - Inclusion of boundaries conditions and options in `odtp.yml` parameters.    
-
-- v0.3.2
-  - Extended `odtp.yml` parameters and input/output definition.
-  - `odtp.requirements.txt` transfered to submodule `odtp-component-client`.
-
-- v0.3.1
-  - Updating schema fields in `odtp.yml` to kebab-case.
-
-- v0.3.0
-  - Turning `odtp-client` into a separate repository and adding it as a submodule in `odtp-component-client`
-  - Updating `app.sh` and tutorial.
-  - Updating `odtp.yml` file.
-  - Adding `.DS_Store` to `.gitignore`
-
-- v0.2.0
-  - Compatible with ODTP v.0.2.0 only with platform / components
-  - Compatible with configuration text files
-  - Improved loging system
-  - Accepting Digital Twins, Executions, and steps, metadata.
-  - Including component versioning in `odtp.yml`
-
-- v0.1.0
-  - Compatible with ODTP v.0.1.0 only with platform / components
-  - Compatible with configuration text files
-
-## Acknowledgments, Copyright, and Licensing
-
-### Acknowledgments and Funding
-
-This work is part of the broader project **O**pen **D**igital **T**win **P**latform of the **S**wiss **M**obility **S**ystem (ODTP-SMS) funded by Swissuniversities CHORD grant Track B - Establish Projects. ODTP-SMS project is a joint endeavour by the Center for Sustainable Future Mobility - CSFM (ETH Zürich) and the Swiss Data Science Center - SDSC (EPFL and ETH Zürich). 
-The Swiss Data Science Center (SDSC) develops domain-agnostic standards and containerized components to manage digital twins. This includes the creation of the Core Platform (both back-end and front-end), Service Component Integration Templates, Component Ontology, and the Component Zoo template. 
-The Center for Sustainable Future Mobility (CSFM) develops mobility services and utilizes the components produced by SDSC to deploy a mobility digital twin platform. CSFM focuses on integrating mobility services and collecting available components in the mobility zoo, thereby applying the digital twin concept in the realm of mobility.
- 
-### Copyright
-
-Copyright © 2023-2024 Swiss Data Science Center (SDSC), www.datascience.ch. All rights reserved.
-The SDSC is jointly established and legally represented by the École Polytechnique Fédérale de Lausanne (EPFL) and the Eidgenössische Technische Hochschule Zürich (ETH Zürich). This copyright encompasses all materials, software, documentation, and other content created and developed by the SDSC.
-
-### Intellectual Property (IP) Rights
-
-The Open Digital Twin Platform (ODTP) is the result of a collaborative effort between ETH Zurich (ETHZ) and the École Polytechnique Fédérale de Lausanne (EPFL). Both institutions hold equal intellectual property rights for the ODTP project, reflecting the equitable and shared contributions of EPFL and ETH Zürich in the development and advancement of this initiative.  
- 
-### Licensing
-
-The Service Component Integration Templates within this repository are licensed under the BSD 3-Clause "New" or "Revised" License. This license allows for broad compatibility and standardization, encouraging open use and contribution. For the full license text, please see the LICENSE file accompanying these templates.
+``` bash
+docker run -it --rm \
+--gpus all \
+-v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-input \
+-v {PATH_TO_YOUR_OUTPUT_VOLUME}:/odtp/odtp-output \
+-v {PATH_TO_YOUR_LOGS_VOLUME}:/odtp/odtp-logs \
+--env-file .env odtp-pyannote-whisper
+```
 
-#### Distinct Licensing for Other Components
+### Running in API Mode
 
-- **Core Platform**: Open-source under AGPLv3.
-- **Ontology**: Creative Commons Attribution-ShareAlike (CC BY-SA).
-- **Component Zoo Template**: BSD-3 license.
+To run the component in API mode and expose a port, use the following command:
 
-### Alternative Commercial Licensing
+``` bash
+docker run -it --rm \
+-v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-input \
+-v {PATH_TO_YOUR_OUTPUT_VOLUME}:/odtp/odtp-output \
+-v {PATH_TO_YOUR_LOGS_VOLUME}:/odtp/odtp-logs \
+-p {HOST_PORT}:7860 \
+--env-file .env \
+--entrypoing python3 \
+odtp-pyannote-whisper \
+/odtp/odtp-app/gradio_app.py
+```
 
-Alternative commercial licensing options for the core platform and other components are available and can be negotiated through the EPFL Technology Transfer Office (https://tto.epfl.ch) or ETH Zürich Technology Transfer Office (https://ethz.ch/en/industry/transfer.html).
+## Credits and references
 
-## Ethical Use and Legal Compliance Disclaimer
+SDSC
 
-Please note that this software should not be used to deliberately harm any individual or entity. Users and developers must adhere to ethical guidelines and use the software responsibly and legally. This disclaimer serves to remind all parties involved in the use or development of this software to engage in practices that are ethical, lawful, and in accordance with the intended purpose of the software.
+This component has been created using the `odtp-component-template` `v0.5.0`. 

README.template.md

@@ -1,62 +0,0 @@
-# Name of the component
-
-Description of the component
-
-| Tool Info | Links |
-| --- | --- |
-| Original Tool | []() |
-| Current Tool Version  | [commit-hash](link-to-commit-hash) |
-
-
-## ODTP command 
-
-```
-odtp new odtp-component-entry \
---name odtp-component \
---component-version x.y.z \
---repository Link to repository
-``` 
-
-## Data sheet
-
-### Parameters
-
-| Parameter | Description | Default Value |
-| --- | --- | --- |
-| A | B | C |
-
-### Input Files
-
-| File/Folder | Description |
-| --- | --- | 
-| A | B |
-
-### Output Files
-
-| File/Folder | Description |
-| --- | --- | 
-| A | B |
-
-## Tutorial
-
-### How to run this component as docker
-
-Build the dockerfile 
-
-```
-docker build -t odtp-component .
-```
-
-Run the following command. Mount the correct volumes for input/output folders. 
-
-```
-docker run -it --rm \
--v {PATH_TO_YOUR_INPUT_VOLUME}:/odtp/odtp-input \
--v {PATH_TO_YOUR_OUTPUT_VOLUME}:/odtp/odtp-output \
---env-file .env odtp-component
-```
-
-
-## Developed by
-
-XXXXXXXXXX

app/app.py

@@ -0,0 +1,374 @@
+import os
+import argparse
+from typing import Any, Optional, TextIO, List
+from pyannote.audio import Pipeline, Audio
+import whisper
+from whisper.utils import WriteSRT, WriteVTT
+from whisper import Whisper
+import torch
+from math import ceil, floor
+import soundfile as sf
+import librosa
+import json
+from dataclasses import dataclass, asdict
+from typing import List
+from jsonschema import validate, ValidationError
+
+
+@dataclass
+class Segment:
+    start: float
+    end: float
+    text: str
+    speaker: str
+    language: str
+
+def generate_segments(transcription_data, speaker, language) -> List[Segment]:
+    segments = []
+    for item in transcription_data:
+        segment = Segment(
+            start=item['start'],
+            end=item['end'],
+            text=item['text'],
+            speaker=speaker,
+            language=language
+        )
+        segments.append(segment)
+    return segments
+
+
+schema = {
+    "type": "object",
+    "properties": {
+        "segments": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "start": {"type": "number"},
+                    "end": {"type": "number"},
+                    "text": {"type": "string"},
+                    "speaker": {"type": "string"},
+                    "language": {"type": "string"}
+                },
+                "required": ["start", "end", "text", "speaker", "language"]
+            }
+        }
+    },
+    "required": ["segments"]
+}
+
+def validate_json(json_data: str) -> bool:
+    try:
+        data = json.loads(json_data)
+        validate(instance=data, schema=schema)
+        return True
+    except ValidationError as e:
+        print(f"Validation error: {e}")
+        return False
+
+def diarize_audio(HF_AUTH_TOKEN, AUDIO_FILE):
+    pipeline = Pipeline.from_pretrained(
+        "pyannote/speaker-diarization-3.1",
+        use_auth_token=HF_AUTH_TOKEN)
+    # Send pyannote pipeline to GPU (when available)
+    device: str = ""
+    if torch.cuda.is_available():
+        device = "cuda"
+    else:
+        device = "cpu"
+    pipeline.to(torch.device(device))
+    print(f"Diarize audio on {device}")  
+    io = Audio(mono='downmix', sample_rate=16000)
+    waveform, sample_rate = io(AUDIO_FILE)
+    diarization = pipeline({"waveform": waveform, "sample_rate": sample_rate})
+    return diarization, waveform, sample_rate
+
+class AppendResultsMixin:
+    """Class to return srt or vtt file path and open mode of write or append
+    to allow incremental writing.
+    """
+    first_call: bool = True
+    output_path: str = ''
+    
+    def get_path_and_open_mode(self, *, audio_path: str, dir: str, ext: str) -> tuple[str, str]:
+        mode: str
+        if self.first_call:
+            audio_basename = os.path.basename(audio_path)
+            audio_basename = os.path.splitext(audio_basename)[0]
+            self.output_path: str = os.path.join(dir, audio_basename + "." + ext)
+            self.first_call = False
+            mode = 'w' # open for write initially
+        else:
+            mode = 'a' # open for append after
+        return self.output_path, mode
+
+class WriteSRTIncremental(AppendResultsMixin, WriteSRT):
+    """Incrementally create an SRT file with multiple calls appending new entries
+      to the file.
+    """
+    srt_index: int = 1  # Index for SRT blocks retained across multiple calls
+
+    def __init__(self, output_dir: Optional[str] = None):
+        super().__init__(output_dir=output_dir)
+        self.extension = '.srt'
+        self.srt_index = 1  # Move to instance variable
+
+    def __call__(
+        self,
+        result: dict,
+        audio_path: str,
+        speaker: str,
+        start_base: float,
+        options: Optional[dict] = None,
+        output_path: Optional[str] = None,
+        **kwargs,
+    ):
+        if output_path:
+            path = output_path
+            mode = 'a' if os.path.exists(path) else 'w'
+        else:
+            audio_dir = os.path.dirname(audio_path)
+            output_dir = self.output_dir if self.output_dir else audio_dir
+            audio_basename = os.path.splitext(os.path.basename(audio_path))[0]
+            path = os.path.join(output_dir, f"{audio_basename}{self.extension}")
+            mode = 'a' if os.path.exists(path) else 'w'
+
+        with open(path, mode, encoding="utf-8") as f:
+            self.write_result(result, f, speaker, start_base, options=options, **kwargs)
+
+    def write_result(
+        self,
+        result: dict,
+        file: TextIO,
+        speaker: str,
+        start_base: float,
+        options: Optional[dict] = None,
+        **kwargs,
+    ):
+        for segment in result['segments']:
+            start = self.format_timestamp(segment['start'])
+            end = self.format_timestamp(segment['end'])
+            text = f"[{speaker}]: {segment['text']}"
+            print(f"{self.srt_index}\n{start} --> {end}\n{text}\n", file=file, flush=True)
+            self.srt_index += 1  
+
+class WriteVTTIncremental(AppendResultsMixin, WriteVTT):
+    """Incrementally create a VTT file with multiple calls appending new entries
+      to the file.
+    """
+    def __call__(
+        self,
+        result: dict,
+        audio_path: str,
+        speaker: str,
+        start: float,
+        options: Optional[dict] = None,
+        output_path: Optional[str] = None,
+        **kwargs,
+    ):
+        if output_path:
+            path = output_path
+            mode = 'a' if os.path.exists(path) else 'w'
+        else:
+            path, mode = self.get_path_and_open_mode(
+                audio_path=audio_path,
+                dir=".",
+                ext="vtt"
+            )
+        with open(path, mode, encoding="utf-8") as f:
+            self.write_result(result, file=f, options=options, **kwargs)
+
+    def write_result(
+        self,
+        result: dict,
+        file: TextIO,
+        options: Optional[dict] = None,
+        **kwargs,
+    ):
+        if file.tell() == 0:
+            print("WEBVTT\n", file=file)
+
+        for segment in result['segments']:
+            start = self.format_timestamp(segment['start'])
+            end = self.format_timestamp(segment['end'])
+            text = f"[{segment.get('speaker', 'unknown')}]: {segment['text']}"
+            print(f"{start} --> {end}\n{text}\n", file=file, flush=True)
+
+class SegmentsJSONWriter(AppendResultsMixin):
+    """Incrementally write segments to a JSON file."""
+    def __init__(self, output_dir: Optional[str] = None):
+        self.output_dir = output_dir  # Now optional
+        self.first_call = True
+        self.output_path = ''  # Will store the output file path
+
+    def __call__(
+        self,
+        segments: List[Segment],
+        audio_path: str,
+        output_path: Optional[str] = None,
+    ):
+        if output_path:
+            # Use the provided output path directly
+            path = output_path
+            mode = 'a' if os.path.exists(path) else 'w'
+            self.output_path = path
+        else:
+            if not self.output_path:
+                audio_basename = os.path.splitext(os.path.basename(audio_path))[0]
+                # Use output_dir if provided, else use the directory of audio_path
+                dir = self.output_dir if self.output_dir else os.path.dirname(audio_path)
+                self.output_path = os.path.join(dir, audio_basename + ".json")
+            path = self.output_path
+            mode = 'a' if not self.first_call else 'w'
+
+        with open(path, mode, encoding='utf-8') as f:
+            if self.first_call:
+                # Start the JSON structure
+                f.write('{"segments": [\n')
+            else:
+                f.write(',\n')
+            for idx, segment in enumerate(segments):
+                if idx > 0:
+                    f.write(',\n')
+                json.dump(asdict(segment), f, ensure_ascii=False, indent=2)
+            self.first_call = False
+
+    def finalize(self):
+        """Call this method after all segments have been written to close the JSON array."""
+        if self.output_path:
+            with open(self.output_path, 'a', encoding='utf-8') as f:
+                f.write('\n  ]\n}\n')
+
+    def close(self):
+        with open(self.output_path, 'a', encoding='utf-8') as f:
+            f.write('\n]}\n')
+
+class WhisperFacade:
+    wmodel: Whisper
+
+    def __init__(self, model:str, *, quantize=False) -> None:
+        """Load the Whisper model and optionally quantize."""
+        print("Initialize whisper")
+        whisper_model = whisper.load_model(model)
+        if quantize:
+            print("Quantize")
+            DTYPE = torch.qint8
+            qmodel: Whisper = torch.quantization.quantize_dynamic(
+                        whisper_model, {torch.nn.Linear}, dtype=DTYPE)
+            del whisper_model
+            self.wmodel = qmodel
+        else:
+            self.wmodel = whisper_model
+
+    def _set_timing_for(self, segment: dict[str, float],  # simplified typing
+                        offset: float) -> None:
+        """For speech fragments in different parts of an audio file, patch the 
+        whisper segment and word timing using the offset (typically the diarization offset)
+        in seconds. This makes the timing accurate for subtitles when multiple 
+        calls to whisper are used for various parts of the audio.
+        """
+        s = segment
+        s['start'] += offset 
+        s['end']   += offset
+        # Update word start/stop times, if present
+        if 'words' in s:
+            w: dict[str, float] # simplified typing
+            for w in s['words']: # type: ignore
+                w['start'] += offset
+                w['end'] += offset
+
+    def load_audio(self, file_path: str):
+        self.audio = whisper.load_audio(file_path)
+    
+    def transcribe(self, *, start: float, end: float, options: dict[str, Any] ) -> dict[str, Any]:
+        """Transcribe from start time to end time (both in seconds)."""
+        SAMPLE_RATE = 16_000 # 16kHz audio
+        start_index = floor(start * SAMPLE_RATE)
+        end_index = ceil(end * SAMPLE_RATE)
+        audio_segment = self.audio[start_index:end_index]
+        result = whisper.transcribe(self.wmodel, audio_segment, **options)
+        #
+        segments = result['segments']
+        s: dict[str, float] # simplified typing
+        for s in segments: # type: ignore
+            self._set_timing_for(segment=s, offset=start)
+        return result
+
+def clip_audio(audio_file_path, sample_rate, start, end, output_path):
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    # Load the audio file
+    waveform, sr = librosa.load(audio_file_path, sr=sample_rate, mono=True)
+    
+    # Calculate start and end samples
+    start_sample = int(start * sr)
+    end_sample = int(end * sr)
+    
+    # Write the audio segment to the output path
+    sf.write(output_path, waveform[start_sample:end_sample], sr, format='WAV')
+
+def main(args):
+    diarization, _, sample_rate = diarize_audio(args.hf_token, args.input_file)
+    model = WhisperFacade(model=args.model, quantize=args.quantize)
+    model.load_audio(args.input_file)
+    #
+    writer = WriteSRTIncremental() 
+    writer_json = SegmentsJSONWriter()
+    whisper_options = {"verbose": None, "word_timestamps": False, 
+                       "task": args.task, "suppress_tokens": ""}
+    if args.language:
+        whisper_options["language"] = args.language
+    writer_options = {"max_line_width":55, "max_line_count":2, "word_timestamps": False}
+    print("Process diarized blocks")
+    
+    # Group consecutive segments of the same speaker
+    grouped_segments = []
+    current_speaker = None
+    current_start = None
+    current_end = None
+
+    for turn, _, speaker in diarization.itertracks(yield_label=True):
+        print(speaker)
+        if turn.end - turn.start < 0.5:  # Suppress short utterances (pyannote artifact)
+            print(f"start={turn.start:.1f}s stop={turn.end:.1f}s IGNORED")
+            continue
+
+        if speaker == current_speaker:
+            current_end = turn.end
+        else:
+            if current_speaker is not None:
+                grouped_segments.append((current_start, current_end, current_speaker))
+            current_speaker = speaker
+            current_start = turn.start
+            current_end = turn.end
+
+    # Append the last segment
+    if current_speaker is not None:
+        grouped_segments.append((current_start, current_end, current_speaker))
+
+    # Process each grouped segment
+    for start, end, speaker in grouped_segments:
+        clip_path = f"/tmp/speaker_{speaker}_start_{start:.1f}_end_{end:.1f}.wav"
+        clip_audio(args.input_file, sample_rate, start, end, clip_path)
+        result = model.transcribe(start=start, end=end, options=whisper_options)
+        language = result['language']
+        print(f"start={start:.1f}s stop={end:.1f}s lang={language} {speaker}")
+        writer(result, args.output_file, speaker, start, writer_options)
+        writer_json(generate_segments(result['segments'],  speaker, language), args.output_json_file)
+    writer_json.finalize()
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Diarization and Whisper Transcription CLI")
+    parser.add_argument('--model', type=str, required=True, help="Whisper model to use")
+    parser.add_argument('--quantize', action='store_true', help="Whether to quantize the model")
+    parser.add_argument('--hf-token', type=str, required=True, help="Hugging Face authentication token")
+    parser.add_argument('--task', type=str, choices=['transcribe', 'translate'], required=True, help="Task to perform")
+    parser.add_argument('--language', type=str, required=False, help="Language to use for transcription or translation")
+    parser.add_argument('--input-file', type=str, required=True, help="Input audio file")
+    parser.add_argument('--output-file', type=str, required=True, help="Output file for the results (SRT or VTT)")
+    parser.add_argument('--output-json-file', type=str, required=True, help="Output file for the results (SRT or VTT)")
+
+    args = parser.parse_args()
+    main(args)

app/app.sh

@@ -32,7 +32,11 @@
 # While the output is managed by ODTP and placed in /odtp/odtp-output/
 #########################################################
 
-# COMMAND $PARAMETER_A #PARAMETER_B /odtp/odtp-input/data
+if [ -n "$LANGUAGE" ]; then
+    python3 /odtp/odtp-app/app.py --model $MODEL --quantize --hf-token $HF_TOKEN --task $TASK --language $LANGUAGE --input-file /odtp/odtp-input/$INPUT_FILE --output-file /odtp/odtp-output/$OUTPUT_FILE.translate.srt --output-json-file /odtp/odtp-output/$OUTPUT_FILE.translate.json
+else
+    python3 /odtp/odtp-app/app.py --model $MODEL --quantize --hf-token $HF_TOKEN --task $TASK --input-file /odtp/odtp-input/$INPUT_FILE --output-file /odtp/odtp-output/$OUTPUT_FILE.srt --output-json-file /odtp/odtp-output/$OUTPUT_FILE.json 
+fi
 
 #########################################################
 # 5. OUTPUT FOLDER MANAGEMENT

app/config_templates/template.yml

@@ -1,3 +0,0 @@
-# Use the variable name between squared brackets to replace values in the template. 
-constant_string: /odtp/odtp-workdir/cache
-value_to_replace: [variable_key]

app/gradio_app.py

@@ -0,0 +1,135 @@
+import gradio as gr
+import tempfile
+import os
+import shutil
+import subprocess
+from pathlib import Path
+import io
+
+def create_temp_structure():
+    """Create temporary ODTP folder structure"""
+    temp_dir = tempfile.mkdtemp(prefix="odtp_")
+    os.makedirs(os.path.join(temp_dir, "odtp-input"))
+    os.makedirs(os.path.join(temp_dir, "odtp-output"))
+    return temp_dir
+
+def cleanup_temp(temp_dir):
+    """Remove temporary folder structure"""
+    shutil.rmtree(temp_dir)
+
+def process_audio(audio_file, model, task, language, hf_token):
+    """Process audio file with Whisper and Pyannote"""
+    # Create temp structure
+    temp_dir = create_temp_structure()
+    
+    try:
+        # Copy input file
+        input_path = os.path.join(temp_dir, "odtp-input", "input.wav")
+        shutil.copy2(audio_file, input_path)
+        
+        # Prepare output paths
+        output_base = "output"
+        output_srt = os.path.join(temp_dir, "odtp-output", 
+            f"{output_base}.{'translate.' if task == 'translate' else ''}srt")
+        output_json = os.path.join(temp_dir, "odtp-output",
+            f"{output_base}.{'translate.' if task == 'translate' else ''}json")
+        
+        # Build command
+        cmd = [
+            "python3", "/odtp/odtp-app/app.py",
+            "--model", model,
+            "--quantize",
+            "--hf-token", hf_token,
+            "--task", task,
+            "--input-file", input_path,
+            "--output-file", output_srt,
+            "--output-json-file", output_json
+        ]
+        
+        if language != "auto":
+            cmd.extend(["--language", language])
+            
+        # Run transcription
+        subprocess.run(cmd, check=True)
+        
+        # Read results
+        with open(output_srt, 'r', encoding='utf-8') as f:
+            srt_content = f.read()
+        with open(output_json, 'r', encoding='utf-8') as f:
+            json_content = f.read()
+        
+        # Create BytesIO objects for downloads
+        srt_bytes = io.BytesIO(srt_content.encode('utf-8'))
+        srt_bytes.name = "output.srt"
+        json_bytes = io.BytesIO(json_content.encode('utf-8'))
+        json_bytes.name = "output.json"
+        
+        # Return contents and BytesIO objects
+        return srt_content, json_content, srt_bytes, json_bytes
+        
+    finally:
+        # Cleanup
+        cleanup_temp(temp_dir)
+
+# Define Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Audio Transcription/Translation with Speaker Diarization")
+    
+    with gr.Row():
+        with gr.Column():
+            audio_input = gr.Audio(
+                type="filepath",
+                label="Upload Audio File (WAV format)"
+            )
+            model = gr.Dropdown(
+                choices=["tiny", "base", "small", "medium", "large", "large-v2"],
+                value="base",
+                label="Whisper Model"
+            )
+            task = gr.Dropdown(
+                choices=["transcribe", "translate"],
+                value="transcribe",
+                label="Task"
+            )
+            language = gr.Dropdown(
+                choices=["auto", "en", "es", "fr", "de", "it", "pt", "nl", "ja", "zh", "ru"],
+                value="auto",
+                label="Source Language"
+            )
+            hf_token = gr.Textbox(
+                label="Hugging Face Token",
+                type="password"
+            )
+            submit_btn = gr.Button("Process Audio")
+            
+        with gr.Column():
+            srt_output = gr.Textbox(
+                label="SRT Output",
+                lines=10
+            )
+            json_output = gr.Textbox(
+                label="JSON Output",
+                lines=10
+            )
+            # Add download buttons
+            srt_download = gr.File(
+                label="Download SRT File"
+            )
+            json_download = gr.File(
+                label="Download JSON File"
+            )
+    
+    submit_btn.click(
+        fn=process_audio,
+        inputs=[audio_input, model, task, language, hf_token],
+        outputs=[srt_output, json_output, srt_download, json_download]
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",  # More secure default for development
+        server_port=7860,         # Default Gradio port
+        share=False,              # Disable temporary public URL
+        show_error=True,          # Show detailed error messages
+        debug=True               # Enable debug mode for development
+    )

odtp.yml

@@ -1,95 +1,133 @@
-# This file should contain basic component information for your component.
-component-name: Component Name
-component-author: Component Author
-component-version: Component Version
-component-repository: Component Repository
-component-license: Component License
-component-type: ephemeral or interactive
-component-description: Description
+# Schema version for tracking updates to the schema format
+schema-version: "v0.5.0"
+
+# Component Information
+component-name: odtp-pyannote-whisper
+component-version: "v0.0.1"
+component-license: AGPL 3.0
+component-type: ephemeral
+component-description: Transcribe or translate audio files using Whisper and Pyannote for speaker diarization
+component-authors:
+  - name: Carlos Vivar Rios
+    orcid: null
+component-repository:
+  url: "https://github.com/odtp-org/odtp-pyannote-whisper"
+  doi: null
+component-docker-image: null
 tags:
-  - tag1
-  - tag2
+  - audio
+  - transcription
+  - translation
+  - whisper
+  - pyannote
 
-# Information about the tools
+# Tool Information
 tools:
-  - tool-name: tool's name
-    tool-author: Tool's author
-    tool-version: Tool version
-    tool-repository: Tool's repository
-    tool-license: Tool's license
+  - tool-name: whisper
+    tool-authors:
+      - name: OpenAI
+        orcid: null
+    tool-version: latest
+    tool-repository:
+      url: "https://github.com/openai/whisper"
+      doi: null
+    tool-license: MIT
+
+  - tool-name: pyannote
+    tool-authors:
+      - name: Hervé Bredin
+        orcid: null
+    tool-version: latest
+    tool-repository:
+      url: "https://github.com/pyannote/pyannote-audio"
+      doi: null
+    tool-license: MIT
 
-# If your tool require some secrets token to be passed as ENV to the component
-# This won't be traced in MongoDB
+# Secrets (ENV variables)
 secrets:
-  - name: Key of the argument
-  - description: Description of the secret
+  - name: HF_TOKEN
+    description: Hugging Face API token for accessing pyannote models
+    type: str
 
-# If the tool requires some building arguments such as Matlab license
-build-args:
-  - name: Key of the argument
-  - description: Descriptio of the building argument
-  - secret: Bool
+# Build Arguments (if any)
+build-args: null
 
-# If applicable, ports exposed by the component
-# Include Name, Description, and Port Value for each port
-ports:
-  - name: PORT A
-    description: Description of Port A
-    port-value: XXXX
-  - name: PORT B
-    description: Description of Port B
-    port-value: YYYY
+# Exposed Ports
+ports: null
 
-# If applicable, parameters exposed by the component
-# Datatype can be str, int, float, or bool.
+# Parameters for the Component
 parameters:
-  - name: PARAMETER A
-    default-value: DEFAULT_VALUE_A
-    datatype: DATATYPE_A
-    description: Description of Parameter A
-    parameter-bounds: # Boundaries for int and float datatype
-      - 0 # Lower bound
-      - inf # Upper bound
-    options: null
-    allow-custom-value: false # If true the user can add a custom value out of parameter-bounds, or options
-  - name: PARAMETER B
-    default-value: DEFAULT_VALUE_B
-    datatype: DATATYPE_B
-    description: Description of Parameter B
+  - name: MODEL
+    default-value: large-v3
+    datatype: str
+    description: Whisper model to use for transcription/translation
+    parameter-bounds: null
+    options:
+      - tiny
+      - base
+      - small
+      - medium
+      - large
+      - large-v2
+      - large-v3
+    allow-custom-value: false
+
+  - name: TASK
+    default-value: transcribe
+    datatype: str
+    description: Task to perform (transcribe or translate)
     parameter-bounds: null
-    options: # If your string parameter is limited to a few option, please list them here. 
-      - OptionA
-      - OptionB
-      - OptionC
-    allow-custom-value: false # If true the user can add a custom value out of parameter-bounds, or options
+    options:
+      - transcribe
+      - translate
+    allow-custom-value: false
 
-# If applicable, data-input list required by the component
+  - name: LANGUAGE
+    default-value: auto
+    datatype: str
+    description: Source language code (use 'auto' for auto-detection)
+    parameter-bounds: null
+    options:
+      - auto
+      - en
+      - es
+      - fr
+      - de
+      - it
+      - pt
+      - nl
+      - ja
+      - zh
+      - ru
+    allow-custom-value: true
+
+# Data Inputs
 data-inputs:
-  - name: INPUT A
-    type: TYPE_A # Folder or filetype
-    path: VALUE_A  
-    description: Description of Input A
-  - name: INPUT B
-    type: TYPE_B # Folder or filetype
-    path: VALUE_B  
-    description: Description of Input B
+  - name: INPUT_FILE
+    type: .wav
+    path: /odtp/odtp-input
+    description: Input audio file in WAV format
+    naming-convention: null
+
+# Data Outputs
+data-outputs:
+  - name: OUTPUT_FILE
+    type: .srt
+    path: /odtp/odtp-output
+    description: Transcription/translation output in SRT format with speaker diarization
+    naming-convention: null
 
-# If applicable, data-output list produced by the component
-data-output:
-  - name: OUTPUT A
-    type: TYPE_A # Folder or filetype
-    path: VALUE_A
-    description: Description of Output A
-  - name: OUTPUT B
-    type: TYPE_B # Folder or filetype
-    path: VALUE_B
-    description: Description of Output B
+  - name: OUTPUT_JSON_FILE
+    type: .json
+    path: /odtp/odtp-output
+    description: Transcription/translation output in JSON format with speaker diarization
+    naming-convention: null
 
-# If applicable, path to schemas to perform semantic validation.
-# Still under development. Ignore.
-schema-input: PATH_TO_INPUT_SCHEMA
-schema-output: PATH_TO_OUTPUT_SCHEMA
+# Validation Schemas (Future Development)
+schema-input: null
+schema-output: null
 
-# If applicable, define devices needed such as GPU.
+# Device Requirements
 devices:
-  gpu: Bool
+  - type: gpu
+    required: true

requirements.txt

@@ -1 +1,9 @@
-# Please list here all python dependencies of your tool
+--extra-index-url https://download.pytorch.org/whl/cu121
+torch
+torchaudio
+openai-whisper
+pyannote.audio
+soundfile
+librosa
+jsonschema
+gradio