pytdxfeed 0.2.0__tar.gz

pytdxfeed-0.2.0/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.pytest_cache/
+.ruff_cache/
+.venv/
+__pycache__/
+*.py[cod]
+dist/
+

pytdxfeed-0.2.0/AGENTS.md

@@ -0,0 +1,24 @@
+# AGENTS.md
+
+## Environment
+
+- This repository uses uv exclusively. Use `uv sync`, `uv run`, `uv lock`, and
+  `uv build`; do not add Poetry, pip, pipx, or repository-local environment
+  managers.
+- The package is private and Git-only. Do not publish it or its bundled
+  tdx-api binaries to PyPI or a public release while the upstream repository
+  has no declared license.
+- Before pushing, run `uv run ruff check .`, `uv run ruff format --check .`,
+  `uv run pytest`, and `uv build`.
+
+## Runtime contract
+
+- The service host is fixed at `127.0.0.1`; the explicit service port defaults
+  to `8080` and may be configured by consumers. Do not add configurable hosts,
+  base URLs, automatic free-port selection, or alternate service fallback.
+- The macOS runtime root is fixed at `~/.pytdxfeed` and the LaunchAgent label is
+  `com.hermanzhaozzzz.pytdxfeed.tdx-api`.
+- Never kill or reuse an unhealthy unknown configured-port owner. A strictly
+  healthy unknown tdx-api service on the configured port may be used without
+  taking ownership.
+- Market-data requests have no source fallback and no silent retry.

