phonexia-replay-attack-detection-client 1.0.0__tar.gz

phonexia_replay_attack_detection_client-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.3
+Name: phonexia-replay-attack-detection-client
+Version: 1.0.0
+Summary: Client for communication with Phonexia Replay Attack Detection microservice.
+Keywords: grpc,voice
+Author: Phonexia
+Author-email: info@phonexia.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: grpcio (>=1.54.0,<2.0.0)
+Requires-Dist: numpy (<2.0.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=2.0.0) ; python_version >= "3.12"
+Requires-Dist: phonexia-grpc (>=2.0.0,<3.0.0)
+Requires-Dist: soundfile (>=0.12.1,<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 Replay Attack Detection client
+
+This module contains client for communication with [Replay attack detection microservice](https://hub.docker.com/repository/docker/phonexia/replay-attack-detection/general) developed by [Phonexia](https://phonexia.com).
+
+To use this client you will first need a running instance of any *Phonexia Replay Attack Detection 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 identification technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/speaker-identification/).
+
+On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/replay_attack_detection/experimental/replay_attack_detection.proto), you will find a *gRPC API* reference for *Replay Attack Detection microservice*.

phonexia_replay_attack_detection_client-1.0.0/phonexia_replay_attack_detection_client.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+
+import argparse
+import csv
+import json
+import logging
+import os
+import sys
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any, Optional
+
+import google.protobuf.duration_pb2
+import grpc
+import numpy as np
+import soundfile
+from phonexia.grpc.common.core_pb2 import Audio, RawAudioConfig, TimeRange
+from phonexia.grpc.technologies.replay_attack_detection.experimental.replay_attack_detection_pb2 import (
+    DetectRequest,
+    DetectResponse,
+)
+from phonexia.grpc.technologies.replay_attack_detection.experimental.replay_attack_detection_pb2_grpc import (
+    ReplayAttackDetectionStub,
+)
+
+
+def time_to_duration(time: float) -> Optional[google.protobuf.duration_pb2.Duration]:
+    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 make_request(
+    file: Path,
+    start: Optional[float],
+    end: Optional[float],
+    use_raw_audio: bool,
+) -> Iterator[DetectRequest]:
+    time_range: Optional[TimeRange] = TimeRange(
+        start=time_to_duration(start), end=time_to_duration(end)
+    )
+    chunk_size = 1024 * 100
+    if use_raw_audio:
+        with soundfile.SoundFile(file) as r:
+            raw_audio_config: Optional[RawAudioConfig] = RawAudioConfig(
+                channels=r.channels,
+                sample_rate_hertz=r.samplerate,
+                encoding=RawAudioConfig.AudioEncoding.PCM16,
+            )
+            for data in r.blocks(blocksize=r.samplerate, dtype="float32"):
+                int16_info = np.iinfo(np.int16)
+                data_scaled = np.clip(
+                    data * (int16_info.max + 1), int16_info.min, int16_info.max
+                ).astype("int16")
+                yield DetectRequest(
+                    audio=Audio(
+                        content=data_scaled.flatten().tobytes(),
+                        raw_audio_config=raw_audio_config,
+                        time_range=time_range,
+                    )
+                )
+                time_range = None
+                raw_audio_config = None
+
+    else:
+        with open(file, mode="rb") as fd:
+            while chunk := fd.read(chunk_size):
+                yield DetectRequest(audio=Audio(content=chunk, time_range=time_range))
+                time_range = None
+
+
+def write_result(audio_path: str, response: DetectResponse, output_file: Optional[str] = None):
+    with sys.stdout if output_file is None else open(output_file, "w") as f:
+        logging.info(f"{audio_path!s} -> {output_file!s}")
+        output = {
+            "audio": str(audio_path),
+            "total_billed_time": str(response.processed_audio_length.ToTimedelta()),
+        }
+        if response.HasField("result"):
+            output["score"] = response.result.score
+        json.dump(output, f, indent=2)
+
+
+def detect(
+    channel: grpc.Channel,
+    file: Path,
+    output_file: Optional[Path],
+    start: Optional[float],
+    end: Optional[float],
+    metadata: Optional[list[Any]],
+    use_raw_audio: bool,
+):
+    logging.info(f"Detecting replay attacks in {file}")
+    stub = ReplayAttackDetectionStub(channel)
+    response = stub.Detect(make_request(file, start, end, use_raw_audio), metadata=metadata)
+    write_result(file, response, output_file)
+
+
+# Main program
+def check_file_exists(path: str) -> Path:
+    if not os.path.isfile(path):
+        raise argparse.ArgumentTypeError(f"File '{path}' does not exist.")
+    return Path(path)
+
+
+def parse_list(path: Path) -> list[list[str]]:
+    with open(path, newline="") as csvfile:
+        reader = csv.reader(csvfile, delimiter=" ", skipinitialspace=True)
+        rows = list(reader)
+
+        for row in rows:
+            num_cols = len(row)
+            if num_cols < 1 or num_cols > 2:
+                raise ValueError(
+                    f"File '{path}' must contain one or two columns. Problematic row: '{row}'"
+                )
+            if num_cols == 1:
+                row.append(str(Path(row[0]).with_suffix(".json")))
+
+        return rows
+
+
+def main():  # noqa: C901
+    parser = argparse.ArgumentParser(description="Replay Attack Detection Client")
+    parser.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        default="localhost:8080",
+        help="Server address, default: localhost:8080",
+    )
+    parser.add_argument(
+        "-l",
+        "--log_level",
+        type=str,
+        default="error",
+        choices=["critical", "error", "warning", "info", "debug"],
+    )
+    parser.add_argument(
+        "--metadata",
+        metavar="key=value",
+        nargs="+",
+        type=lambda x: tuple(x.split("=")),
+        help="Custom client metadata",
+    )
+    parser.add_argument("-i", "--input", type=check_file_exists, help="Input audio file")
+    parser.add_argument("-o", "--output", type=Path, help="Output file path")
+    parser.add_argument(
+        "-L",
+        "--list",
+        type=check_file_exists,
+        help="List of files and optional output locations (csv file, delimiter is space character ' ')",
+    )
+    parser.add_argument("--use_ssl", action="store_true", help="Use SSL connection")
+    parser.add_argument("--start", type=float, default=None, help="Start time (seconds)")
+    parser.add_argument("--end", type=float, default=None, help="End time (seconds)")
+    parser.add_argument("--use_raw_audio", action="store_true", help="Send raw audio chunks")
+
+    args = parser.parse_args()
+
+    if not (args.input or args.list):
+        raise ValueError("Either 'input' or 'list' parameter must be set.")
+
+    if args.start is not None and args.start < 0:
+        raise ValueError("Parameter 'start' must be a non-negative float.")
+
+    if args.end is not None and args.end <= 0:
+        raise ValueError("Parameter 'end' must be a positive float.")
+
+    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'.")
+
+    logging.basicConfig(
+        level=args.log_level.upper(),
+        format="[%(asctime)s.%(msecs)03d] [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    try:
+        logging.info(f"Connecting to {args.host}")
+        channel = (
+            grpc.secure_channel(target=args.host, credentials=grpc.ssl_channel_credentials())
+            if args.use_ssl
+            else grpc.insecure_channel(target=args.host)
+        )
+
+        def execute(input_file: Path, output_file: Path) -> None:
+            detect(
+                channel,
+                input_file,
+                output_file,
+                args.start,
+                args.end,
+                args.metadata,
+                args.use_raw_audio,
+            )
+
+        if args.input is not None:
+            execute(args.input, args.output)
+
+        elif args.list is not None:
+            for input_file, output_file in parse_list(args.list):
+                execute(Path(input_file), Path(output_file))
+
+    except grpc.RpcError:
+        logging.exception("RPC failed")
+        exit(1)
+    except ValueError as e:
+        logging.exception(e)  # noqa: TRY401
+        exit(1)
+    except Exception:
+        logging.exception("Unknown error")
+        exit(1)
+    finally:
+        channel.close()
+
+
+if __name__ == "__main__":
+    main()

phonexia_replay_attack_detection_client-1.0.0/pypi-README.md

@@ -0,0 +1,10 @@
+![](https://www.phonexia.com/wp-content/uploads/phonexia-logo-transparent-500px.png)
+# Phonexia Replay Attack Detection client
+
+This module contains client for communication with [Replay attack detection microservice](https://hub.docker.com/repository/docker/phonexia/replay-attack-detection/general) developed by [Phonexia](https://phonexia.com).
+
+To use this client you will first need a running instance of any *Phonexia Replay Attack Detection 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 identification technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/speaker-identification/).
+
+On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/replay_attack_detection/experimental/replay_attack_detection.proto), you will find a *gRPC API* reference for *Replay Attack Detection microservice*.

phonexia_replay_attack_detection_client-1.0.0/pyproject.toml

@@ -0,0 +1,99 @@
+[tool.poetry]
+name = "phonexia-replay-attack-detection-client"
+version = "1.0.0"
+description = "Client for communication with Phonexia Replay Attack Detection microservice."
+readme = "pypi-README.md"
+keywords = ["grpc", "voice"]
+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]
+replay_attack_detection_client = 'phonexia_replay_attack_detection_client:main'
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+grpcio = "^1.54.0"
+phonexia-grpc = {version="^2.0.0", source="pypi"}
+soundfile = "^0.12.1"
+numpy = [
+    { version = "<2.0.0", markers = "python_version < '3.12'" },
+    { version = ">=2.0.0", markers = "python_version >= '3.12'" }
+]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-cov = "^6.0.0"
+pytest-env = "^1.0.0"
+pytest-random-order = "^1.1.0"
+black = "^24.0.0"
+ruff = "^0.7.0"
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[[tool.poetry.source]]
+name = "gitlab"
+url = "https://gitlab.cloud.phonexia.com/api/v4/groups/39/-/packages/pypi/simple"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 100
+target-version = ['py39']
+preview = true
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+fix = true
+lint.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",
+]
+lint.ignore = [
+    # LineTooLong
+    "E501",
+    # DoNotAssignLambda
+    "E731",
+    # RaiseVanillaArgs aka Avoid specifying long messages outside the exception class
+    "TRY003",
+    # Use X | Y for type annotations instead of Optional
+    "UP007",
+    # Import Iterator from 'collections.abc' instead of typing
+    "UP035",
+]