phonexia-speaker-diarization-client 1.1.0__tar.gz

phonexia_speaker_diarization_client-1.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: phonexia-speaker-diarization-client
+Version: 1.1.0
+Summary: Client script for communicationg with diarization microservice
+Keywords: grpc,voice,voice-biometry,speech,language,diarization
+Author: Phonexia
+Author-email: info@phonexia.com
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: ConfigArgParse (==1.7)
+Requires-Dist: grpcio (>=1.54.0,<2.0.0)
+Requires-Dist: grpcio-health-checking (>=1.54.0,<2.0.0)
+Requires-Dist: grpcio-reflection (>=1.54.0,<2.0.0)
+Requires-Dist: phonexia-grpc (>=1.0.0,<2.0.0)
+Requires-Dist: tomlkit (>=0.12.0,<0.13.0)
+Project-URL: Homepage, https://phonexia.com
+Project-URL: Issues, https://phonexia.atlassian.net/servicedesk/customer/portal/15/group/20/create/40
+Project-URL: protofiles, https://github.com/phonexia/protofiles
+Description-Content-Type: text/markdown
+
+
+![](https://www.phonexia.com/wp-content/uploads/phonexia-logo-transparent-500px.png)
+
+# Phonexia speaker diarization client
+
+This module contains client for communication with [voiceprint diarization microservice](https://hub.docker.com/repository/docker/phonexia/speaker-diarization/general) developed by [Phonexia](https://phonexia.com).
+
+To use this client you will first need a running instance of any *Phonexia speaker diarization microservice*. If you don't yet have any running instance, don't hesitate to [contact our sales department](mailto:info@phonexia.com).
+
+You can learn more about the speaker diarization technology [here](TODO).
+
+On [this page](TODO), you will find a *gRPC API* reference for *voiceprint diarization microservice*.

phonexia_speaker_diarization_client-1.1.0/phonexia_speaker_diarization_client.py

@@ -0,0 +1,271 @@
+#!/usr/bin/python3
+
+import argparse
+import fnmatch
+import logging
+import os
+from pathlib import Path
+from typing import Iterator, Optional
+
+import google.protobuf.duration_pb2
+import grpc
+import phonexia.grpc.common.core_pb2 as phx_common
+import phonexia.grpc.technologies.speaker_diarization.v1.speaker_diarization_pb2 as diarization
+import phonexia.grpc.technologies.speaker_diarization.v1.speaker_diarization_pb2_grpc as diarization_grpc
+
+CHUNK_SIZE = 1024 * 1024
+
+
+class speaker_diarization_client:
+    def __init__(
+        self,
+        host: str,
+        use_ssl: bool,
+        max_speakers: Optional[int] = None,
+        total_speakers: Optional[int] = None,
+        output_format="lab",
+    ):
+        if use_ssl:
+            logging.info("Connecting to %s via secure channel", host)
+            credentials = grpc.ssl_channel_credentials()
+            self.channel = grpc.secure_channel(host, credentials)
+        else:
+            logging.info("Connecting to %s via insecure channel", host)
+            self.channel = grpc.insecure_channel(host)
+
+        self.max_speakers = max_speakers
+        self.total_speakers = total_speakers
+        logging.info(
+            "Using max_speakers=%s and total_speakers=%s",
+            self.max_speakers,
+            self.total_speakers,
+        )
+        self.diarize_stub = diarization_grpc.SpeakerDiarizationStub(self.channel)
+        if output_format not in {"lab", "rttm"}:
+            raise ValueError("Unsupported output format")
+        self.format = output_format
+
+    def time_to_duration(self, time: float) -> google.protobuf.duration_pb2.Duration | None:
+        if time is None:
+            return None
+        duration = google.protobuf.duration_pb2.Duration()
+        duration.seconds = int(time)
+        duration.nanos = int((time - duration.seconds) * 1e9)
+        return duration
+
+    def file_to_request(
+        self, file: Path, start: float, end: float
+    ) -> Iterator[diarization.DiarizeRequest]:
+        time_range = phx_common.TimeRange(
+            start=self.time_to_duration(start), end=self.time_to_duration(end)
+        )
+        request = diarization.DiarizeRequest(
+            audio=phx_common.Audio(content=None, time_range=time_range),
+            config=diarization.DiarizeConfig(),
+        )
+
+        if self.total_speakers is not None:
+            request.config.total_speakers = self.total_speakers
+
+        if self.max_speakers is not None:
+            request.config.max_speakers = self.max_speakers
+
+        with open(file, "rb") as f:
+            while chunk := f.read(CHUNK_SIZE):
+                request.audio.content = chunk
+                logging.debug("Sending chunk of size %d", len(chunk))
+                yield request
+                request.audio.ClearField("time_range")
+                request.config.ClearField("total_speakers")
+                request.config.ClearField("max_speakers")
+
+    def save_response_lab(self, response: diarization.DiarizeResponse, file: Path):
+        def to_htk(sec: float):
+            return int(round(sec * 10**7, ndigits=0))
+
+        with open(file, "w", encoding="utf8") as fd:
+            for segment in response.segments:
+                print(
+                    "{:d} {:d} {:d}".format(
+                        to_htk(segment.start_time.ToTimedelta().total_seconds()),
+                        to_htk(segment.end_time.ToTimedelta().total_seconds()),
+                        int(segment.speaker_id) + 1,
+                    ),
+                    file=fd,
+                )
+
+    def save_response_rttm(self, response: diarization.DiarizeResponse, file: Path):
+        with open(file, "w", encoding="utf8") as fd:
+            for segment in response.segments:
+                beg = segment.start_time.ToTimedelta().total_seconds()
+                end = segment.end_time.ToTimedelta().total_seconds()
+                size = end - beg
+                print(
+                    f"SPEAKER {file.stem} 1 {beg:.2f} {size:.2f} <NA> <NA>"
+                    f" {int(segment.speaker_id) + 1} <NA>",
+                    file=fd,
+                )
+
+    def send_diarize_request(
+        self, request: Iterator[diarization.DiarizeRequest]
+    ) -> diarization.DiarizeResponse:
+        return self.diarize_stub.Diarize(request)
+
+    def process_file(
+        self,
+        in_file: Path,
+        start: Optional[float] = None,
+        end: Optional[float] = None,
+        output: Optional[Path] = None,
+    ):
+        if output is None:
+            output = in_file.with_suffix("." + self.format)
+
+        logging.info("%s -> %s", in_file, output)
+
+        response = self.send_diarize_request(self.file_to_request(in_file, start, end))
+
+        if self.format == "lab":
+            self.save_response_lab(response, output)
+        if self.format == "rttm":
+            self.save_response_rttm(response, output)
+
+    def process_dir(
+        self,
+        in_dir: Path,
+        start: Optional[float] = None,
+        end: Optional[float] = None,
+        output: Optional[Path] = None,
+        input_suffix: str = "wav",
+    ):
+        if output is None:
+            output = in_dir
+
+        if not output.exists:
+            os.mkdir(output)
+
+        logging.info("Scanning directory %s for *.%s", os.path.abspath(in_dir), input_suffix)
+        files = os.listdir(in_dir)
+        filtered_files = [f for f in files if fnmatch.fnmatch(f, f"*.{input_suffix}")]
+        logging.info("Found %d files", len(filtered_files))
+        for file in filtered_files:
+            in_file = in_dir / file
+            out_file = (Path(output) / file).with_suffix("." + self.format)
+            self.process_file(in_file, start, end, out_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Speaker Diarization gRPC client. Identifies speakers in input audio and returns"
+            " segments with timestamps for each speaker."
+        )
+    )
+    parser.add_argument(
+        "-H",
+        "--host",
+        default="localhost:8080",
+        help="Phonexia Speech Engine gRPC API server host",
+    )
+    parser.add_argument("--use_ssl", action="store_true", default=False, help="Use SSL connection")
+    parser.add_argument(
+        "-F",
+        "--out-format",
+        default="lab",
+        choices=["lab", "rttm"],
+        help="Output format",
+    )
+    speakers = parser.add_mutually_exclusive_group(required=False)
+    speakers.add_argument(
+        "--total-speakers",
+        type=int,
+        help="Exact number of speakers in recording",
+    )
+    speakers.add_argument(
+        "--max-speakers",
+        type=int,
+        help="Maximum number of speakers in recording",
+    )
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        type=str,
+        default="info",
+        choices=["critical", "error", "warning", "info", "debug"],
+        help="Logging level",
+    )
+    input_options = parser.add_mutually_exclusive_group(required=True)
+    input_options.add_argument("-i", "--in-file", type=Path, help="Path to audio file")
+    input_options.add_argument(
+        "-d", "--in-dir", type=Path, help="Path to directory containing audio files"
+    )
+    parser.add_argument("--start", type=float, help="Audio start time")
+    parser.add_argument("--end", type=float, help="Audio end time")
+    parser.add_argument(
+        "-e",
+        "--in-extension",
+        default="wav",
+        help="Input extension of files in directory.",
+    )
+    output_options = parser.add_mutually_exclusive_group(required=False)
+    output_options.add_argument(
+        "-o",
+        "--out-file",
+        type=Path,
+        help="Location the output will be stored into.",
+    )
+    output_options.add_argument(
+        "-D",
+        "--out-dir",
+        type=Path,
+        help="Directory in which the output will be stored.",
+    )
+
+    args = parser.parse_args()
+
+    if args.start is not None and args.start < 0:
+        raise ValueError("Parameter 'start' must be a non-negative float.\n")
+
+    if args.end is not None and args.end <= 0:
+        raise ValueError("Parameter 'end' must be a positive float.\n")
+
+    if args.start is not None and args.end is not None and args.start >= args.end:
+        raise ValueError("Parameter 'end' must be larger than 'start'.\n")
+
+    if args.out_file and args.in_dir:
+        raise ValueError("'-o' option can not be used with '-d'.\n")
+
+    if args.out_dir and args.in_file:
+        raise ValueError("'-D' option can not be used with '-i'.\n")
+
+    logging.basicConfig(
+        level=args.log_level.upper(),
+        format="[%(asctime)s.%(msecs)03d] [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    try:
+        client = speaker_diarization_client(
+            args.host,
+            args.use_ssl,
+            args.max_speakers,
+            args.total_speakers,
+            args.out_format,
+        )
+
+        if args.in_file:
+            client.process_file(args.in_file, args.start, args.end, args.out_file)
+
+        elif args.in_dir:
+            client.process_dir(args.in_dir, args.start, args.end, args.out_dir, args.in_extension)
+
+    except grpc.RpcError:
+        logging.exception("RPC failed")
+        exit(1)
+    except Exception:
+        logging.exception("Unknown error")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

phonexia_speaker_diarization_client-1.1.0/pypi-README.md

@@ -0,0 +1,12 @@
+
+![](https://www.phonexia.com/wp-content/uploads/phonexia-logo-transparent-500px.png)
+
+# Phonexia speaker diarization client
+
+This module contains client for communication with [voiceprint diarization microservice](https://hub.docker.com/repository/docker/phonexia/speaker-diarization/general) developed by [Phonexia](https://phonexia.com).
+
+To use this client you will first need a running instance of any *Phonexia speaker diarization microservice*. If you don't yet have any running instance, don't hesitate to [contact our sales department](mailto:info@phonexia.com).
+
+You can learn more about the speaker diarization technology [here](TODO).
+
+On [this page](TODO), you will find a *gRPC API* reference for *voiceprint diarization microservice*.

phonexia_speaker_diarization_client-1.1.0/pyproject.toml

@@ -0,0 +1,95 @@
+[tool.poetry]
+name = "phonexia-speaker-diarization-client"
+version = "1.1.0"
+description = "Client script for communicationg with diarization microservice"
+readme = "pypi-README.md"
+keywords = ["grpc", "voice", "voice-biometry", "speech", "language", "diarization"]
+authors = ["Phonexia <info@phonexia.com>"]
+
+[tool.poetry.urls]
+Homepage = "https://phonexia.com"
+Issues = "https://phonexia.atlassian.net/servicedesk/customer/portal/15/group/20/create/40"
+protofiles = "https://github.com/phonexia/protofiles"
+
+[tool.poetry.scripts]
+speaker_diarization_client = 'phonexia_speaker_diarization_client:main'
+
+[tool.poetry.dependencies]
+python = ">=3.8,<4.0"
+grpcio = "^1.54.0"
+phonexia-grpc = {version="^1.0.0", source="pypi"}
+ConfigArgParse = "1.7"
+grpcio-reflection = "^1.54.0"
+grpcio-health-checking = "^1.54.0"
+tomlkit = "^0.12.0"
+
+[[tool.poetry.source]]
+name = "gitlab"
+url = "https://gitlab.cloud.phonexia.com/api/v4/groups/39/-/packages/pypi/simple"
+priority = "primary"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "default"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-env = "^1.0.0"
+pytest-random-order = "^1.1.0"
+pre-commit = "^3.0.0"
+tox = "^4.0.0"
+toml = "^0.10.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 100
+target-version = ['py38']
+preview = true
+
+[tool.ruff]
+target-version = "py38"
+line-length = 100
+fix = true
+select = [
+    # flake8-2020
+    "YTT",
+    # flake8-bandit
+    "S",
+    # flake8-bugbear
+    "B",
+    # flake8-builtins
+    "A",
+    # flake8-comprehensions
+    "C4",
+    # flake8-debugger
+    "T10",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # mccabe
+    "C90",
+    # pycodestyle
+    "E", "W",
+    # pyflakes
+    "F",
+    # pygrep-hooks
+    "PGH",
+    # pyupgrade
+    "UP",
+    # ruff
+    "RUF",
+    # tryceratops
+    "TRY",
+]
+ignore = [
+    # LineTooLong
+    "E501",
+    # DoNotAssignLambda
+    "E731",
+    # RaiseVanillaArgs aka Avoid specifying long messages outside the exception class
+    "TRY003",
+]