pytdxfeed-0.2.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pytdxfeed
+Version: 0.2.0
+Summary: Private macOS runtime and HTTP client for oficcejo/tdx-api.
+Author-email: Huanan Herman Zhao <hermanzhaozzzz@gmail.com>
+Requires-Python: <3.14,>=3.11
+Requires-Dist: requests<3.0.0,>=2.32.0
+Description-Content-Type: text/markdown
+
+# pytdxfeed
+
+`pytdxfeed` is a private Python wrapper around the local
+[`oficcejo/tdx-api`](https://github.com/oficcejo/tdx-api) service used by VQT
+and `vnpy_ths`. It provides one macOS LaunchAgent and one HTTP client contract,
+so both consumers share the same process instead of deploying competing copies.
+
+The package is installed only from the private Git repository. It is not the
+unrelated package formerly published under similar names on PyPI.
+
+## Runtime
+
+- Host: `127.0.0.1`
+- Port: `8080` by default; consumers may select another explicit port
+- Runtime root: `~/.pytdxfeed`
+- LaunchAgent: `com.hermanzhaozzzz.pytdxfeed.tdx-api`
+- Pinned upstream commit: `ea07dccb67aeb92ebde851ac31503b4bf457a318`
+
+On macOS, `ensure_service()` reuses an already healthy service or installs the
+bundled binary for the current architecture. The persistent upstream database
+is kept in `~/.pytdxfeed/data/database`. On other systems the function only
+checks an existing local service.
+
+```python
+from pytdxfeed import TdxApiClient, ensure_service
+
+service = ensure_service(port=18080)
+with TdxApiClient(timeout_sec=3.0, port=18080) as client:
+    health = client.health()
+    quotes = client.batch_quote(["sh600000", "sz159915"])
+```
+
+The host and LaunchAgent identity stay fixed. Port selection is explicit: the
+runtime never scans for a free port, and an unhealthy unknown process occupying
+the selected port causes startup to fail without terminating that process. The
+managed macOS service receives the selected port through `TDX_API_PORT`.
+
+## Development
+
+```bash
+uv sync --locked --all-groups
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest
+uv build
+```
+
+Regenerate the private macOS assets when the locked upstream commit or reviewed
+private patch set changes:
+
+```bash
+uv run python scripts/build_assets.py --source /path/to/tdx-api
+```
+
+The build verifies the exact clean upstream checkout, applies the patches in
+`patches/`, runs their Go tests, and records every patch checksum in the asset
+manifest. Artifact generation 3 retains explicit THS JSONP validation and adds
+strict `TDX_API_PORT` handling to the Go service. It does not retry or switch
+market-data sources.
+
+The upstream repository currently has no declared license. This repository and
+its derived binaries must remain private/internal until redistribution terms are
+clear.

pytdxfeed-0.2.0/README.md

@@ -0,0 +1,63 @@
+# pytdxfeed
+
+`pytdxfeed` is a private Python wrapper around the local
+[`oficcejo/tdx-api`](https://github.com/oficcejo/tdx-api) service used by VQT
+and `vnpy_ths`. It provides one macOS LaunchAgent and one HTTP client contract,
+so both consumers share the same process instead of deploying competing copies.
+
+The package is installed only from the private Git repository. It is not the
+unrelated package formerly published under similar names on PyPI.
+
+## Runtime
+
+- Host: `127.0.0.1`
+- Port: `8080` by default; consumers may select another explicit port
+- Runtime root: `~/.pytdxfeed`
+- LaunchAgent: `com.hermanzhaozzzz.pytdxfeed.tdx-api`
+- Pinned upstream commit: `ea07dccb67aeb92ebde851ac31503b4bf457a318`
+
+On macOS, `ensure_service()` reuses an already healthy service or installs the
+bundled binary for the current architecture. The persistent upstream database
+is kept in `~/.pytdxfeed/data/database`. On other systems the function only
+checks an existing local service.
+
+```python
+from pytdxfeed import TdxApiClient, ensure_service
+
+service = ensure_service(port=18080)
+with TdxApiClient(timeout_sec=3.0, port=18080) as client:
+    health = client.health()
+    quotes = client.batch_quote(["sh600000", "sz159915"])
+```
+
+The host and LaunchAgent identity stay fixed. Port selection is explicit: the
+runtime never scans for a free port, and an unhealthy unknown process occupying
+the selected port causes startup to fail without terminating that process. The
+managed macOS service receives the selected port through `TDX_API_PORT`.
+
+## Development
+
+```bash
+uv sync --locked --all-groups
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest
+uv build
+```
+
+Regenerate the private macOS assets when the locked upstream commit or reviewed
+private patch set changes:
+
+```bash
+uv run python scripts/build_assets.py --source /path/to/tdx-api
+```
+
+The build verifies the exact clean upstream checkout, applies the patches in
+`patches/`, runs their Go tests, and records every patch checksum in the asset
+manifest. Artifact generation 3 retains explicit THS JSONP validation and adds
+strict `TDX_API_PORT` handling to the Go service. It does not retry or switch
+market-data sources.
+
+The upstream repository currently has no declared license. This repository and
+its derived binaries must remain private/internal until redistribution terms are
+clear.

pytdxfeed-0.2.0/patches/tdx-api-configurable-port.patch

@@ -0,0 +1,85 @@
+diff --git a/web/server.go b/web/server.go
+--- a/web/server.go
++++ b/web/server.go
+@@ -8,5 +8,6 @@ import (
+ 	"net/http"
+ 	"os"
+ 	"path/filepath"
++	"strconv"
+ 	"strings"
+ 	"time"
+@@ -804,7 +805,25 @@ func main() {
+ 	http.HandleFunc("/api/tasks", handleListTasks)
+ 	http.HandleFunc("/api/tasks/", handleTaskOperations)
+ 
+-	port := ":8080"
+-	log.Printf("服务启动成功，访问 http://localhost%s\n", port)
+-	log.Fatal(http.ListenAndServe(port, nil))
++	address, err := resolveListenAddress()
++	if err != nil {
++		log.Fatalf("服务端口配置无效: %v", err)
++	}
++	log.Printf("服务启动成功，访问 http://localhost%s\n", address)
++	log.Fatal(http.ListenAndServe(address, nil))
+ }
++
++func resolveListenAddress() (string, error) {
++	raw, configured := os.LookupEnv("TDX_API_PORT")
++	if !configured || raw == "" {
++		return ":8080", nil
++	}
++	if raw != strings.TrimSpace(raw) {
++		return "", fmt.Errorf("TDX_API_PORT必须是1到65535之间的整数")
++	}
++	port, err := strconv.Atoi(raw)
++	if err != nil || port < 1 || port > 65535 {
++		return "", fmt.Errorf("TDX_API_PORT必须是1到65535之间的整数")
++	}
++	return fmt.Sprintf(":%d", port), nil
++}
+diff --git a/web/server_port_test.go b/web/server_port_test.go
+new file mode 100644
+--- /dev/null
++++ b/web/server_port_test.go
+@@ -0,0 +1,41 @@
++package main
++
++import "testing"
++
++func TestResolveListenAddress(t *testing.T) {
++	tests := []struct {
++		name    string
++		value   string
++		set     bool
++		want    string
++		wantErr bool
++	}{
++		{name: "unset", want: ":8080"},
++		{name: "empty", value: "", set: true, want: ":8080"},
++		{name: "custom", value: "18080", set: true, want: ":18080"},
++		{name: "zero", value: "0", set: true, wantErr: true},
++		{name: "too large", value: "65536", set: true, wantErr: true},
++		{name: "text", value: "http", set: true, wantErr: true},
++		{name: "whitespace", value: " 18080", set: true, wantErr: true},
++	}
++	for _, test := range tests {
++		t.Run(test.name, func(t *testing.T) {
++			if test.set {
++				t.Setenv("TDX_API_PORT", test.value)
++			}
++			got, err := resolveListenAddress()
++			if test.wantErr {
++				if err == nil {
++					t.Fatalf("expected error, got %q", got)
++				}
++				return
++			}
++			if err != nil {
++				t.Fatalf("unexpected error: %v", err)
++			}
++			if got != test.want {
++				t.Fatalf("got %q, want %q", got, test.want)
++			}
++		})
++	}
++}

pytdxfeed-0.2.0/patches/tdx-api-ths-response-validation.patch

@@ -0,0 +1,101 @@
+diff --git a/extend/spider-ths.go b/extend/spider-ths.go
+--- a/extend/spider-ths.go
++++ b/extend/spider-ths.go
+@@ -124,14 +124,19 @@ func GetTHSDayKline(code string, _type uint8) ([]*Kline, error) {
+ 		return nil, err
+ 	}
+ 
+ 	defer resp.Body.Close()
++	if resp.StatusCode != http.StatusOK {
++		return nil, fmt.Errorf("同花顺日K线HTTP状态异常: %s", resp.Status)
++	}
+ 	bs, err := io.ReadAll(resp.Body)
+ 	if err != nil {
+ 		return nil, err
+ 	}
+ 
+-	n := bytes.IndexByte(bs, '(')
+-	bs = bs[n+1 : len(bs)-1]
++	bs, err = parseTHSJSONPBody(bs)
++	if err != nil {
++		return nil, err
++	}
+ 
+ 	m := map[string]any{}
+ 	err = json.Unmarshal(bs, &m)
+@@ -196,3 +217,20 @@ func GetTHSDayKline(code string, _type uint8) ([]*Kline, error) {
+ 
+ 	return ls, nil
+ }
++
++func parseTHSJSONPBody(bs []byte) ([]byte, error) {
++	trimmed := bytes.TrimSpace(bs)
++	if len(trimmed) == 0 {
++		return nil, fmt.Errorf("同花顺日K线返回空响应")
++	}
++	open := bytes.IndexByte(trimmed, '(')
++	close := bytes.LastIndexByte(trimmed, ')')
++	if open < 0 || close <= open {
++		return nil, fmt.Errorf("同花顺日K线返回无效JSONP: bytes=%d", len(trimmed))
++	}
++	payload := bytes.TrimSpace(trimmed[open+1 : close])
++	if len(payload) == 0 {
++		return nil, fmt.Errorf("同花顺日K线JSONP内容为空")
++	}
++	return payload, nil
++}
+diff --git a/extend/spider-ths_test.go b/extend/spider-ths_test.go
+--- a/extend/spider-ths_test.go
++++ b/extend/spider-ths_test.go
+@@ -1,16 +1,43 @@
+ package extend
+ 
+ import (
++	"bytes"
+ 	"testing"
+ )
+ 
+-func TestNewSpiderTHS(t *testing.T) {
+-	ls, err := GetTHSDayKline("sz000001", THS_HFQ)
+-	if err != nil {
+-		t.Error(err)
+-		return
+-	}
+-	for _, v := range ls {
+-		t.Log(v)
++func TestParseTHSJSONPBody(t *testing.T) {
++	tests := []struct {
++		name    string
++		body    string
++		want    string
++		wantErr bool
++	}{
++		{name: "empty", body: "", wantErr: true},
++		{name: "whitespace", body: " \n\t", wantErr: true},
++		{name: "missing opener", body: `callback{"status":"ok"})`, wantErr: true},
++		{name: "missing closer", body: `callback({"status":"ok"}`, wantErr: true},
++		{name: "empty payload", body: "callback()", wantErr: true},
++		{
++			name: "valid with trailing semicolon",
++			body: "  callback({\"status\":\"ok\"});\n",
++			want: `{"status":"ok"}`,
++		},
++	}
++	for _, test := range tests {
++		t.Run(test.name, func(t *testing.T) {
++			got, err := parseTHSJSONPBody([]byte(test.body))
++			if test.wantErr {
++				if err == nil {
++					t.Fatalf("expected error, got %q", got)
++				}
++				return
++			}
++			if err != nil {
++				t.Fatalf("unexpected error: %v", err)
++			}
++			if !bytes.Equal(got, []byte(test.want)) {
++				t.Fatalf("got %q, want %q", got, test.want)
++			}
++		})
+ 	}
+ }

pytdxfeed-0.2.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "pytdxfeed"
+version = "0.2.0"
+description = "Private macOS runtime and HTTP client for oficcejo/tdx-api."
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+authors = [
+    { name = "Huanan Herman Zhao", email = "hermanzhaozzzz@gmail.com" },
+]
+dependencies = [
+    "requests>=2.32.0,<3.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0,<9.0.0",
+    "ruff>=0.12.0,<1.0.0",
+]
+
+[build-system]
+requires = ["hatchling>=1.27.0,<2.0.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pytdxfeed"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+    "/tests",
+    "/scripts",
+    "/patches",
+    "/README.md",
+    "/AGENTS.md",
+    "/pyproject.toml",
+    "/uv.lock",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["A", "B", "C4", "D", "E", "F", "I", "N", "PERF", "RUF", "S", "SIM", "UP", "W"]
+ignore = ["D105", "D107", "D203", "D213"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["D", "S101", "S108"]
+"scripts/**" = ["D103", "S603"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]

pytdxfeed-0.2.0/scripts/build_assets.py

@@ -0,0 +1,193 @@
+"""Build deterministic private macOS tdx-api assets for pytdxfeed."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+from pathlib import Path
+
+UPSTREAM_URL = "https://github.com/oficcejo/tdx-api.git"
+UPSTREAM_SHA = "ea07dccb67aeb92ebde851ac31503b4bf457a318"
+ARTIFACT_GENERATION = 3
+REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+PATCH_FILES = (
+    REPOSITORY_ROOT / "patches" / "tdx-api-ths-response-validation.patch",
+    REPOSITORY_ROOT / "patches" / "tdx-api-configurable-port.patch",
+)
+GO_VERSION_RE = re.compile(r"\bgo(\d+)\.(\d+)(?:\.\d+)?\b")
+ARCHITECTURES = ("arm64", "x86_64")
+GO_ARCHITECTURES = {"arm64": "arm64", "x86_64": "amd64"}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path(__file__).resolve().parents[1] / "src" / "pytdxfeed" / "assets",
+    )
+    args = parser.parse_args()
+
+    go = _require_go()
+    args.output.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="pytdxfeed-assets-") as temp_text:
+        temp = Path(temp_text)
+        source = args.source.expanduser().resolve() if args.source else temp / "source"
+        if args.source is None:
+            _run(["git", "clone", "--no-checkout", UPSTREAM_URL, str(source)])
+            _run(["git", "-C", str(source), "checkout", "--detach", UPSTREAM_SHA])
+        _verify_source(source)
+        _apply_patches(source)
+        _run([str(go), "test", "./extend"], cwd=source)
+        _run([str(go), "test", "./..."], cwd=source / "web")
+
+        assets: dict[str, dict[str, str]] = {}
+        for architecture in ARCHITECTURES:
+            root = temp / f"tdx-api-{architecture}"
+            binary = root / "bin" / "tdx-api"
+            binary.parent.mkdir(parents=True)
+            environment = {
+                **os.environ,
+                "CGO_ENABLED": "0",
+                "GOOS": "darwin",
+                "GOARCH": GO_ARCHITECTURES[architecture],
+            }
+            _run(
+                [
+                    str(go),
+                    "build",
+                    "-trimpath",
+                    "-ldflags=-s -w",
+                    "-o",
+                    str(binary),
+                    ".",
+                ],
+                cwd=source / "web",
+                env=environment,
+            )
+            binary.chmod(0o755)
+            shutil.copytree(source / "web" / "static", root / "static")
+            shutil.copytree(
+                source / "web" / "data" / "database",
+                root / "data" / "database",
+            )
+            filename = f"tdx-api-{UPSTREAM_SHA[:12]}-darwin-{architecture}.tar.gz"
+            archive = args.output / filename
+            _write_deterministic_archive(root, archive)
+            assets[architecture] = {
+                "filename": filename,
+                "sha256": _sha256(archive),
+            }
+
+    manifest = {
+        "schema_version": 1,
+        "api_major": 1,
+        "artifact_generation": ARTIFACT_GENERATION,
+        "upstream_url": UPSTREAM_URL,
+        "upstream_sha": UPSTREAM_SHA,
+        "patches": [
+            {"filename": patch.name, "sha256": _sha256(patch)} for patch in PATCH_FILES
+        ],
+        "assets": assets,
+    }
+    (args.output / "manifest.json").write_text(
+        json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _require_go() -> Path:
+    raw = shutil.which("go")
+    if raw is None:
+        raise SystemExit("Go 1.23+ is required to regenerate bundled assets")
+    result = _run([raw, "version"])
+    match = GO_VERSION_RE.search(result.stdout)
+    if match is None or (int(match.group(1)), int(match.group(2))) < (1, 23):
+        raise SystemExit(f"Go 1.23+ is required, found: {result.stdout.strip()}")
+    return Path(raw).resolve()
+
+
+def _verify_source(source: Path) -> None:
+    head = _run(["git", "-C", str(source), "rev-parse", "HEAD"]).stdout.strip()
+    if head != UPSTREAM_SHA:
+        raise SystemExit(f"source HEAD is {head}, expected {UPSTREAM_SHA}")
+    if not (source / "web" / "go.mod").is_file():
+        raise SystemExit(f"source does not contain web/go.mod: {source}")
+    status = _run(
+        ["git", "-C", str(source), "status", "--short", "--untracked-files=all"]
+    ).stdout.strip()
+    if status:
+        raise SystemExit(f"source checkout is dirty:\n{status}")
+
+
+def _apply_patches(source: Path) -> None:
+    for patch in PATCH_FILES:
+        if not patch.is_file():
+            raise SystemExit(f"required private patch is missing: {patch}")
+        _run(["git", "-C", str(source), "apply", "--check", str(patch)])
+        _run(["git", "-C", str(source), "apply", str(patch)])
+
+
+def _write_deterministic_archive(source: Path, destination: Path) -> None:
+    with (
+        destination.open("wb") as raw,
+        gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as compressed,
+        tarfile.open(mode="w", fileobj=compressed, format=tarfile.PAX_FORMAT) as tar,
+    ):
+        for path in sorted(source.rglob("*")):
+            relative = path.relative_to(source)
+            info = tar.gettarinfo(str(path), arcname=str(relative))
+            info.uid = 0
+            info.gid = 0
+            info.uname = ""
+            info.gname = ""
+            info.mtime = 0
+            if path.is_file():
+                with path.open("rb") as stream:
+                    tar.addfile(info, stream)
+            else:
+                tar.addfile(info)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _run(
+    command: list[str],
+    *,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(
+        command,
+        cwd=cwd,
+        env=env,
+        check=False,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    if result.returncode != 0:
+        rendered = " ".join(command)
+        raise SystemExit(
+            f"command failed ({result.returncode}): {rendered}\n{result.stdout}"
+        )
+    return result
+
+
+if __name__ == "__main__":
+    main()

pytdxfeed-0.2.0/src/pytdxfeed/__init__.py

@@ -0,0 +1,34 @@
+"""Shared tdx-api client and macOS runtime."""
+
+from pytdxfeed._version import __version__
+from pytdxfeed.client import (
+    BASE_URL,
+    DEFAULT_PORT,
+    HOST,
+    TdxApiClient,
+    local_base_url,
+    validate_port,
+)
+from pytdxfeed.errors import (
+    TdxApiDeploymentError,
+    TdxApiError,
+    TdxApiResponseError,
+    TdxApiTransportError,
+)
+from pytdxfeed.runtime import ServiceInfo, ensure_service
+
+__all__ = [
+    "BASE_URL",
+    "DEFAULT_PORT",
+    "HOST",
+    "ServiceInfo",
+    "TdxApiClient",
+    "TdxApiDeploymentError",
+    "TdxApiError",
+    "TdxApiResponseError",
+    "TdxApiTransportError",
+    "__version__",
+    "ensure_service",
+    "local_base_url",
+    "validate_port",
+]

pytdxfeed-0.2.0/src/pytdxfeed/_version.py

@@ -0,0 +1,3 @@
+"""Package version shared by runtime metadata and public exports."""
+
+__version__ = "0.2.0"

pytdxfeed-0.2.0/src/pytdxfeed/assets/manifest.json

@@ -0,0 +1,27 @@
+{
+  "api_major": 1,
+  "artifact_generation": 3,
+  "assets": {
+    "arm64": {
+      "filename": "tdx-api-ea07dccb67ae-darwin-arm64.tar.gz",
+      "sha256": "8b99f16639c248c3b634f613abfc9d8bd469f5428aa70b6f16ca38c700a7e8c5"
+    },
+    "x86_64": {
+      "filename": "tdx-api-ea07dccb67ae-darwin-x86_64.tar.gz",
+      "sha256": "9696b1332b826bb0d723da52cd3c558ae529ed31de6a6989f6d9e982659a4a31"
+    }
+  },
+  "patches": [
+    {
+      "filename": "tdx-api-ths-response-validation.patch",
+      "sha256": "6f27e36df68011cd60038b701b155788a7b90ad0cd7522c37144042cd6d17e20"
+    },
+    {
+      "filename": "tdx-api-configurable-port.patch",
+      "sha256": "f1c7d6824ce8f5c486d854a85ffab30ecef053e243b25b017c953b2b505e28a2"
+    }
+  ],
+  "schema_version": 1,
+  "upstream_sha": "ea07dccb67aeb92ebde851ac31503b4bf457a318",
+  "upstream_url": "https://github.com/oficcejo/tdx-api.git"
+}