Upload 12 files

Dockerfile

@@ -0,0 +1,49 @@
+# Use a PyTorch runtime with CUDA
+FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-runtime
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV TRANSFORMERS_CACHE=/app/models
+ENV HF_HOME=/app/models
+
+# Set the working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    sox \
+    libsndfile1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip and setuptools
+RUN pip install --upgrade pip setuptools
+
+# Copy the requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install specific versions of additional packages
+RUN pip install transformers==4.35.0 sentencepiece
+
+# Copy application code
+COPY . /app
+
+# Generate gRPC code
+#RUN python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. seamless_m4t.proto
+RUN pip install git+https://github.com/huggingface/transformers.git
+# Debug the transformers package and download the model
+#RUN python -c "import transformers; print(transformers.__version__); print(dir(transformers))"
+#RUN python -c "from transformers import AutoProcessor, AutoModel; \
+#    model_name = 'facebook/seamless-m4t-v2-large'; \
+#    AutoProcessor.from_pretrained(model_name); \
+#    AutoModel.from_pretrained(model_name)"
+
+# Expose the port
+EXPOSE 8080
+
+# Command to run
+CMD ["python", "server51.py"]
+
+

cert_config.cnf

@@ -0,0 +1,14 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+CN = reserve.aixblock.io
+
+[v3_req]
+subjectAltName = @alt_names
+
+[alt_names]
+DNS.1 = reserve.aixblock.io
+

h62_client.py

