harness-sdk-python 0.2.0__tar.gz → 0.3.0__tar.gz

{harness_sdk_python-0.2.0 → harness_sdk_python-0.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.2.0
+Version: 0.3.0
 Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT
 Requires-Python: <4.0,>=3.11
-Requires-Dist: statewire<0.3,>=0.2.0
+Requires-Dist: statewire<0.4,>=0.3.0
 Provides-Extra: postgres
 Requires-Dist: langgraph-checkpoint-postgres>=2.0.0; extra == 'postgres'
 Description-Content-Type: text/markdown
@@ -21,7 +21,7 @@ class MyHost(Statewire):
     async def lifespan(self):
         self.state = initial_state()
         self.runs = RunManager(
-            state=self.state["runs"],
+            state=self.state,
             start=self._start,
             get_message_meta=self._get_message_meta,
             create_task=self.create_task,

{harness_sdk_python-0.2.0 → harness_sdk_python-0.3.0}/README.md

@@ -9,7 +9,7 @@ class MyHost(Statewire):
     async def lifespan(self):
         self.state = initial_state()
         self.runs = RunManager(
-            state=self.state["runs"],
+            state=self.state,
             start=self._start,
             get_message_meta=self._get_message_meta,
             create_task=self.create_task,

{harness_sdk_python-0.2.0 → harness_sdk_python-0.3.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.2.0"
+version = "0.3.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11,<4.0"
-dependencies = ["statewire>=0.2.0,<0.3"]
+dependencies = ["statewire>=0.3.0,<0.4"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.2.0 → harness_sdk_python-0.3.0}/src/harness_sdk/fenced_postgres.py

@@ -8,6 +8,7 @@ try:
     from langgraph.checkpoint.base import SerializerProtocol
     from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver, _ainternal
     from psycopg import AsyncPipeline, errors
+    from psycopg.pq import TransactionStatus
     from psycopg.cursor_async import AsyncCursor
     from psycopg.rows import DictRow, dict_row
     from psycopg.sql import SQL, Identifier, Literal
@@ -20,7 +21,7 @@ except ImportError as exc:
 DEFAULT_FENCE_TABLE = "checkpoint_fence"
 FENCE_LOST_SQLSTATE = "FL001"
 
-_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_IDENTIFIER_RE = re.compile(r"^[a-z_][a-z0-9_]*$")
 
 
 class FenceLost(RuntimeError):
@@ -41,7 +42,7 @@ def _require_thread_id(thread_id: str) -> str:
 def _require_fence_table(fence_table: str) -> str:
     if not isinstance(fence_table, str) or not _IDENTIFIER_RE.match(fence_table):
         raise ValueError(
-            f"fence_table must be an unquoted SQL identifier, got {fence_table!r}"
+            f"fence_table must be a lowercase SQL identifier, got {fence_table!r}"
         )
     return fence_table
 
@@ -89,8 +90,14 @@ def _assert_sql(fence_table: str) -> SQL:
     return SQL("SELECT {}(%s, %s)").format(Identifier(_assert_fn(fence_table)))
 
 
-def _is_fence_lost(exc: errors.Error) -> bool:
-    return exc.sqlstate == FENCE_LOST_SQLSTATE
+def _is_fence_lost(exc: BaseException | None) -> bool:
+    seen: set[int] = set()
+    while exc is not None and id(exc) not in seen:
+        seen.add(id(exc))
+        if isinstance(exc, errors.Error) and exc.sqlstate == FENCE_LOST_SQLSTATE:
+            return True
+        exc = exc.__cause__ or exc.__context__
+    return False
 
 
 def _missing_fence_error(missing: str) -> RuntimeError:
@@ -133,27 +140,32 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
     ) -> "AsyncFencedPostgresSaver":
         _require_thread_id(thread_id)
         _require_fence_table(fence_table)
-        async with (
-            _ainternal.get_connection(conn) as c,
-            c.cursor(binary=True, row_factory=dict_row) as cur,
-        ):
-            if create_fence_table:
-                await cur.execute(_create_sql(fence_table))
-                await cur.execute(_create_fn_sql(fence_table))
-            else:
-                await cur.execute(
-                    "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
-                    (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
+        async with _ainternal.get_connection(conn) as c:
+            if c.info.transaction_status != TransactionStatus.IDLE:
+                raise RuntimeError(
+                    "acquire requires a connection with no transaction in progress"
                 )
-                row = await cur.fetchone()
-                if row["tbl"] is None:
-                    raise _missing_fence_error(f"fence table {fence_table!r}")
-                if row["fn"] is None:
-                    raise _missing_fence_error(
-                        f"fence function {_assert_fn(fence_table)!r}"
+            async with (
+                c.transaction(),
+                c.cursor(binary=True, row_factory=dict_row) as cur,
+            ):
+                if create_fence_table:
+                    await cur.execute(_create_sql(fence_table))
+                    await cur.execute(_create_fn_sql(fence_table))
+                else:
+                    await cur.execute(
+                        "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
+                        (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
                     )
-            await cur.execute(_bump_sql(fence_table), (thread_id,))
-            epoch = (await cur.fetchone())["epoch"]
+                    row = await cur.fetchone()
+                    if row["tbl"] is None:
+                        raise _missing_fence_error(f"fence table {fence_table!r}")
+                    if row["fn"] is None:
+                        raise _missing_fence_error(
+                            f"fence function {_assert_fn(fence_table)!r}"
+                        )
+                await cur.execute(_bump_sql(fence_table), (thread_id,))
+                epoch = (await cur.fetchone())["epoch"]
         if pipe is not None:
             await pipe.sync()
         return cls(
@@ -191,9 +203,24 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
                 await cur.execute(_assert_sql(self.fence_table), (self.thread_id, self.epoch))
                 yield cur
         except errors.Error as exc:
-            if not _is_fence_lost(exc):
-                raise
-            raise self._fence_lost() from exc
+            if _is_fence_lost(exc):
+                raise self._fence_lost() from exc
+            # An aborted pipeline can surface before the assert's FL001 does;
+            # the fence row decides which it was.
+            if isinstance(exc, errors.PipelineAborted) and await self._fence_stale():
+                raise self._fence_lost() from exc
+            raise
+
+    async def _fence_stale(self) -> bool:
+        async with super()._cursor(pipeline=False) as cur:
+            await cur.execute(
+                SQL("SELECT epoch FROM {} WHERE thread_id = %s").format(
+                    Identifier(self.fence_table)
+                ),
+                (self.thread_id,),
+            )
+            row = await cur.fetchone()
+        return row is None or row["epoch"] != self.epoch
 
     async def aput(
         self,