agentic-api 0.7.0__py3-none-macosx_11_0_arm64.whl

agentic_api/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+
+__version__ = version("agentic-api")

agentic_api/__main__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from agentic_api import cli
+
+
+def main() -> int:
+    return cli.main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agentic_api/binary.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+
+REMEDIATION_MESSAGE = "Reinstall agentic-api for this platform"
+BINARY_VERSION_TIMEOUT_S = 5.0
+
+
+class PackagedBinaryNotFoundError(FileNotFoundError):
+    """Raised when a packaged executable cannot be located."""
+
+
+class PackagedBinaryVersionError(RuntimeError):
+    """Raised when a packaged executable cannot report its version."""
+
+
+def find_packaged_binary(name: str) -> Path:
+    for candidate in _candidate_paths(name, include_ambient_path=False):
+        if _is_executable_file(candidate):
+            return candidate
+    raise PackagedBinaryNotFoundError(f"{name} not found; {REMEDIATION_MESSAGE}")
+
+
+def find_active_environment_executable(name: str) -> Path:
+    for candidate in _candidate_paths(name, include_ambient_path=False):
+        if _is_executable_file(candidate):
+            return candidate
+    raise FileNotFoundError(f"{name} executable not found in the active environment")
+
+
+def read_binary_version(path: Path) -> str:
+    try:
+        completed = subprocess.run(
+            [str(path), "--version"],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=BINARY_VERSION_TIMEOUT_S,
+        )
+    except OSError as error:  # pragma: no cover - exercised via unit tests.
+        raise PackagedBinaryVersionError(f"unable to launch {path}: {error.strerror or error}") from error
+    except subprocess.TimeoutExpired as error:
+        raise PackagedBinaryVersionError(f"{path} timed out while reporting its version") from error
+    except subprocess.CalledProcessError as error:
+        raise PackagedBinaryVersionError(
+            f"{path} exited with status {error.returncode} while reporting its version"
+        ) from error
+
+    output = (completed.stdout or completed.stderr).strip()
+    if not output:
+        raise PackagedBinaryVersionError(f"{path} did not report a version")
+    return output.splitlines()[0].strip()
+
+
+def _candidate_paths(name: str, *, include_ambient_path: bool = True) -> list[Path]:
+    candidates: list[Path] = []
+
+    if sys.argv and sys.argv[0]:
+        candidates.append(Path(sys.argv[0]).resolve().parent / name)
+
+    scripts_dir = sysconfig.get_path("scripts")
+    if scripts_dir:
+        candidates.append(Path(scripts_dir) / name)
+
+    candidates.append(Path(sys.executable).resolve().parent / name)
+
+    if include_ambient_path:
+        which_path = shutil.which(name)
+        if which_path:
+            candidates.append(Path(which_path))
+
+    unique_candidates: list[Path] = []
+    seen: set[Path] = set()
+    for candidate in candidates:
+        resolved = candidate.resolve(strict=False)
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        unique_candidates.append(candidate)
+    return unique_candidates
+
+
+def _is_executable_file(path: Path) -> bool:
+    return path.is_file() and os.access(path, os.X_OK)