@@ -0,0 +1,114 @@
+import grpc
+import pyaudio
+import wave
+import io
+import threading
+import queue
+import seamless_m4t_pb2
+import seamless_m4t_pb2_grpc
+
+debug = False
+
+def record_audio_to_queue(audio_queue, chunk_duration_s, sample_rate=16000, channels=1):
+    """
+    Captures audio from the sound card and pushes it to a queue in WAV format.
+    """
+    # Initialize PyAudio
+    p = pyaudio.PyAudio()
+    window=8192 #4096
+
+    # Open the audio stream
+    stream = p.open(format=pyaudio.paInt16,
+                    channels=channels,
+                    rate=sample_rate,
+                    input=True,
+                    frames_per_buffer=window)  # Increased buffer size
+
+    if debug:
+        print("Recording audio... Press Ctrl+C to stop.")
+    try:
+        while True:
+            frames = []
+
+            # Record for the specified duration
+            for _ in range(0, int(sample_rate / 1024 * chunk_duration_s)):
+                try:
+                    data = stream.read(window, exception_on_overflow=False)  # Handle overflow
+                    frames.append(data)
+                except OSError as e:
+                    print(f"Audio buffer overflow: {e}")
+                    break
+
+            # Write audio data to WAV format in memory
+            with io.BytesIO() as wav_buffer:
+                with wave.open(wav_buffer, 'wb') as wf:
+                    wf.setnchannels(channels)
+                    wf.setsampwidth(p.get_sample_size(pyaudio.paInt16))
+                    wf.setframerate(sample_rate)
+                    wf.writeframes(b"".join(frames))
+                audio_queue.put(wav_buffer.getvalue())
+
+    except KeyboardInterrupt:
+        print("Stopped recording.")
+    finally:
+        if stream.is_active():
+            stream.stop_stream()
+        stream.close()
+        p.terminate()
+        audio_queue.put(None)  # Signal the end of recording
+
+
+def send_audio_chunks_to_server(audio_queue, server_address, tgt_lang):
+    """
+    Sends audio chunks from the queue to the gRPC server and prints the transcriptions.
+    """
+    # Connect to the gRPC server
+    channel = grpc.insecure_channel(server_address)
+    stub = seamless_m4t_pb2_grpc.SeamlessM4TServiceStub(channel)
+
+    chunk_id = 0
+    while True:
+        audio_data = audio_queue.get()
+        if audio_data is None:  # End of recording
+            break
+
+        try:
+            if debug:
+                print(f"Sending chunk {chunk_id} to server...")
+
+            # Create and send the request
+            request = seamless_m4t_pb2.SpeechToTextRequest(audio=audio_data, tgt_lang=tgt_lang)
+            response = stub.SpeechToText(request)
+
+            # Print the response
+            print(f"{response.text}")
+            chunk_id += 1
+
+        except grpc.RpcError as e:
+            print(f"gRPC Error: {e.code()} - {e.details()}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+if __name__ == "__main__":
+    # Parameters
+    chunk_duration_s = 1  # Record in 2-second chunks
+    server_address = "localhost:9090"  # gRPC server address
+    tgt_lang = "eng"  # Target language for transcription
+
+    # Create a queue to share audio chunks between threads
+    audio_queue = queue.Queue()
+
+    # Start the recording and sending threads
+    recorder_thread = threading.Thread(target=record_audio_to_queue, args=(audio_queue, chunk_duration_s))
+    sender_thread = threading.Thread(target=send_audio_chunks_to_server, args=(audio_queue, server_address, tgt_lang))
+
+    recorder_thread.start()
+    sender_thread.start()
+
+    # Wait for both threads to finish
+    recorder_thread.join()
+    sender_thread.join()
+
+    print("Recording and transcription completed.")
+

requirements.txt

@@ -1,4 +1,5 @@
 torchaudio
 grpcio
 grpcio-tools
-protobuf
+protobuf
+

seamless_m4t.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package seamlessm4t;
+
+// Define the gRPC service
+service SeamlessM4TService {
+    // Unary RPC for speech-to-text
+    rpc SpeechToText(SpeechToTextRequest) returns (SpeechToTextResponse);
+}
+
+// Define the request message for speech-to-text
+message SpeechToTextRequest {
+    bytes audio = 1;         // The audio file data in bytes
+    string tgt_lang = 2;     // The target language for transcription (e.g., "eng", "fra")
+}
+
+// Define the response message for speech-to-text
+message SpeechToTextResponse {
+    string text = 1;         // The transcribed text from the audio
+}
+

seamless_m4t_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: seamless_m4t.proto
+# Protobuf Python Version: 5.28.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    28,
+    1,
+    '',
+    'seamless_m4t.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12seamless_m4t.proto\x12\x0bseamlessm4t\"6\n\x13SpeechToTextRequest\x12\r\n\x05\x61udio\x18\x01 \x01(\x0c\x12\x10\n\x08tgt_lang\x18\x02 \x01(\t\"$\n\x14SpeechToTextResponse\x12\x0c\n\x04text\x18\x01 \x01(\t2i\n\x12SeamlessM4TService\x12S\n\x0cSpeechToText\x12 .seamlessm4t.SpeechToTextRequest\x1a!.seamlessm4t.SpeechToTextResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'seamless_m4t_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_SPEECHTOTEXTREQUEST']._serialized_start=35
+  _globals['_SPEECHTOTEXTREQUEST']._serialized_end=89
+  _globals['_SPEECHTOTEXTRESPONSE']._serialized_start=91
+  _globals['_SPEECHTOTEXTRESPONSE']._serialized_end=127
+  _globals['_SEAMLESSM4TSERVICE']._serialized_start=129
+  _globals['_SEAMLESSM4TSERVICE']._serialized_end=234
+# @@protoc_insertion_point(module_scope)

seamless_m4t_pb2_grpc.py

@@ -0,0 +1,101 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+import seamless_m4t_pb2 as seamless__m4t__pb2
+
+GRPC_GENERATED_VERSION = '1.68.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in seamless_m4t_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class SeamlessM4TServiceStub(object):
+    """Define the gRPC service
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SpeechToText = channel.unary_unary(
+                '/seamlessm4t.SeamlessM4TService/SpeechToText',
+                request_serializer=seamless__m4t__pb2.SpeechToTextRequest.SerializeToString,
+                response_deserializer=seamless__m4t__pb2.SpeechToTextResponse.FromString,
+                _registered_method=True)
+
+
+class SeamlessM4TServiceServicer(object):
+    """Define the gRPC service
+    """
+
+    def SpeechToText(self, request, context):
+        """Unary RPC for speech-to-text
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_SeamlessM4TServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SpeechToText': grpc.unary_unary_rpc_method_handler(
+                    servicer.SpeechToText,
+                    request_deserializer=seamless__m4t__pb2.SpeechToTextRequest.FromString,
+                    response_serializer=seamless__m4t__pb2.SpeechToTextResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'seamlessm4t.SeamlessM4TService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('seamlessm4t.SeamlessM4TService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class SeamlessM4TService(object):
+    """Define the gRPC service
+    """
+
+    @staticmethod
+    def SpeechToText(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/seamlessm4t.SeamlessM4TService/SpeechToText',
+            seamless__m4t__pb2.SpeechToTextRequest.SerializeToString,
+            seamless__m4t__pb2.SpeechToTextResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

server.crt

@@ -0,0 +1,28 @@
+-----BEGIN CERTIFICATE-----
+MIIEwjCCAqoCE14N9UG91aZF9RVmsm6ON5SjewQwDQYJKoZIhvcNAQELBQAwHjEc
+MBoGA1UEAwwTcmVzZXJ2ZS5haXhibG9jay5pbzAeFw0yNDExMjYwMTMzMzlaFw0y
+NTExMjYwMTMzMzlaMB4xHDAaBgNVBAMME3Jlc2VydmUuYWl4YmxvY2suaW8wggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDfNYTqc39NnsAVVhaRZvUZS+R0
+T9KOsCIVj2VUya2WZe1MfT8SZ+EiMroueG52D9rH7siI2zj7RIl+WUtr9ReIMdBp
+OjaOfUOjr034UaI6Cfh6tlyZ+PHf5mdQttYizY7RLLdgeLrBWrJUJyOFoDyNCAHj
+U0cqeYlnYXas2ECL/TlHqeOQerYsKWCkqJZDacHOR70oAXSbPjaQlIAFyrxApPqd
+pevyM65FtqoLaPGKxzFzrRsPFCOPXcDLnyX81cexig6rk24yM3yd3DC1CM4lXXJc
+W6XsHGksOx8XmvWjyIdZEd5ic1aOM2d830irAR4EQSRiqv7nspJnBtqIqNtuQY5r
+Id4DNgpYUBJiV9V6cHppBYSj2wM7VEUxEeMIWxM6YMiSwH5gdMCUqLMHJHTRlCZi
+M5COiEj4gWkNy5B9zgGOJIjRKe3e8x0aAVbOqNNDaiQQXg/CYZBiJtOTrnc9bmHu
+OdXGP770CAglYy1JmXfPmOL+ega7Wq1g/v91i559EpVre5+pEPU6bWEfEpO1aK7s
+lZ/F7suteWZgfAVFVqU1nXlHb3d0PMSCDGcDqEE8HSbp1qNNswU42a0E7iwGA/Ks
+D3AKeDFCA45ZDwb4QoTRDHYlEwiQelZt+LA2CXqY5KWBGBqIqmYTEJcx2oJPvz0P
+kyvnau9z75BnhAkF9QIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQCH0BCzPR0alXGb
+MxYwAAkVhzY0NeYA56+fRwbTkH2xzuE8VFp3ezEAJmuP9WGbuGZ2Ntw0kjDXKXhi
+eXChjby055qDzPWS4h2mNhauxFfUeHGlHwYxBoQcOzFkjLVtmPVGkAqtWopiEBE1
+lEJdoasgboKN8ypwYjPWzSpxNdd2h6RZNb9/cpLwdU0wlaN2yhfwsP2wOnBM+/yK
+QQAT+GTNlO9xgIMvQs0XB0r5Wy6MF2A0V2uxwzr5lYFEDHxrvVPjMy4yAtPJz+Q4
+WYZCRnV36WUz3IVFIcpMun2yW2Y6rdPAkNE4uoSTIHSd1iaswrqR5l4Uor7V6tOR
+Enl4Iz7Tc8BAAL2D99ajDeJ2+BE31Oipe6YtMesCsaMWylrzike196J480JIqjhz
+tBeep+3L0BquPpSzSQW5o554s+zVQCXJVVDewwSlBxpCi92N8lA1Zffyl/d7LbWt
+Wgf3iHx7v5y5FZY6vAARTKCcEqvKONrQmp1WGB0Equ5hFaC5e+FU59qpOi6cWO36
+sMkgSRVDueNeEBYN4fKKDh36WJ3rxDSclUv+oqlcneNvAnpfR5kfYEr5ta4OqsQ2
+TRpW8a4tR9uNnokomQs4X4AAwOgdZaDD2+6m8rnr01HnPdaZDBhwwmkBaKA+vNO0
+Etg+7cwaKCJ2n6Q7u84Bs8zMY7Bldg==
+-----END CERTIFICATE-----

server.key

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

server51.py

@@ -0,0 +1,93 @@
+import os
+import torch
+import torchaudio
+from transformers import AutoProcessor, SeamlessM4Tv2Model
+import seamless_m4t_pb2
+import seamless_m4t_pb2_grpc
+from concurrent import futures
+import grpc
+import io 
+# Set Hugging Face cache path
+os.environ["HF_HOME"] = "/path/to/custom/huggingface_cache"  # Change this to your desired path
+
+# Load the transcription model and processor
+MODEL_NAME = "facebook/seamless-m4t-v2-large"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+print(f"Loading model {MODEL_NAME} on {device}...")
+processor = AutoProcessor.from_pretrained(MODEL_NAME)
+model = SeamlessM4Tv2Model.from_pretrained(MODEL_NAME).to(device)
+
+
+class SeamlessM4TServicer(seamless_m4t_pb2_grpc.SeamlessM4TServiceServicer):
+    def SpeechToText(self, request, context):
+        """
+        Handles a unary SpeechToText request, processes the audio, and returns a transcription.
+        """
+        try:
+            # Load audio from the request directly into memory
+            print("Processing received audio in memory...")
+            audio_data = torch.frombuffer(request.audio, dtype=torch.float32)
+            
+            # Convert the buffer to a waveform tensor
+            waveform, sampling_rate = torchaudio.load(io.BytesIO(request.audio), format="wav")
+            print(f"Loaded audio: shape={waveform.shape}, sampling_rate={sampling_rate}")
+
+            # Resample to 16 kHz if necessary
+            if sampling_rate != 16000:
+                print("Resampling audio to 16kHz...")
+                resampler = torchaudio.transforms.Resample(orig_freq=sampling_rate, new_freq=16000)
+                waveform = resampler(waveform)
+
+            # Convert stereo to mono if necessary
+            if waveform.shape[0] > 1:
+                print("Converting audio to mono...")
+                waveform = torch.mean(waveform, dim=0, keepdim=True)
+
+            # Prepare the input for the model
+            inputs = processor(
+                audios=waveform.squeeze().numpy(),
+                sampling_rate=16000,
+                return_tensors="pt"
+            ).to(device)
+
+            # Generate transcription
+            output_tokens = model.generate(**inputs, tgt_lang=request.tgt_lang, generate_speech=False)
+            transcribed_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)
+
+            print(f"Transcription result: {transcribed_text}")
+
+            # Return the response
+            return seamless_m4t_pb2.SpeechToTextResponse(text=transcribed_text)
+
+        except Exception as e:
+            print(f"Error in SpeechToText: {e}")
+            context.set_details(str(e))
+            context.set_code(grpc.StatusCode.INTERNAL)
+            return seamless_m4t_pb2.SpeechToTextResponse(text="Error during transcription.")
+
+
+def serve():
+    """
+    Start the gRPC server and listen for client connections.
+    """
+    """
+    Start the gRPC server with secure communication using TLS.
+    """
+    # Load the server's certificate and private key
+    with open("server.crt", "rb") as cert_file, open("server.key", "rb") as key_file:
+        server_credentials = grpc.ssl_server_credentials(
+            [(key_file.read(), cert_file.read())]
+        )
+
+    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+    seamless_m4t_pb2_grpc.add_SeamlessM4TServiceServicer_to_server(SeamlessM4TServicer(), server)
+    server.add_secure_port("[::]:9080",server_credentials)
+    print("Server is running on port 9080...")
+    server.start()
+    server.wait_for_termination()
+
+
+if __name__ == "__main__":
+    serve()
+