phonexia-time-analysis-client 1.0.0__tar.gz

phonexia_time_analysis_client-1.0.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.3
+Name: phonexia-time-analysis-client
+Version: 1.0.0
+Summary: Client for communication with Phonexia time analysis microservice.
+Keywords: grpc,voice,analysis
+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 time analysis client
+
+This module contains client for communication with [time analysis microservice](https://hub.docker.com/repository/docker/phonexia/time-analysis/general) developed by [Phonexia](https://phonexia.com).
+
+To use this client you will first need a running instance of any *Phonexia time analysis 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 time analysis technology [here](https://docs.phonexia.com/products/speech-platform-4/technologies/time-analysis/).
+
+On [this page](https://docs.phonexia.com/products/speech-platform-4/grpc/api/phonexia/grpc/technologies/time_analysis/v1/time_analysis.proto), you will find a *gRPC API* reference for *time analysis microservice*.

phonexia_time_analysis_client-1.0.0/phonexia_time_analysis_client.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import logging
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator, Optional
+
+import grpc
+import numpy as np
+import soundfile
+from google.protobuf.duration_pb2 import Duration
+from google.protobuf.json_format import MessageToDict
+from phonexia.grpc.common.core_pb2 import (
+    Audio,
+    RawAudioConfig,
+    TimeRange,
+)
+from phonexia.grpc.technologies.time_analysis.v1.time_analysis_pb2 import (
+    AnalyzeRequest,
+    AnalyzeResponse,
+)
+from phonexia.grpc.technologies.time_analysis.v1.time_analysis_pb2_grpc import (
+    TimeAnalysisStub,
+)
+
+
+def print_json(message, output_file: Optional[Path] = None) -> None:
+    json.dump(
+        message, output_file.open("w") if output_file else sys.stdout, indent=2, ensure_ascii=False
+    )
+
+
+def message_to_dict(message):
+    return MessageToDict(
+        message,
+        always_print_fields_with_no_presence=True,
+        preserving_proto_field_name=True,
+        use_integers_for_enums=False,
+    )
+
+
+def time_to_duration(time: float) -> Optional[Duration]:
+    if time is None:
+        return None
+    duration = Duration()
+    duration.seconds = int(time)
+    duration.nanos = int((time - duration.seconds) * 1e9)
+    return duration
+
+
+def make_request(
+    file: str,
+    start: Optional[float],
+    end: Optional[float],
+    use_raw_audio: bool,
+) -> Iterator[AnalyzeRequest]:
+    time_range = 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 = 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 AnalyzeRequest(
+                    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 AnalyzeRequest(audio=Audio(content=chunk, time_range=time_range))
+                time_range = None
+
+
+def write_result(response: AnalyzeResponse, output_file: Optional[str] = None) -> None:
+    logging.debug("Writing matches to {}".format(output_file if output_file else "'stdout'"))
+    message = message_to_dict(message=response)
+    print_json(message, output_file)
+
+
+def analyze(
+    channel: grpc.Channel,
+    input_file: Path,
+    output_file: Optional[Path],
+    start: Optional[float],
+    end: Optional[float],
+    metadata: Optional[list],
+    use_raw_audio: bool,
+) -> None:
+    logging.info(
+        "Analyzing {input} -> {output}".format(
+            input=input_file, output=(output_file if output_file else "'stdout'")
+        )
+    )
+
+    response_it = make_request(
+        file=input_file,
+        start=start,
+        end=end,
+        use_raw_audio=use_raw_audio,
+    )
+
+    stub = TimeAnalysisStub(channel)
+    for response in stub.Analyze(response_it, metadata=metadata):
+        write_result(response, output_file)
+
+
+# Main program
+def handle_grpc_error(e: grpc.RpcError):
+    logging.error(f"gRPC call failed with status code: {e.code()}")
+    logging.error(f"Error details: {e.details()}")
+
+    if e.code() == grpc.StatusCode.UNAVAILABLE:
+        logging.error("Service is unavailable. Please try again later.")
+    elif e.code() == grpc.StatusCode.INVALID_ARGUMENT:
+        logging.error("Invalid arguments were provided to the RPC.")
+    elif e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
+        logging.error("The RPC deadline was exceeded.")
+    else:
+        logging.error(f"An unexpected error occurred: {e.code()} - {e.details()}")
+
+
+def check_file_exists(path: Path) -> Path:
+    if not os.path.isfile(path):
+        raise argparse.ArgumentTypeError(f"File '{path}' does not exist.")
+    return Path(path)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=("Analyze time based traits in a multichannel audio file"),
+    )
+    parser.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        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="Multichannel input audio file.",
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=None,
+        help="Output result to a file. If omitted, output to stdout.",
+    )
+    parser.add_argument("--use_ssl", action="store_true", help="Use SSL connection")
+    parser.add_argument("--start", type=float, help="Audio start time")
+    parser.add_argument("--end", type=float, help="Audio end time")
+    parser.add_argument("--use_raw_audio", action="store_true", help="Send a raw audio")
+
+    args = parser.parse_args()
+
+    output_file: Optional[Path] = Optional
+    output_file = args.output
+
+    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.")
+
+    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)
+        )
+
+        start_time = datetime.now()
+
+        analyze(
+            channel=channel,
+            input_file=args.input,
+            output_file=output_file,
+            start=args.start,
+            end=args.end,
+            metadata=args.metadata,
+            use_raw_audio=args.use_raw_audio,
+        )
+
+        logging.debug(f"Elapsed time {(datetime.now() - start_time)}")
+
+    except grpc.RpcError as e:
+        handle_grpc_error(e)
+        exit(1)
+    except Exception:
+        logging.exception("Unknown error")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

phonexia_time_analysis_client-1.0.0/pypi-README.md

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

phonexia_time_analysis_client-1.0.0/pyproject.toml

@@ -0,0 +1,99 @@
+[tool.poetry]
+name = "phonexia-time-analysis-client"
+version = "1.0.0"
+description = "Client for communication with Phonexia time analysis microservice."
+readme = "pypi-README.md"
+keywords = ["grpc", "voice", "analysis"]
+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]
+time_analysis_client = 'phonexia_time_analysis_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",
+]