agentic_api/cli.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import argparse
+import math
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+from urllib.parse import urlparse
+
+from agentic_api import __version__
+from agentic_api.diagnostics import doctor
+from agentic_api.version import version_report
+
+
+DEFAULT_HOST = "0.0.0.0"
+DEFAULT_PORT = 9000
+DEFAULT_STARTUP_TIMEOUT_S = 600.0
+DEFAULT_SHUTDOWN_TIMEOUT_S = 10.0
+DEFAULT_VLLM_PORT = 8000
+DEFAULT_GATEWAY_API_KEY_ENV = "OPENAI_API_KEY"
+DEFAULT_VLLM_API_KEY_ENV = "AGENTIC_VLLM_API_KEY"
+RESERVED_VLLM_FLAGS = {"--host", "--port", "--api-key"}
+INCOMPATIBLE_VLLM_FLAGS = {"--uds"}
+MAX_TIMEOUT_S = 86_400.0
+
+
+@dataclass(frozen=True)
+class ServeOptions:
+    mode: str
+    model: str | None
+    vllm_base_url: str | None
+    host: str
+    port: int
+    startup_timeout_s: float
+    shutdown_timeout_s: float
+    vllm_port: int
+    gateway_api_key_env: str
+    vllm_api_key_env: str
+    vllm_args: list[str]
+
+
+class _AgenticArgumentParser(argparse.ArgumentParser):
+    def parse_args(self, args: Sequence[str] | None = None, namespace: argparse.Namespace | None = None) -> argparse.Namespace:
+        parsed = super().parse_args(args=args, namespace=namespace)
+        command = getattr(parsed, "command", None)
+
+        if command == "serve":
+            parsed.options = _build_serve_options(self, parsed)
+
+        return parsed
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = _AgenticArgumentParser(
+        prog="agentic-api",
+        description="Python launcher for packaged Agentic API binaries",
+        allow_abbrev=False,
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    serve_parser = subparsers.add_parser(
+        "serve", help="Launch Agentic API in local or remote mode", allow_abbrev=False
+    )
+    serve_parser.add_argument("--model")
+    serve_parser.add_argument("--vllm-base-url")
+    serve_parser.add_argument("--host", default=DEFAULT_HOST)
+    serve_parser.add_argument("--port", type=_tcp_port, default=DEFAULT_PORT)
+    serve_parser.add_argument("--startup-timeout-s", type=_bounded_timeout, default=DEFAULT_STARTUP_TIMEOUT_S)
+    serve_parser.add_argument("--shutdown-timeout-s", type=_bounded_timeout, default=DEFAULT_SHUTDOWN_TIMEOUT_S)
+    serve_parser.add_argument("--vllm-port", type=_tcp_port, default=DEFAULT_VLLM_PORT)
+    serve_parser.add_argument("--gateway-api-key-env", default=DEFAULT_GATEWAY_API_KEY_ENV)
+    serve_parser.add_argument("--vllm-api-key-env", default=DEFAULT_VLLM_API_KEY_ENV)
+    serve_parser.add_argument("vllm_args", nargs=argparse.REMAINDER)
+
+    doctor_parser = subparsers.add_parser(
+        "doctor", help="Report packaged binary and compatibility diagnostics", allow_abbrev=False
+    )
+    doctor_parser.add_argument("--mode", choices=("local", "remote"))
+    doctor_parser.add_argument(
+        "--json", action="store_true", dest="json_output", help="Emit a machine-readable JSON report"
+    )
+
+    subparsers.add_parser("version", help="Print package and packaged binary versions")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    try:
+        namespace = parser.parse_args(argv)
+    except SystemExit as error:
+        code = error.code
+        return code if isinstance(code, int) else 1
+
+    if namespace.command == "version":
+        try:
+            print(version_report())
+            return 0
+        except (FileNotFoundError, RuntimeError) as error:
+            print(str(error), file=sys.stderr)
+            return 1
+
+    if namespace.command == "doctor":
+        return doctor(namespace.mode, json_output=namespace.json_output)
+
+    if namespace.command == "serve":
+        try:
+            from agentic_api.launcher import run_serve
+        except ModuleNotFoundError as error:
+            if error.name != "agentic_api.launcher":
+                raise
+            print(
+                "agentic-api serve is unavailable because the Python launcher is missing; "
+                "reinstall agentic-api for this platform.",
+                file=sys.stderr,
+            )
+            return 1
+
+        return run_serve(namespace.options)
+
+    parser.error(f"unknown command: {namespace.command}")
+    return 1
+
+
+def _build_serve_options(parser: argparse.ArgumentParser, namespace: argparse.Namespace) -> ServeOptions:
+    if namespace.model is not None and not namespace.model.strip():
+        parser.error("--model must not be empty")
+
+    source_count = int(bool(namespace.model)) + int(bool(namespace.vllm_base_url))
+    if source_count != 1:
+        parser.error("exactly one of --model or --vllm-base-url is required")
+
+    vllm_args = _normalize_vllm_args(namespace.vllm_args)
+    reserved_flag = _reserved_vllm_flag(vllm_args)
+    if reserved_flag is not None:
+        parser.error(f"{reserved_flag} is reserved for the launcher and cannot be forwarded after --")
+
+    vllm_base_url = None
+    mode = "local"
+    if namespace.vllm_base_url is not None:
+        vllm_base_url = _normalize_base_url(parser, namespace.vllm_base_url)
+        mode = "remote"
+
+    if mode == "remote" and vllm_args:
+        parser.error("vLLM passthrough arguments are only supported with --model (local mode)")
+
+    return ServeOptions(
+        mode=mode,
+        model=namespace.model,
+        vllm_base_url=vllm_base_url,
+        host=namespace.host,
+        port=namespace.port,
+        startup_timeout_s=namespace.startup_timeout_s,
+        shutdown_timeout_s=namespace.shutdown_timeout_s,
+        vllm_port=namespace.vllm_port,
+        gateway_api_key_env=namespace.gateway_api_key_env,
+        vllm_api_key_env=namespace.vllm_api_key_env,
+        vllm_args=vllm_args,
+    )
+
+
+def _normalize_vllm_args(values: Sequence[str]) -> list[str]:
+    if values and values[0] == "--":
+        return list(values[1:])
+    return list(values)
+
+
+def _reserved_vllm_flag(values: Sequence[str]) -> str | None:
+    for value in values:
+        if not value.startswith("--"):
+            continue
+        option_name = value.partition("=")[0].replace("_", "-")
+        if len(option_name) > 2 and any(
+            reserved.startswith(option_name) for reserved in RESERVED_VLLM_FLAGS | INCOMPATIBLE_VLLM_FLAGS
+        ):
+            return option_name
+    return None
+
+
+def _tcp_port(value: str) -> int:
+    try:
+        port = int(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError("must be between 1 and 65535") from error
+    if not 1 <= port <= 65_535:
+        raise argparse.ArgumentTypeError("must be between 1 and 65535")
+    return port
+
+
+def _bounded_timeout(value: str) -> float:
+    try:
+        timeout = float(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(
+            f"must be finite and greater than 0, up to {MAX_TIMEOUT_S:g} seconds"
+        ) from error
+    if not math.isfinite(timeout) or not 0 < timeout <= MAX_TIMEOUT_S:
+        raise argparse.ArgumentTypeError(f"must be finite and greater than 0, up to {MAX_TIMEOUT_S:g} seconds")
+    return timeout
+
+
+def _normalize_base_url(parser: argparse.ArgumentParser, value: str) -> str:
+    if any(character.isspace() for character in value):
+        parser.error("--vllm-base-url must not contain whitespace")
+
+    try:
+        parsed = urlparse(value)
+        hostname = parsed.hostname
+        port = parsed.port
+    except ValueError as error:
+        parser.error(f"--vllm-base-url is malformed: {error}")
+
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc or not hostname:
+        parser.error("--vllm-base-url must be an http:// or https:// base URL")
+    if parsed.username is not None or parsed.password is not None:
+        parser.error("--vllm-base-url must not contain credentials; use an environment variable for API keys")
+    if port is not None and not 1 <= port <= 65_535:
+        parser.error("--vllm-base-url port must be between 1 and 65535")
+    if parsed.query or parsed.fragment:
+        parser.error("--vllm-base-url must not include a query string or fragment")
+    return value.rstrip("/")

agentic_api/compatibility.py

@@ -0,0 +1 @@
+SUPPORTED_VLLM_VERSION = "0.11.0"

agentic_api/diagnostics.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+from dataclasses import asdict, dataclass
+from importlib.metadata import PackageNotFoundError, version as metadata_version
+from pathlib import Path
+
+from agentic_api import __version__
+from agentic_api.binary import (
+    PackagedBinaryNotFoundError,
+    PackagedBinaryVersionError,
+    find_active_environment_executable,
+    find_packaged_binary,
+    read_binary_version,
+)
+from agentic_api.compatibility import SUPPORTED_VLLM_VERSION
+
+
+@dataclass(frozen=True)
+class DoctorReport:
+    python_version: str
+    platform_summary: str
+    package_version: str
+    rust_binary_path: str
+    rust_binary_executable: bool
+    rust_binary_version: str
+    supported_vllm_version: str
+    installed_vllm_version: str
+    vllm_executable_path: str
+    local_ok: bool
+    remote_ok: bool
+    local_message: str
+    remote_message: str
+
+
+def doctor(mode: str | None, *, json_output: bool = False) -> int:
+    report = collect_doctor_report()
+    print(render_doctor_report(report, mode, json_output=json_output))
+
+    if mode == "local":
+        return 0 if report.local_ok else 1
+    if mode == "remote":
+        return 0 if report.remote_ok else 1
+    return 0 if report.remote_ok else 1
+
+
+def collect_doctor_report() -> DoctorReport:
+    rust_binary_path, rust_binary_executable, rust_binary_version = _rust_binary_details()
+    package_version = _package_version("agentic-api")
+    installed_vllm_version = _package_version("vllm")
+    try:
+        vllm_executable_path = str(find_active_environment_executable("vllm"))
+    except FileNotFoundError:
+        vllm_executable_path = "not found"
+    local_runtime_ok, local_message = _local_health(
+        installed_vllm_version,
+        vllm_executable_path,
+        platform_name=platform.system(),
+    )
+    remote_ok = rust_binary_executable and not rust_binary_version.startswith("error:")
+    remote_message = _remote_health_message(rust_binary_executable, rust_binary_version)
+    if local_runtime_ok and not remote_ok:
+        local_message = remote_message
+
+    return DoctorReport(
+        python_version=platform.python_version(),
+        platform_summary=f"{platform.system()} {platform.machine()}",
+        package_version=package_version,
+        rust_binary_path=rust_binary_path,
+        rust_binary_executable=rust_binary_executable,
+        rust_binary_version=rust_binary_version,
+        supported_vllm_version=SUPPORTED_VLLM_VERSION,
+        installed_vllm_version=installed_vllm_version,
+        vllm_executable_path=vllm_executable_path,
+        local_ok=local_runtime_ok and remote_ok,
+        remote_ok=remote_ok,
+        local_message=local_message,
+        remote_message=remote_message,
+    )
+
+
+def render_doctor_report(report: DoctorReport, mode: str | None, *, json_output: bool = False) -> str:
+    if json_output:
+        payload = asdict(report)
+        payload["selected_mode"] = mode or "all"
+        return json.dumps(payload, sort_keys=True)
+
+    local_health = "ok" if report.local_ok else "unavailable"
+    remote_health = "ok" if report.remote_ok else "unavailable"
+
+    lines = [
+        f"Selected mode: {mode or 'all'}",
+        f"Python version: {report.python_version}",
+        f"Platform: {report.platform_summary}",
+        f"agentic-api version: {report.package_version}",
+        f"Rust binary path: {report.rust_binary_path}",
+        f"Rust binary executable: {'yes' if report.rust_binary_executable else 'no'}",
+        f"Rust binary version: {report.rust_binary_version}",
+        f"Supported vLLM version: {report.supported_vllm_version}",
+        f"Installed vLLM version: {report.installed_vllm_version}",
+        f"vLLM executable path: {report.vllm_executable_path}",
+        f"Local mode health: {local_health}",
+        f"Local mode details: {report.local_message}",
+        f"Remote mode health: {remote_health}",
+        f"Remote mode details: {report.remote_message}",
+    ]
+    return "\n".join(lines)
+
+
+def _package_version(name: str) -> str:
+    try:
+        return metadata_version(name)
+    except PackageNotFoundError:
+        return "not installed"
+
+
+def _rust_binary_details() -> tuple[str, bool, str]:
+    try:
+        path = find_packaged_binary("agentic-server")
+    except PackagedBinaryNotFoundError as error:
+        return ("not found", False, f"error: {error}")
+
+    executable = path.is_file() and os.access(path, os.X_OK)
+    try:
+        version = read_binary_version(path)
+    except PackagedBinaryVersionError as error:
+        version = f"error: {error}"
+    return (str(path), executable, version)
+
+
+def _local_health(
+    installed_vllm_version: str,
+    vllm_executable_path: str,
+    *,
+    platform_name: str,
+) -> tuple[bool, str]:
+    if platform_name != "Linux":
+        return (
+            False,
+            "Local mode is currently supported only on Linux because the [local] extra installs vLLM only on Linux. "
+            "Use remote mode on this platform, or run local mode on Linux.",
+        )
+
+    install_hint = (
+        "Install the agentic-api wheel artifact with its local extra: "
+        '`uv pip install "agentic-api[local] @ file:///path/to/agentic_api-PLATFORM.whl"`.'
+    )
+    if installed_vllm_version == "not installed":
+        return (False, install_hint)
+    if installed_vllm_version != SUPPORTED_VLLM_VERSION:
+        return (
+            False,
+            f"Installed vLLM does not match the tested version {SUPPORTED_VLLM_VERSION}. {install_hint}",
+        )
+    if vllm_executable_path == "not found":
+        return (
+            False,
+            f"The installed vLLM package does not provide a `vllm` executable in the active Python environment. "
+            f"{install_hint}",
+        )
+    return (True, "The tested local vLLM package and executable are available.")
+
+
+def _remote_health_message(rust_binary_executable: bool, rust_binary_version: str) -> str:
+    if not rust_binary_executable:
+        return "The packaged Rust gateway executable is missing or not executable."
+    if rust_binary_version.startswith("error:"):
+        return "The packaged Rust gateway executable could not report its version."
+    return "The packaged Rust gateway executable is available; remote mode does not require vLLM."

agentic_api/launcher.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import os
+import signal
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from agentic_api.binary import (
+    PackagedBinaryNotFoundError,
+    find_active_environment_executable,
+    find_packaged_binary,
+)
+from agentic_api.cli import ServeOptions
+from agentic_api.compatibility import SUPPORTED_VLLM_VERSION
+from agentic_api.process import ChildResult, ProcessSupervisor, ShutdownRequested, wait_for_vllm_ready
+
+
+READY_INTERVAL_S = 2.0
+
+
+def run_serve(options: ServeOptions) -> int:
+    supervisor = ProcessSupervisor()
+    signal_exit_code: int | None = None
+    previous_handlers: list[tuple[int, object]] = []
+
+    def begin_shutdown(signum: int, _frame: object) -> None:
+        nonlocal signal_exit_code
+        if signal_exit_code is None:
+            signal_exit_code = _signal_exit_code(signum)
+        supervisor.request_shutdown(signum)
+
+    for signum in (signal.SIGINT, signal.SIGTERM):
+        previous_handlers.append((signum, signal.signal(signum, begin_shutdown)))
+
+    try:
+        if options.mode == "local":
+            result = _run_local_mode(supervisor, options)
+        elif options.mode == "remote":
+            result = _run_remote_mode(supervisor, options)
+        else:
+            raise ValueError(f"unsupported serve mode: {options.mode}")
+
+        if signal_exit_code is not None:
+            return signal_exit_code
+        return _normalize_exit_code(result)
+    except ShutdownRequested:
+        if signal_exit_code is not None:
+            return signal_exit_code
+        raise
+    except KeyboardInterrupt:
+        signal_exit_code = _signal_exit_code(signal.SIGINT)
+        supervisor.request_shutdown(signal.SIGINT)
+        return signal_exit_code
+    except (OSError, PackagedBinaryNotFoundError, RuntimeError, ValueError) as error:
+        if signal_exit_code is not None:
+            return signal_exit_code
+        print(str(error), file=sys.stderr)
+        return 1
+    finally:
+        supervisor.terminate_all(options.shutdown_timeout_s)
+        for signum, previous in previous_handlers:
+            signal.signal(signum, previous)
+
+
+def _run_local_mode(supervisor: ProcessSupervisor, options: ServeOptions) -> ChildResult:
+    if options.model is None:
+        raise ValueError("--model is required in local mode")
+    if sys.platform != "linux":
+        raise RuntimeError(
+            "agentic-api local mode is currently supported only on Linux; "
+            "use remote mode on this platform"
+        )
+
+    rust_binary = find_packaged_binary("agentic-server")
+    vllm_path = find_active_environment_executable("vllm")
+    installed_version = _installed_vllm_version()
+    if installed_version != SUPPORTED_VLLM_VERSION:
+        raise RuntimeError(
+            f"agentic-api local mode requires vllm=={SUPPORTED_VLLM_VERSION}; found {installed_version}"
+        )
+
+    vllm_api_key = os.environ.get(options.vllm_api_key_env)
+    vllm_url = f"http://127.0.0.1:{options.vllm_port}"
+
+    vllm_process = supervisor.start(
+        [
+            str(vllm_path),
+            "serve",
+            options.model,
+            *options.vllm_args,
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(options.vllm_port),
+        ],
+        _vllm_environment(vllm_api_key),
+    )
+    wait_for_vllm_ready(
+        base_url=vllm_url,
+        api_key=vllm_api_key,
+        process=vllm_process,
+        timeout=options.startup_timeout_s,
+        interval=READY_INTERVAL_S,
+        shutdown_requested=supervisor.shutdown_requested,
+    )
+
+    supervisor.start(
+        _rust_command(options, vllm_url, binary=rust_binary),
+        _rust_environment(options.gateway_api_key_env, vllm_api_key),
+    )
+    return supervisor.wait_for_failure()
+
+
+def _run_remote_mode(supervisor: ProcessSupervisor, options: ServeOptions) -> ChildResult:
+    if options.vllm_base_url is None:
+        raise ValueError("--vllm-base-url is required in remote mode")
+
+    supervisor.start(
+        _rust_command(options, options.vllm_base_url),
+        _rust_environment(options.gateway_api_key_env, None),
+    )
+    return supervisor.wait_for_failure()
+
+
+def _rust_command(options: ServeOptions, upstream_base_url: str, *, binary: Path | None = None) -> list[str]:
+    binary = binary or find_packaged_binary("agentic-server")
+    return [
+        str(binary),
+        "--llm-api-base",
+        upstream_base_url,
+        "--llm-ready-timeout-s",
+        str(options.startup_timeout_s),
+        "--gateway-host",
+        options.host,
+        "--gateway-port",
+        str(options.port),
+    ]
+
+
+def _rust_environment(gateway_api_key_env: str, api_key_override: str | None) -> dict[str, str]:
+    env = os.environ.copy()
+    gateway_api_key = api_key_override if api_key_override is not None else os.environ.get(gateway_api_key_env)
+    if gateway_api_key is not None:
+        env["OPENAI_API_KEY"] = gateway_api_key
+    elif gateway_api_key_env != "OPENAI_API_KEY":
+        env.pop("OPENAI_API_KEY", None)
+    return env
+
+
+def _vllm_environment(api_key: str | None) -> dict[str, str]:
+    env = os.environ.copy()
+    if api_key is not None:
+        env["VLLM_API_KEY"] = api_key
+    else:
+        env.pop("VLLM_API_KEY", None)
+    return env
+
+
+def _installed_vllm_version() -> str:
+    try:
+        return version("vllm")
+    except PackageNotFoundError as error:
+        raise RuntimeError(
+            f"agentic-api local mode requires vllm=={SUPPORTED_VLLM_VERSION}; install the [local] extra first"
+        ) from error
+
+
+def _normalize_exit_code(result: ChildResult) -> int:
+    if result.returncode == 0:
+        print(f"{result.name} exited unexpectedly with status 0", file=sys.stderr)
+        return 1
+    if result.returncode >= 0:
+        return result.returncode
+    return _signal_exit_code(-result.returncode)
+
+
+def _signal_exit_code(signum: int) -> int:
+    return 128 + int(signum)