Release build: e89c054

Author: actions-user

.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches:
+      - python-release
+
+jobs:
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Setup Python
+        run: uv python install 3.12
+
+      - name: Build the package
+        run: uv run --with build python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 teams_lib_pzsp2_z1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include teams_lib_pzsp2_z1/bin *

README.md

@@ -0,0 +1,32 @@
+[project]
+name = "teams_lib_pzsp2_z1"
+version = "0.1.12"
+description = "Bridge to Go client for Teams API"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "python-dotenv>=1.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.0",
+    "ruff>=0.14.4",
+    "pytest-httpserver>=1.1.3",
+]
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+target-version = "py312"
+fix = true
+show-fixes = true
+src = ["teams_lib_pzsp2_z1"]
+exclude = ["test_*.py", "tests/*"]
+
+
+[tool.ruff.lint]
+extend-select = ["I", "E", "W", "F", "C90", "B", "S", "UP", "PL"]
+
+[tool.setuptools]
+include-package-data = true

pyproject.toml

@@ -0,0 +1,119 @@
+import json
+import pathlib
+import platform
+import subprocess
+import threading
+from typing import Any
+
+from teams_lib_pzsp2_z1 import config
+from teams_lib_pzsp2_z1.services.channels import ChannelsService
+
+
+class TeamsClient:
+    def __init__(
+        self,
+        auto_init: bool = True,
+        env_path: str | None = None,
+        cache_enabled: bool = False,
+        cache_path: str | None = None,
+    ):
+        self._lock = threading.Lock()
+
+        self.proc = subprocess.Popen(  # noqa: S603
+            [str(self._binary())],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            bufsize=1,
+        )
+
+        self.env_path = env_path
+        self.channels = ChannelsService(self)
+
+        if auto_init:
+            self.init_client(cache_enabled, cache_path)
+
+    def _binary(self):
+        base = pathlib.Path(__file__).parent / "bin"
+        osname = platform.system()
+
+        if osname == "Windows":
+            return base / "teamsClientLib_windows.exe"
+        elif osname == "Linux":
+            return base / "teamsClientLib_linux"
+        else:
+            raise RuntimeError("Unsupported OS")
+
+    def init_client(
+        self, cache_enabled: bool = False, cache_path: str | None = None
+    ) -> Any:
+        sender_config = config.SenderConfig()
+        auth_config = config.load_auth_config(self.env_path)
+        return self.execute(
+            cmd_type="init",
+            config={
+                "senderConfig": {
+                    "maxRetries": sender_config.max_retries,
+                    "nextRetryDelay": sender_config.next_retry_delay,
+                    "timeout": sender_config.timeout,
+                },
+                "authConfig": {
+                    "clientID": auth_config.client_id,
+                    "tenant": auth_config.tenant,
+                    "email": auth_config.email,
+                    "scopes": auth_config.scopes,
+                    "authMethod": auth_config.auth_method,
+                },
+                "cacheEnabled": cache_enabled,
+                "cachePath": cache_path,
+            },
+        )
+
+    def init_fake_client(self, mock_server_url: str) -> Any:
+        return self.execute(
+            cmd_type="init",
+            params={
+                "mockServerUrl": mock_server_url,
+            },
+        )
+
+    def execute(
+        self,
+        cmd_type: str,
+        method: str | None = None,
+        config: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        payload = {"type": cmd_type}
+        if method:
+            payload["method"] = method
+        if params:
+            payload["params"] = params
+        if config:
+            payload["config"] = config
+
+        json_payload = json.dumps(payload)
+
+        # Critical section to avoid interleaving requests/responses
+        with self._lock:
+            try:
+                self.proc.stdin.write(json_payload + "\n")
+                self.proc.stdin.flush()
+
+                raw_response = self.proc.stdout.readline()
+            except BrokenPipeError:
+                raise RuntimeError("Go process crashed or closed connection")  # noqa: B904
+
+            if not raw_response:
+                raise RuntimeError("Go process returned empty response")
+
+            res = json.loads(raw_response)
+
+        if "error" in res and res["error"]:
+            raise RuntimeError(f"Go Error: {res['error']}")
+
+        return res.get("result")
+
+    def close(self):
+        self.proc.terminate()