pgfsm-async-worker-sdk 0.1.0__tar.gz

pgfsm_async_worker_sdk-0.1.0/LICENSE

@@ -0,0 +1,185 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and its derivative works thereof.
+
+      "Contribution" shall mean, as used in this License, any work of
+      authorship, including the original version of the Work and any
+      modifications or additions to that Work or Derivative Works of the
+      Work, that is intentionally submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and subsequently
+      incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or a Contribution
+      incorporated within the Work constitutes direct or contributory patent
+      infringement, then any patent licenses granted to You under this License
+      for that Work shall terminate as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the Work
+      or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You meet
+      the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative Works
+          a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works that
+          You distribute, all copyright, patent, trademark, and attribution
+          notices from the Source form of the Work, excluding those notices
+          that do not pertain to any part of the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the attribution
+          notices contained within such NOTICE file, in at least one of the
+          following places: within a NOTICE text file distributed as part of
+          the Derivative Works; within the Source form or documentation, if
+          provided along with the Derivative Works; or, within a display
+          generated by the Derivative Works, if and wherever such third-party
+          notices normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License. You may
+          add Your own attribution notices within Derivative Works that You
+          distribute, alongside or as an addendum to the NOTICE text from the
+          Work, provided that such additional attribution notices cannot be
+          construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and may
+      provide additional grant of rights to use, reproduce, modify, and
+      distribute Your modifications, or for such Derivative Works as a whole,
+      under terms and conditions of Your choice, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with the
+      conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any conditions of title,
+      non-infringement, merchantability, or fitness for a particular purpose.
+      You are solely responsible for determining the appropriateness of using
+      or redistributing the Work and assume any risks associated with Your
+      exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a result
+      of this License or out of the use or inability to use the Work
+      (including but not limited to damages for loss of goodwill, work
+      stoppage, computer failure or malfunction, or all other commercial
+      damages or losses), even if such Contributor has been advised of the
+      possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing the
+      Work or Derivative Works thereof, You may choose to offer, and charge
+      a fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may offer such obligations
+      only on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by, or
+      claims asserted against, such Contributor by reason of your accepting
+      any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2025 Niraj Kashyap
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pgfsm_async_worker_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: pgfsm-async-worker-sdk
+Version: 0.1.0
+Summary: Python worker SDK for the pgfsm Activity Gateway: registers actors and serves invocations over the sidecar gRPC stream.
+Author: Niraj Kashyap
+Author-email: Niraj Kashyap <niraj.38.re@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: pgfsm-proto-codegen>=0.1.1,<0.2
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/pgfsm/fsm
+Project-URL: Source, https://github.com/pgfsm/fsm/tree/main/packages/fsm-async-worker-sdk-python
+Description-Content-Type: text/markdown
+
+# pgfsm-async-worker-sdk
+
+Python worker SDK for the pgfsm Activity Gateway. A worker process built on it
+connects to the gateway's sidecar Unix socket, registers a set of actors, and
+serves the invocations the gateway routes to them over the
+`pgfsm.sidecargateway.v1.SidecarGatewayService` gRPC stream (stubs from
+[`pgfsm-proto-codegen`](https://pypi.org/project/pgfsm-proto-codegen/)).
+
+It never opens a database connection — that stays in the gateway.
+
+Python counterpart of the TypeScript
+[`@pgfsm/async-worker-sdk`](https://www.npmjs.com/package/@pgfsm/async-worker-sdk).
+
+## Usage
+
+You normally don't write against this package directly. `@pgfsm/compiler`'s
+`generate-async-logic` writes a small `run_async_worker.py` plus a
+`pyproject.toml` that pins this package:
+
+```python
+# async-worker/python/run_async_worker.py (generated)
+import logging
+import sys
+
+from pgfsm.async_worker_sdk import run_actor_worker_cli
+from python_actors_registry_generated import ACTOR_REGISTRATIONS
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    raise SystemExit(run_actor_worker_cli(ACTOR_REGISTRATIONS, sys.argv[1:]))
+```
+
+Run it from that directory with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv run run_async_worker.py list    # print the actors in the registry, no gateway needed
+uv run run_async_worker.py start   # connect to the gateway and serve invocations
+```
+
+or with pip: `python3 -m pip install pgfsm-async-worker-sdk`, then
+`python3 run_async_worker.py start`.
+
+### Options
+
+```
+-g, --gateway-socket <path>   Sidecar socket to connect to (default: /tmp/pgfsm-activity-gateway-workers.sock)
+-i, --worker-id <id>          Stable worker identity (default: python-<random>)
+    --heartbeat-ms <ms>       Heartbeat interval (default: 5000)
+-h, --help                    Show this help message
+```
+
+SIGINT/SIGTERM stop the worker gracefully (it unregisters from the gateway).
+
+## API
+
+- `run_actor_worker_cli(registrations, args, invocation=None) -> int` — the
+  `list`/`start` CLI. Returns the process exit code instead of exiting.
+- `ActorWorker(worker_id, gateway_socket_path, registrations, heartbeat_ms=5000)`
+  — `run()` registers every actor and serves invocations until `stop()` is
+  called or the gateway ends the stream.
+
+A registration is a dict:
+
+```python
+{
+    "parent_fsm_name": "creditCheck",
+    "parent_fsm_version": "v01",
+    "async_operation_type": "internalAsyncOperation",
+    "async_operation_name": "checkBureau",
+    "async_operation_version": "v01",
+    "async_operation_language": "python",
+    "handler": check_bureau,  # (input) -> JSON-serializable output; may be async
+}
+```
+
+A handler that raises is reported to the gateway as an `INTERNAL` invoke error;
+an invoke for an unregistered actor is reported as `NOT_FOUND`.
+
+Logging goes through the standard `logging` module (`pgfsm.async_worker_sdk`
+loggers); the library never configures logging itself.
+
+## Releasing (maintainers)
+
+Released from the [pgfsm/fsm](https://github.com/pgfsm/fsm) monorepo by
+`.github/workflows/pypi-publish.yml`. Pushing an
+`async-worker-sdk-py-v<version>` tag publishes to PyPI with trusted publishing
+(no API token). This package releases independently of
+[`pgfsm-proto-codegen`](https://pypi.org/project/pgfsm-proto-codegen/).
+
+1. **Pick the version.** While below 1.0: breaking API change → minor (`0.1.0` →
+   `0.2.0`); new backward-compatible features → minor; fixes only → patch
+   (`0.1.0` → `0.1.1`).
+2. **Bump it in a PR.** From `packages/fsm-async-worker-sdk-python`:
+
+   ```bash
+   uv version --bump minor     # or: --bump patch, or an exact version: uv version 0.2.0
+   ```
+
+   This updates `pyproject.toml` and `uv.lock` together; commit both. If the new
+   version needs a newer `pgfsm-proto-codegen`, release that first, then raise
+   the `pgfsm-proto-codegen>=` pin here.
+3. **Tag the merge commit and push the tag.** The tag must be exactly
+   `async-worker-sdk-py-v` + `uv version --short`:
+
+   ```bash
+   git fetch origin
+   git tag async-worker-sdk-py-v0.2.0 origin/main
+   git push origin async-worker-sdk-py-v0.2.0
+   ```
+
+4. **Check the release.** `gh run list --workflow pypi-publish.yml` shows the
+   run, which checks the tag against `pyproject.toml`, runs the tests, builds,
+   and uploads. Then confirm https://pypi.org/project/pgfsm-async-worker-sdk/
+   lists the version and it installs:
+   `pip install pgfsm-async-worker-sdk==0.2.0`.
+
+For prereleases, uv writes the version in PEP 440 form
+(`uv version 0.2.0-alpha.0` stores `0.2.0a0`), so tag
+`async-worker-sdk-py-v0.2.0a0`. pip only installs a prerelease if asked
+explicitly (`--pre` or an exact `==` version).
+
+A published version can never be re-uploaded. If a bad version ships, release
+the next patch and yank the bad one on pypi.org. Yanked versions stay
+installable when pinned exactly, but resolvers skip them otherwise.
+
+## License
+
+Apache-2.0

pgfsm_async_worker_sdk-0.1.0/README.md

@@ -0,0 +1,128 @@
+# pgfsm-async-worker-sdk
+
+Python worker SDK for the pgfsm Activity Gateway. A worker process built on it
+connects to the gateway's sidecar Unix socket, registers a set of actors, and
+serves the invocations the gateway routes to them over the
+`pgfsm.sidecargateway.v1.SidecarGatewayService` gRPC stream (stubs from
+[`pgfsm-proto-codegen`](https://pypi.org/project/pgfsm-proto-codegen/)).
+
+It never opens a database connection — that stays in the gateway.
+
+Python counterpart of the TypeScript
+[`@pgfsm/async-worker-sdk`](https://www.npmjs.com/package/@pgfsm/async-worker-sdk).
+
+## Usage
+
+You normally don't write against this package directly. `@pgfsm/compiler`'s
+`generate-async-logic` writes a small `run_async_worker.py` plus a
+`pyproject.toml` that pins this package:
+
+```python
+# async-worker/python/run_async_worker.py (generated)
+import logging
+import sys
+
+from pgfsm.async_worker_sdk import run_actor_worker_cli
+from python_actors_registry_generated import ACTOR_REGISTRATIONS
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    raise SystemExit(run_actor_worker_cli(ACTOR_REGISTRATIONS, sys.argv[1:]))
+```
+
+Run it from that directory with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv run run_async_worker.py list    # print the actors in the registry, no gateway needed
+uv run run_async_worker.py start   # connect to the gateway and serve invocations
+```
+
+or with pip: `python3 -m pip install pgfsm-async-worker-sdk`, then
+`python3 run_async_worker.py start`.
+
+### Options
+
+```
+-g, --gateway-socket <path>   Sidecar socket to connect to (default: /tmp/pgfsm-activity-gateway-workers.sock)
+-i, --worker-id <id>          Stable worker identity (default: python-<random>)
+    --heartbeat-ms <ms>       Heartbeat interval (default: 5000)
+-h, --help                    Show this help message
+```
+
+SIGINT/SIGTERM stop the worker gracefully (it unregisters from the gateway).
+
+## API
+
+- `run_actor_worker_cli(registrations, args, invocation=None) -> int` — the
+  `list`/`start` CLI. Returns the process exit code instead of exiting.
+- `ActorWorker(worker_id, gateway_socket_path, registrations, heartbeat_ms=5000)`
+  — `run()` registers every actor and serves invocations until `stop()` is
+  called or the gateway ends the stream.
+
+A registration is a dict:
+
+```python
+{
+    "parent_fsm_name": "creditCheck",
+    "parent_fsm_version": "v01",
+    "async_operation_type": "internalAsyncOperation",
+    "async_operation_name": "checkBureau",
+    "async_operation_version": "v01",
+    "async_operation_language": "python",
+    "handler": check_bureau,  # (input) -> JSON-serializable output; may be async
+}
+```
+
+A handler that raises is reported to the gateway as an `INTERNAL` invoke error;
+an invoke for an unregistered actor is reported as `NOT_FOUND`.
+
+Logging goes through the standard `logging` module (`pgfsm.async_worker_sdk`
+loggers); the library never configures logging itself.
+
+## Releasing (maintainers)
+
+Released from the [pgfsm/fsm](https://github.com/pgfsm/fsm) monorepo by
+`.github/workflows/pypi-publish.yml`. Pushing an
+`async-worker-sdk-py-v<version>` tag publishes to PyPI with trusted publishing
+(no API token). This package releases independently of
+[`pgfsm-proto-codegen`](https://pypi.org/project/pgfsm-proto-codegen/).
+
+1. **Pick the version.** While below 1.0: breaking API change → minor (`0.1.0` →
+   `0.2.0`); new backward-compatible features → minor; fixes only → patch
+   (`0.1.0` → `0.1.1`).
+2. **Bump it in a PR.** From `packages/fsm-async-worker-sdk-python`:
+
+   ```bash
+   uv version --bump minor     # or: --bump patch, or an exact version: uv version 0.2.0
+   ```
+
+   This updates `pyproject.toml` and `uv.lock` together; commit both. If the new
+   version needs a newer `pgfsm-proto-codegen`, release that first, then raise
+   the `pgfsm-proto-codegen>=` pin here.
+3. **Tag the merge commit and push the tag.** The tag must be exactly
+   `async-worker-sdk-py-v` + `uv version --short`:
+
+   ```bash
+   git fetch origin
+   git tag async-worker-sdk-py-v0.2.0 origin/main
+   git push origin async-worker-sdk-py-v0.2.0
+   ```
+
+4. **Check the release.** `gh run list --workflow pypi-publish.yml` shows the
+   run, which checks the tag against `pyproject.toml`, runs the tests, builds,
+   and uploads. Then confirm https://pypi.org/project/pgfsm-async-worker-sdk/
+   lists the version and it installs:
+   `pip install pgfsm-async-worker-sdk==0.2.0`.
+
+For prereleases, uv writes the version in PEP 440 form
+(`uv version 0.2.0-alpha.0` stores `0.2.0a0`), so tag
+`async-worker-sdk-py-v0.2.0a0`. pip only installs a prerelease if asked
+explicitly (`--pre` or an exact `==` version).
+
+A published version can never be re-uploaded. If a bad version ships, release
+the next patch and yank the bad one on pypi.org. Yanked versions stay
+installable when pinned exactly, but resolvers skip them otherwise.
+
+## License
+
+Apache-2.0

pgfsm_async_worker_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "pgfsm-async-worker-sdk"
+version = "0.1.0"
+description = "Python worker SDK for the pgfsm Activity Gateway: registers actors and serves invocations over the sidecar gRPC stream."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+dependencies = ["pgfsm-proto-codegen>=0.1.1,<0.2"]
+
+[[project.authors]]
+name = "Niraj Kashyap"
+email = "niraj.38.re@gmail.com"
+
+[project.urls]
+Repository = "https://github.com/pgfsm/fsm"
+Source = "https://github.com/pgfsm/fsm/tree/main/packages/fsm-async-worker-sdk-python"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.uv.build-backend]
+module-name = "pgfsm.async_worker_sdk"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["uv_build>=0.10.12,<0.11.0"]
+build-backend = "uv_build"

pgfsm_async_worker_sdk-0.1.0/pyproject.toml.orig

@@ -0,0 +1,38 @@
+# Python worker SDK for the pgfsm Activity Gateway — see CLAUDE.md. Managed
+# with uv (`uv sync`, `uv run pytest`, `uv build`). Published to PyPI as
+# pgfsm-async-worker-sdk by .github/workflows/pypi-publish.yml from an
+# `async-worker-sdk-py-v<version>` tag.
+[project]
+name = "pgfsm-async-worker-sdk"
+version = "0.1.0"
+description = "Python worker SDK for the pgfsm Activity Gateway: registers actors and serves invocations over the sidecar gRPC stream."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Niraj Kashyap", email = "niraj.38.re@gmail.com" }]
+# protobuf>=7.35 (via pgfsm-proto-codegen) needs 3.10+.
+requires-python = ">=3.10"
+dependencies = [
+  # Generated pgfsm.sidecargateway.v1 client stubs; brings grpcio/protobuf.
+  "pgfsm-proto-codegen>=0.1.1,<0.2",
+]
+
+[project.urls]
+Repository = "https://github.com/pgfsm/fsm"
+Source = "https://github.com/pgfsm/fsm/tree/main/packages/fsm-async-worker-sdk-python"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.uv.build-backend]
+# `pgfsm` is a namespace package shared with pgfsm-proto-codegen
+# (pgfsm.sidecargateway, pgfsm.activitygateway), so there's no
+# src/pgfsm/__init__.py.
+module-name = "pgfsm.async_worker_sdk"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["uv_build>=0.10.12,<0.11.0"]
+build-backend = "uv_build"

pgfsm_async_worker_sdk-0.1.0/src/pgfsm/async_worker_sdk/__init__.py

@@ -0,0 +1,22 @@
+"""Python worker SDK for the pgfsm Activity Gateway (pgfsm-async-worker-sdk)."""
+
+from .actor_worker import (
+    DEFAULT_HEARTBEAT_MS,
+    ActorHandler,
+    ActorRegistration,
+    ActorWorker,
+    ProtocolError,
+    actor_key,
+)
+from .cli import DEFAULT_GATEWAY_SOCKET_PATH, run_actor_worker_cli
+
+__all__ = [
+    "DEFAULT_GATEWAY_SOCKET_PATH",
+    "DEFAULT_HEARTBEAT_MS",
+    "ActorHandler",
+    "ActorRegistration",
+    "ActorWorker",
+    "ProtocolError",
+    "actor_key",
+    "run_actor_worker_cli",
+]

pgfsm_async_worker_sdk-0.1.0/src/pgfsm/async_worker_sdk/actor_worker.py

@@ -0,0 +1,266 @@
+"""ActorWorker: the client end of the Activity Gateway's sidecar leg.
+
+Moved here from fsm-compiler-ts's python/worker-sdk-sdk.eta (#364), which used
+to write this whole module into every project as `async-worker/python/sdk.py`.
+
+Connects to the gateway's sidecar Unix socket via the generated
+pgfsm.sidecargateway.v1.SidecarGatewayService bidi-streaming client (from the
+`pgfsm-proto-codegen` package), registers actors from a compiler-generated
+registry, and serves invoke requests.
+
+Python counterpart of @pgfsm/async-worker-sdk's ActorWorker — same actor_key()
+identity (parent_fsm_name@parent_fsm_version@async_operation_type@async_operation_name@async_operation_version@
+async_operation_language), same register -> heartbeat -> serve lifecycle.
+Outgoing messages (register, heartbeat, invoke_result, invoke_error) are pushed
+onto a thread-safe queue.Queue that doubles as the request generator grpc's
+synchronous stream_stream stub drains on its own thread — the natural Python
+analogue of @pgfsm/async-worker-sdk's push-based AsyncQueue, and a better fit
+than a second manual reader/writer thread pair for the same duplex stream.
+
+`ActorWorker` takes the registry's list of dicts (parent_fsm_name/
+parent_fsm_version/async_operation_type/async_operation_name/
+async_operation_version/async_operation_language/handler) directly; it stays
+registry-source-agnostic so it's easy to test with a synthetic list. The
+generated `run_async_worker.py` is what wires it to that project's registry,
+via `run_actor_worker_cli` (see cli.py).
+
+Logging is not configured here: this module only calls `logging.getLogger()`.
+The generated entry point configures logging once.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import queue
+import threading
+import time
+from typing import Any, Callable, Dict, Iterator, List, Optional
+
+import grpc
+from pgfsm.sidecargateway.v1 import sidecar_gateway_pb2 as pb
+from pgfsm.sidecargateway.v1 import sidecar_gateway_pb2_grpc as pb_grpc
+
+logger = logging.getLogger("pgfsm.async_worker_sdk")
+
+ActorHandler = Callable[[Any], Any]
+ActorRegistration = Dict[str, Any]
+
+DEFAULT_HEARTBEAT_MS = 5000
+
+
+class ProtocolError(Exception):
+    pass
+
+
+def actor_key(
+    parent_fsm_name: str,
+    parent_fsm_version: str,
+    async_operation_type: str,
+    async_operation_name: str,
+    async_operation_version: str,
+    async_operation_language: str,
+) -> str:
+    return (
+        f"{parent_fsm_name}@{parent_fsm_version}@{async_operation_type}@{async_operation_name}"
+        f"@{async_operation_version}@{async_operation_language}"
+    )
+
+
+def _parse_input_json(input_json: str) -> Any:
+    if not input_json.strip():
+        return None
+    return json.loads(input_json)
+
+
+class ActorWorker:
+    def __init__(
+        self,
+        worker_id: str,
+        gateway_socket_path: str,
+        registrations: List[ActorRegistration],
+        heartbeat_ms: int = DEFAULT_HEARTBEAT_MS,
+    ) -> None:
+        self.worker_id = worker_id
+        self.language = "python"
+        self.gateway_socket_path = gateway_socket_path
+        self.registrations = registrations
+        self.heartbeat_ms = heartbeat_ms
+
+        self._handlers: Dict[str, ActorHandler] = {}
+        self._stopped = False
+        self._outbox: "queue.Queue[Optional[pb.SessionRequest]]" = queue.Queue()
+        self._channel: Optional[grpc.Channel] = None
+
+    def run(self) -> None:
+        """Registers every actor and serves invocations until `stop()` is
+        called or the gateway ends the stream. Closes the gRPC channel before
+        returning."""
+        if not self.registrations:
+            raise ValueError("no actors to register, refusing to start worker")
+
+        registered_actors = []
+        for reg in self.registrations:
+            key = actor_key(
+                reg["parent_fsm_name"],
+                reg["parent_fsm_version"],
+                reg["async_operation_type"],
+                reg["async_operation_name"],
+                reg["async_operation_version"],
+                reg["async_operation_language"],
+            )
+            self._handlers[key] = reg["handler"]
+            registered_actors.append(
+                pb.RegisteredActor(
+                    parent_fsm_name=reg["parent_fsm_name"],
+                    parent_fsm_version=reg["parent_fsm_version"],
+                    async_operation_type=reg["async_operation_type"],
+                    async_operation_name=reg["async_operation_name"],
+                    async_operation_version=reg["async_operation_version"],
+                    async_operation_language=reg["async_operation_language"],
+                )
+            )
+
+        # grpc-core sends the socket path itself as the HTTP/2 `:authority`
+        # for a bare `unix://` target, which a plain (non-grpc-core) HTTP/2
+        # server -- the gateway's connect-node adapter -- can't parse as a
+        # host. `grpc.default_authority` overrides it with an ordinary
+        # hostname, the standard fix for local/UDS channels against such
+        # servers.
+        self._channel = grpc.insecure_channel(
+            f"unix://{self.gateway_socket_path}",
+            options=[("grpc.default_authority", "localhost")],
+        )
+        try:
+            self._run_session(pb_grpc.SidecarGatewayServiceStub(self._channel), registered_actors)
+        finally:
+            # Ends the request stream on every exit path (including a rejected
+            # registration) before the channel goes away.
+            self.stop()
+            self._channel.close()
+            self._channel = None
+
+    def stop(self) -> None:
+        if self._stopped:
+            return
+        self._stopped = True
+        self._outbox.put(
+            pb.SessionRequest(unregister=pb.Unregister(worker_id=self.worker_id))
+        )
+        self._outbox.put(None)
+
+    def _run_session(
+        self,
+        stub: pb_grpc.SidecarGatewayServiceStub,
+        registered_actors: List[pb.RegisteredActor],
+    ) -> None:
+        self._outbox.put(
+            pb.SessionRequest(
+                register=pb.Register(
+                    worker_id=self.worker_id,
+                    language=self.language,
+                    protocol_version="1.0",
+                    actors=registered_actors,
+                )
+            )
+        )
+
+        response_iter = iter(stub.Session(self._request_iterator()))
+
+        try:
+            first = next(response_iter)
+        except StopIteration:
+            raise ProtocolError("expected register_ack but got EOF") from None
+        if first.WhichOneof("payload") != "register_ack":
+            raise ProtocolError(
+                f"expected register_ack but got {first.WhichOneof('payload')}"
+            )
+        if not first.register_ack.accepted:
+            raise ProtocolError("gateway rejected registration")
+
+        logger.info(
+            "Worker %s registered %d actor(s) with the gateway",
+            self.worker_id,
+            len(registered_actors),
+        )
+
+        heartbeat_thread = threading.Thread(target=self._heartbeat_loop, daemon=True)
+        heartbeat_thread.start()
+
+        self._serve_loop(response_iter)
+
+    def _request_iterator(self) -> Iterator[pb.SessionRequest]:
+        while True:
+            item = self._outbox.get()
+            if item is None:
+                return
+            yield item
+
+    def _heartbeat_loop(self) -> None:
+        while not self._stopped:
+            time.sleep(self.heartbeat_ms / 1000)
+            if self._stopped:
+                break
+            self._outbox.put(
+                pb.SessionRequest(heartbeat=pb.Heartbeat(worker_id=self.worker_id))
+            )
+
+    def _serve_loop(self, response_iter: Iterator[pb.SessionResponse]) -> None:
+        for response in response_iter:
+            if self._stopped:
+                break
+            case = response.WhichOneof("payload")
+            if case == "cancel":
+                continue
+            if case != "invoke":
+                continue
+            self._handle_invoke(response.invoke)
+
+    def _handle_invoke(self, body: "pb.Invoke") -> None:
+        key = actor_key(
+            body.parent_fsm_name,
+            body.parent_fsm_version,
+            body.async_operation_type,
+            body.async_operation_name,
+            body.async_operation_version,
+            body.async_operation_language,
+        )
+        handler = self._handlers.get(key)
+
+        if handler is None:
+            self._send_error(body.invoke_id, "NOT_FOUND", f"actor not found: {key}")
+            return
+
+        started = time.perf_counter()
+        try:
+            input_value = _parse_input_json(body.input_json)
+            if asyncio.iscoroutinefunction(handler):
+                output = asyncio.run(handler(input_value))
+            else:
+                output = handler(input_value)
+            duration_ms = max(0, round((time.perf_counter() - started) * 1000))
+            self._outbox.put(
+                pb.SessionRequest(
+                    invoke_result=pb.InvokeResult(
+                        invoke_id=body.invoke_id,
+                        output_json=json.dumps(output),
+                        duration_ms=duration_ms,
+                    )
+                )
+            )
+        except Exception as exc:  # noqa: BLE001 — reported to the gateway, not raised
+            logger.debug("Actor %s failed: %s", key, exc, exc_info=True)
+            self._send_error(body.invoke_id, "INTERNAL", str(exc))
+
+    def _send_error(self, invoke_id: str, code: str, message: str) -> None:
+        self._outbox.put(
+            pb.SessionRequest(
+                invoke_error=pb.InvokeError(
+                    invoke_id=invoke_id,
+                    error=pb.InvokeErrorDetail(
+                        code=code, message=message, retriable=False
+                    ),
+                )
+            )
+        )

pgfsm_async_worker_sdk-0.1.0/src/pgfsm/async_worker_sdk/cli.py

@@ -0,0 +1,167 @@
+"""`list`/`start` command handling for a compiler-generated
+`run_async_worker.py` — moved here from fsm-compiler-ts's
+python/worker-sdk-cli.eta (#364), which used to write this whole file into
+every project as `async-worker/python/cli.py`.
+
+Python counterpart of @pgfsm/async-worker-sdk's runActorWorkerCli. Logging is
+not configured here; the generated entry point configures it once before
+calling this.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import signal
+import threading
+import uuid
+from typing import List, Optional, Sequence
+
+from .actor_worker import DEFAULT_HEARTBEAT_MS, ActorRegistration, ActorWorker
+
+logger = logging.getLogger("pgfsm.async_worker_sdk.cli")
+
+DEFAULT_GATEWAY_SOCKET_PATH = "/tmp/pgfsm-activity-gateway-workers.sock"
+
+_DESCRIPTION = """\
+pgfsm-async-worker-sdk — Python worker for the Activity Gateway
+
+commands:
+  list    Print the actors compiled into this registry, without connecting to the gateway.
+  start   Connect to the gateway and serve invocations for every actor in the registry until stopped.
+
+Actors come from a compiler-generated registry (see fsm-compiler-ts's
+writeAggregateActorsRegistry) -- statically imported, not scanned or
+dynamically loaded at startup.
+"""
+
+
+class _UsageError(Exception):
+    pass
+
+
+class _ArgumentParser(argparse.ArgumentParser):
+    """Raises instead of calling sys.exit(), so run_actor_worker_cli can turn a
+    usage error into an exit code."""
+
+    def error(self, message: str) -> None:  # type: ignore[override]
+        raise _UsageError(message)
+
+
+def _build_parser(invocation: str) -> _ArgumentParser:
+    parser = _ArgumentParser(
+        prog=invocation,
+        description=_DESCRIPTION,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"example:\n  {invocation} start --gateway-socket {DEFAULT_GATEWAY_SOCKET_PATH}",
+        add_help=False,
+    )
+    parser.add_argument("command", nargs="?", choices=["list", "start"])
+    parser.add_argument(
+        "-g",
+        "--gateway-socket",
+        default=DEFAULT_GATEWAY_SOCKET_PATH,
+        help=f"Sidecar socket to connect to (default: {DEFAULT_GATEWAY_SOCKET_PATH})",
+    )
+    parser.add_argument(
+        "-i",
+        "--worker-id",
+        default=None,
+        help="Stable worker identity (default: python-<random>)",
+    )
+    parser.add_argument(
+        "--heartbeat-ms",
+        type=int,
+        default=DEFAULT_HEARTBEAT_MS,
+        help=f"Heartbeat interval (default: {DEFAULT_HEARTBEAT_MS})",
+    )
+    parser.add_argument(
+        "-h", "--help", action="store_true", help="Show this help message"
+    )
+    return parser
+
+
+def run_actor_worker_cli(
+    registrations: List[ActorRegistration],
+    args: Sequence[str],
+    invocation: Optional[str] = None,
+) -> int:
+    """Runs the `list`/`start` worker CLI against `registrations` and returns
+    the process exit code — the caller decides whether to exit with it, which
+    keeps this testable. `start` installs SIGINT/SIGTERM handlers (when called
+    from the main thread) that stop the worker gracefully, and restores the
+    previous handlers once it returns.
+
+    `invocation` is how to run the calling script, shown in `--help`; defaults
+    to `python3 run_async_worker.py`.
+    """
+    parser = _build_parser(invocation or "python3 run_async_worker.py")
+
+    try:
+        parsed = parser.parse_args(list(args))
+    except _UsageError as exc:
+        logger.error("%s", exc)
+        print(parser.format_help())
+        return 1
+
+    if parsed.help:
+        print(parser.format_help())
+        return 0
+
+    if parsed.command is None:
+        logger.error("First argument must be one of: list, start. Got: (none)")
+        print(parser.format_help())
+        return 1
+
+    gateway_socket_path: str = parsed.gateway_socket
+    worker_id: str = parsed.worker_id or f"python-{uuid.uuid4().hex[:8]}"
+
+    logger.info("%d actor(s) compiled into this registry", len(registrations))
+    for reg in registrations:
+        logger.info(
+            "  + %s@%s (parent %s@%s)",
+            reg["async_operation_name"],
+            reg["async_operation_version"],
+            reg["parent_fsm_name"],
+            reg["parent_fsm_version"],
+        )
+
+    if parsed.command == "list":
+        return 0
+
+    if not registrations:
+        logger.error("No actors in the registry, refusing to start worker")
+        return 1
+
+    worker = ActorWorker(
+        worker_id=worker_id,
+        gateway_socket_path=gateway_socket_path,
+        registrations=registrations,
+        heartbeat_ms=parsed.heartbeat_ms,
+    )
+
+    def _on_signal(signum: int, frame: object) -> None:
+        del signum, frame
+        logger.info("Shutdown requested — stopping worker...")
+        worker.stop()
+
+    # signal.signal() only works from the main thread; elsewhere (e.g. a test
+    # driving this from a worker thread) the caller stops the worker itself.
+    previous_handlers = {}
+    if threading.current_thread() is threading.main_thread():
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            previous_handlers[sig] = signal.signal(sig, _on_signal)
+
+    try:
+        logger.info(
+            "Starting worker %s: gateway-socket=%s", worker_id, gateway_socket_path
+        )
+        worker.run()
+        logger.info("Worker %s stopped.", worker_id)
+        return 0
+    except Exception as exc:  # noqa: BLE001 — reported and turned into an exit code
+        logger.error("Worker %s failed: %s", worker_id, exc, exc_info=True)
+        return 1
+    finally:
+        for sig, handler in previous_handlers.items():
+            signal.signal(sig, handler)