harness-sdk-python 0.25.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
harness_sdk/__init__.py CHANGED
@@ -11,6 +11,7 @@ from .checkpoints import (
11
11
  langgraph_snapshot,
12
12
  langgraph_switch_values,
13
13
  )
14
+ from .deepagents import DeepagentsMessages
14
15
  from .linear_thread import linear_thread
15
16
  from .run_manager import RunManager, RunManagerDescriptor, run_manager
16
17
 
@@ -18,6 +19,7 @@ __all__ = [
18
19
  "CheckpointIndex",
19
20
  "CheckpointStore",
20
21
  "CheckpointThread",
22
+ "DeepagentsMessages",
21
23
  "MemoryCheckpointIndex",
22
24
  "Plan",
23
25
  "PostgresCheckpointIndex",
@@ -11,6 +11,7 @@ Rows and entries are insert-only; ``last_checkpoint_id`` is the only update.
11
11
  """
12
12
 
13
13
  import asyncio
14
+ from contextlib import asynccontextmanager
14
15
  from dataclasses import dataclass, field
15
16
  from typing import Any, Callable, Protocol
16
17
 
@@ -158,50 +159,69 @@ class MemoryCheckpointIndex:
158
159
 
159
160
 
160
161
  class PostgresCheckpointIndex:
161
- """psycopg-backed CheckpointIndex; ``setup()`` creates the two tables."""
162
+ """psycopg-backed CheckpointIndex over an ``AsyncConnection`` or ``AsyncConnectionPool``; ``setup()`` creates the two tables."""
162
163
 
163
164
  def __init__(self, conn: Any) -> None:
164
165
  try:
165
- import psycopg # noqa: F401
166
+ import psycopg
167
+ import psycopg_pool
166
168
  except ImportError as exc:
167
169
  raise ImportError(
168
170
  "harness_sdk.checkpoints.PostgresCheckpointIndex requires the "
169
171
  "'postgres' extra: pip install 'harness-sdk-python[postgres]'"
170
172
  ) from exc
173
+ if not isinstance(
174
+ conn, (psycopg.AsyncConnection, psycopg_pool.AsyncConnectionPool)
175
+ ):
176
+ raise TypeError(
177
+ f"conn must be an AsyncConnection or AsyncConnectionPool, got {conn!r}"
178
+ )
171
179
  self._conn = conn
172
180
 
181
+ @asynccontextmanager
182
+ async def _connection(self):
183
+ import psycopg
184
+
185
+ if isinstance(self._conn, psycopg.AsyncConnection):
186
+ yield self._conn
187
+ else:
188
+ async with self._conn.connection() as conn:
189
+ yield conn
190
+
173
191
  async def setup(self) -> None:
174
- await self._conn.execute(
175
- "CREATE TABLE IF NOT EXISTS checkpoint_threads ("
176
- " thread_id TEXT NOT NULL,"
177
- " checkpoint_ns TEXT NOT NULL,"
178
- " branches JSONB NOT NULL,"
179
- " PRIMARY KEY (thread_id, checkpoint_ns))"
180
- )
181
- await self._conn.execute(
182
- "CREATE TABLE IF NOT EXISTS checkpoint_messages ("
183
- " thread_id TEXT NOT NULL,"
184
- " checkpoint_ns TEXT NOT NULL,"
185
- " message_id TEXT NOT NULL,"
186
- " anchor_checkpoint_id TEXT,"
187
- " branch_id INTEGER NOT NULL,"
188
- " PRIMARY KEY (thread_id, checkpoint_ns, message_id))"
189
- )
192
+ async with self._connection() as conn:
193
+ await conn.execute(
194
+ "CREATE TABLE IF NOT EXISTS checkpoint_threads ("
195
+ " thread_id TEXT NOT NULL,"
196
+ " checkpoint_ns TEXT NOT NULL,"
197
+ " branches JSONB NOT NULL,"
198
+ " PRIMARY KEY (thread_id, checkpoint_ns))"
199
+ )
200
+ await conn.execute(
201
+ "CREATE TABLE IF NOT EXISTS checkpoint_messages ("
202
+ " thread_id TEXT NOT NULL,"
203
+ " checkpoint_ns TEXT NOT NULL,"
204
+ " message_id TEXT NOT NULL,"
205
+ " anchor_checkpoint_id TEXT,"
206
+ " branch_id INTEGER NOT NULL,"
207
+ " PRIMARY KEY (thread_id, checkpoint_ns, message_id))"
208
+ )
190
209
 
191
210
  async def read_thread(
192
211
  self, thread_id: str, checkpoint_ns: str
193
212
  ) -> list[dict[str, Any]]:
194
- cur = await self._conn.execute(
195
- "SELECT branches FROM checkpoint_threads WHERE thread_id = %s AND checkpoint_ns = %s",
196
- (thread_id, checkpoint_ns),
197
- )
198
- row = await cur.fetchone()
213
+ async with self._connection() as conn:
214
+ cur = await conn.execute(
215
+ "SELECT branches FROM checkpoint_threads WHERE thread_id = %s AND checkpoint_ns = %s",
216
+ (thread_id, checkpoint_ns),
217
+ )
218
+ row = await cur.fetchone()
199
219
  return row[0] if row is not None else []
200
220
 
201
- async def _seed_root(self, thread_id: str, checkpoint_ns: str) -> None:
221
+ async def _seed_root(self, conn: Any, thread_id: str, checkpoint_ns: str) -> None:
202
222
  from psycopg.types.json import Jsonb
203
223
 
204
- await self._conn.execute(
224
+ await conn.execute(
205
225
  "INSERT INTO checkpoint_threads (thread_id, checkpoint_ns, branches)"
206
226
  " VALUES (%s, %s, %s) ON CONFLICT DO NOTHING",
207
227
  (thread_id, checkpoint_ns, Jsonb([_ROOT_ENTRY])),
@@ -223,9 +243,9 @@ class PostgresCheckpointIndex:
223
243
  "fork_branch": fork_branch,
224
244
  "last_checkpoint_id": last_checkpoint_id,
225
245
  }
226
- async with self._conn.transaction():
227
- await self._seed_root(thread_id, checkpoint_ns)
228
- cur = await self._conn.execute(
246
+ async with self._connection() as conn, conn.transaction():
247
+ await self._seed_root(conn, thread_id, checkpoint_ns)
248
+ cur = await conn.execute(
229
249
  "UPDATE checkpoint_threads SET branches = branches || %s"
230
250
  " WHERE thread_id = %s AND checkpoint_ns = %s"
231
251
  " RETURNING jsonb_array_length(branches)",
@@ -240,26 +260,27 @@ class PostgresCheckpointIndex:
240
260
  branch_ids: list[int],
241
261
  checkpoint_id: str,
242
262
  ) -> None:
243
- await self._seed_root(thread_id, checkpoint_ns)
244
- cur = await self._conn.execute(
245
- "SELECT jsonb_array_length(branches) FROM checkpoint_threads"
246
- " WHERE thread_id = %s AND checkpoint_ns = %s",
247
- (thread_id, checkpoint_ns),
248
- )
249
- row = await cur.fetchone()
250
- _check_branch_ids(branch_ids, row[0] if row is not None else 0)
251
- await self._conn.execute(
252
- "UPDATE checkpoint_threads SET branches = (SELECT jsonb_agg("
253
- " CASE WHEN idx::int - 1 = ANY(%s)"
254
- " THEN elem || jsonb_build_object('last_checkpoint_id', %s::text)"
255
- " ELSE elem END ORDER BY idx)"
256
- " FROM jsonb_array_elements(branches) WITH ORDINALITY AS t(elem, idx))"
257
- " WHERE thread_id = %s AND checkpoint_ns = %s",
258
- (branch_ids, checkpoint_id, thread_id, checkpoint_ns),
259
- )
263
+ async with self._connection() as conn:
264
+ await self._seed_root(conn, thread_id, checkpoint_ns)
265
+ cur = await conn.execute(
266
+ "SELECT jsonb_array_length(branches) FROM checkpoint_threads"
267
+ " WHERE thread_id = %s AND checkpoint_ns = %s",
268
+ (thread_id, checkpoint_ns),
269
+ )
270
+ row = await cur.fetchone()
271
+ _check_branch_ids(branch_ids, row[0] if row is not None else 0)
272
+ await conn.execute(
273
+ "UPDATE checkpoint_threads SET branches = (SELECT jsonb_agg("
274
+ " CASE WHEN idx::int - 1 = ANY(%s)"
275
+ " THEN elem || jsonb_build_object('last_checkpoint_id', %s::text)"
276
+ " ELSE elem END ORDER BY idx)"
277
+ " FROM jsonb_array_elements(branches) WITH ORDINALITY AS t(elem, idx))"
278
+ " WHERE thread_id = %s AND checkpoint_ns = %s",
279
+ (branch_ids, checkpoint_id, thread_id, checkpoint_ns),
280
+ )
260
281
 
261
282
  async def upsert_messages(self, rows: list[dict[str, Any]]) -> None:
262
- async with self._conn.cursor() as cur:
283
+ async with self._connection() as conn, conn.cursor() as cur:
263
284
  await cur.executemany(
264
285
  "INSERT INTO checkpoint_messages"
265
286
  " (thread_id, checkpoint_ns, message_id, anchor_checkpoint_id, branch_id)"
@@ -272,12 +293,13 @@ class PostgresCheckpointIndex:
272
293
  async def get_message(
273
294
  self, thread_id: str, checkpoint_ns: str, message_id: str
274
295
  ) -> dict[str, Any] | None:
275
- cur = await self._conn.execute(
276
- "SELECT anchor_checkpoint_id, branch_id FROM checkpoint_messages"
277
- " WHERE thread_id = %s AND checkpoint_ns = %s AND message_id = %s",
278
- (thread_id, checkpoint_ns, message_id),
279
- )
280
- row = await cur.fetchone()
296
+ async with self._connection() as conn:
297
+ cur = await conn.execute(
298
+ "SELECT anchor_checkpoint_id, branch_id FROM checkpoint_messages"
299
+ " WHERE thread_id = %s AND checkpoint_ns = %s AND message_id = %s",
300
+ (thread_id, checkpoint_ns, message_id),
301
+ )
302
+ row = await cur.fetchone()
281
303
  if row is None:
282
304
  return None
283
305
  return {"anchor_checkpoint_id": row[0], "branch_id": row[1]}
@@ -0,0 +1,210 @@
1
+ """DeepagentsMessages: the ``messages`` slice of a Statewire host, projected
2
+ from a langgraph checkpointer in the deepagents dialect. The checkpointer is
3
+ the source of truth and the wire state is its projection, restamped with
4
+ ``branch: {id, siblings}`` metadata after every ingest. A rewind restores the
5
+ projection from the target message's anchor checkpoint; a branch switch clones
6
+ the target branch's tip as the checkpointer's latest checkpoint, so resumption
7
+ and reboot both land on the switched world.
8
+ """
9
+
10
+ from datetime import datetime, timezone
11
+ from typing import Any
12
+
13
+ from statepatch import plain
14
+
15
+ from .checkpoints import (
16
+ CheckpointIndex,
17
+ CheckpointStore,
18
+ Snapshot,
19
+ _values_snapshot,
20
+ checkpoint_thread,
21
+ langgraph_snapshot,
22
+ )
23
+
24
+
25
+ def _role(message: dict[str, Any]) -> str:
26
+ return "user" if message["type"] == "human" else "assistant"
27
+
28
+
29
+ def _user_text(message: dict[str, Any]) -> str:
30
+ return "\n\n".join(
31
+ part["text"] for part in message["parts"] if part["type"] == "text"
32
+ )
33
+
34
+
35
+ def _checkpointer_store(
36
+ checkpointer: Any, thread_id: str, checkpoint_ns: str
37
+ ) -> CheckpointStore:
38
+ class _Store:
39
+ async def get(self, checkpoint_id: str | None) -> Snapshot | None:
40
+ configurable: dict[str, Any] = {
41
+ "thread_id": thread_id,
42
+ "checkpoint_ns": checkpoint_ns,
43
+ }
44
+ if checkpoint_id is not None:
45
+ configurable["checkpoint_id"] = checkpoint_id
46
+ saved = await checkpointer.aget_tuple({"configurable": configurable})
47
+ if saved is None:
48
+ return None
49
+ return _values_snapshot(
50
+ saved.checkpoint["id"],
51
+ saved.checkpoint["channel_values"],
52
+ "messages",
53
+ "lineage",
54
+ )
55
+
56
+ return _Store()
57
+
58
+
59
+ class DeepagentsMessages:
60
+ """A host's ``state["messages"]`` over a langgraph checkpointer: boot, turn streaming, rewind, and branch switching for the deepagents dialect."""
61
+
62
+ def __init__(self, checkpointer: Any) -> None:
63
+ if not hasattr(checkpointer, "aget_tuple") or not hasattr(checkpointer, "aput"):
64
+ raise TypeError(
65
+ f"checkpointer must be a langgraph checkpoint saver, got {checkpointer!r}"
66
+ )
67
+ self._checkpointer = checkpointer
68
+ self._captured: dict[str, Any] | None = None
69
+
70
+ async def boot(
71
+ self, state: Any, *, index: CheckpointIndex, thread_id: str
72
+ ) -> None:
73
+ """Adopt ``state["messages"]`` and load the thread's history into it with branch stamps."""
74
+ self._state = state
75
+ self._thread_id = thread_id
76
+ self._store = _checkpointer_store(self._checkpointer, thread_id, "")
77
+ self._thread = await checkpoint_thread(
78
+ store=self._store, index=index, thread_id=thread_id, role=_role
79
+ )
80
+ if self._thread.transcript:
81
+ # the graph carries no lineage channel: re-derive the world path from the tail row
82
+ row = await index.get_message(
83
+ thread_id, "", self._thread.transcript[-1]["id"]
84
+ )
85
+ if row is not None and row["branch_id"] != 0:
86
+ await self._thread.switch_state(row["branch_id"])
87
+ self._restamp()
88
+
89
+ async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
90
+ """The thread projection's message meta, for RunManager."""
91
+ return await self._thread.get_message_meta(message_id)
92
+
93
+ async def get_message_child_id(self, parent_id: str) -> str | None:
94
+ """The thread projection's child id, for RunManager."""
95
+ return await self._thread.get_message_child_id(parent_id)
96
+
97
+ def config(self) -> dict[str, Any]:
98
+ """The langgraph config addressing this thread."""
99
+ return {"configurable": {"thread_id": self._thread_id}}
100
+
101
+ async def plan_turn(
102
+ self, ctx: Any
103
+ ) -> tuple[dict[str, Any] | None, dict[str, Any]]:
104
+ """The dispatch's langgraph (payload, config): plans the resumption, restores a rewind's window, appends the batch to the wire state, and confirms it applied."""
105
+ config = self.config()
106
+ if ctx.resume:
107
+ return None, config
108
+ plan = await self._thread.plan_run(ctx)
109
+ if ctx.has_rollback:
110
+ base = (
111
+ (await self._snapshot(plan.checkpoint_id)).messages
112
+ if plan.checkpoint_id is not None
113
+ else []
114
+ )
115
+ self._replace([*base, *plan.replay])
116
+ turn: list[Any] = [*plan.replay]
117
+ for message in ctx.messages:
118
+ turn.append(self._append_user(message))
119
+ ctx.applied()
120
+ if plan.fork:
121
+ if plan.checkpoint_id is not None:
122
+ config["configurable"]["checkpoint_id"] = plan.checkpoint_id
123
+ else:
124
+ from langchain_core.messages import RemoveMessage
125
+ from langgraph.graph.message import REMOVE_ALL_MESSAGES
126
+
127
+ turn = [RemoveMessage(id=REMOVE_ALL_MESSAGES), *turn]
128
+ return ({"messages": turn} if turn else None), config
129
+
130
+ def append_event(self, namespace: tuple, mode: str, event: Any) -> None:
131
+ """Fold one ``astream`` event into the wire state; the root checkpoint stream is captured for the turn's ingest."""
132
+ if mode == "checkpoints":
133
+ if namespace == ():
134
+ self._captured = event
135
+ return
136
+ from statewire.langgraph import append_langgraph_event
137
+
138
+ append_langgraph_event(self._state, namespace, mode, event)
139
+
140
+ async def ingest_turn(self, *, refetch: bool = False) -> None:
141
+ """Ingest the turn's captured checkpoint and restamp; ``refetch`` discards the capture and reads the checkpointer's latest instead."""
142
+ captured, self._captured = self._captured, None
143
+ if refetch or captured is None:
144
+ await self._thread.ingest_latest()
145
+ else:
146
+ await self._thread.ingest(langgraph_snapshot(captured))
147
+ self._restamp()
148
+
149
+ def append_users(self, messages: Any) -> list[dict[str, Any]]:
150
+ """Append harness user messages to the wire state as human entries, deduplicated by id; returns the langgraph turn entries."""
151
+ return [self._append_user(message) for message in messages]
152
+
153
+ async def switch_branch(self, branch_id: int) -> None:
154
+ """Switch to ``branch_id``: its tip becomes the checkpointer's latest checkpoint and the wire state rebaselines."""
155
+ transcript, lineage = await self._thread.switch_state(branch_id)
156
+ checkpoint_id = await self._clone_tip(self._thread.checkpoint_id)
157
+ await self._thread.ingest(Snapshot(checkpoint_id, transcript, lineage))
158
+ self._restamp()
159
+
160
+ async def _clone_tip(self, checkpoint_id: str) -> str:
161
+ from langgraph.checkpoint.base.id import uuid6
162
+
163
+ parent = {
164
+ "configurable": {
165
+ "thread_id": self._thread_id,
166
+ "checkpoint_ns": "",
167
+ "checkpoint_id": checkpoint_id,
168
+ }
169
+ }
170
+ saved = await self._checkpointer.aget_tuple(parent)
171
+ if saved is None:
172
+ raise LookupError(f"checkpoint {checkpoint_id!r} is not in the checkpointer")
173
+ clone = {
174
+ **saved.checkpoint,
175
+ "id": str(uuid6(clock_seq=-2)),
176
+ "ts": datetime.now(timezone.utc).isoformat(),
177
+ }
178
+ metadata = {
179
+ "source": "update",
180
+ "step": (saved.metadata or {}).get("step", -1) + 1,
181
+ "parents": {},
182
+ }
183
+ written = await self._checkpointer.aput(parent, clone, metadata, {})
184
+ return written["configurable"]["checkpoint_id"]
185
+
186
+ async def _snapshot(self, checkpoint_id: str) -> Snapshot:
187
+ snapshot = await self._store.get(checkpoint_id)
188
+ if snapshot is None:
189
+ raise LookupError(
190
+ f"checkpoint {checkpoint_id!r} is not in the checkpointer"
191
+ )
192
+ return snapshot
193
+
194
+ def _append_user(self, message: dict[str, Any]) -> dict[str, Any]:
195
+ entry = {"id": message["id"], "type": "human", "content": _user_text(message)}
196
+ if not any(m["id"] == entry["id"] for m in plain(self._state["messages"])):
197
+ self._state["messages"].append(entry)
198
+ return entry
199
+
200
+ def _replace(self, messages: list[dict[str, Any]]) -> None:
201
+ from statewire.langgraph import replace_messages
202
+
203
+ replace_messages(self._state, messages)
204
+
205
+ def _restamp(self) -> None:
206
+ stamped = []
207
+ for message in self._thread.transcript:
208
+ branch, siblings = self._thread.sibling_info(message["id"])
209
+ stamped.append({**message, "branch": {"id": branch, "siblings": siblings}})
210
+ self._replace(stamped)
@@ -48,6 +48,7 @@ window.
48
48
  """
49
49
 
50
50
  import asyncio
51
+ import contextlib
51
52
  import logging
52
53
  from dataclasses import dataclass, field
53
54
  from typing import Any, AsyncIterator, Callable, Coroutine, Iterable, Protocol
@@ -1610,7 +1611,7 @@ class RunManagerNamespace(TrayMapNamespace):
1610
1611
  f"{type(api).__name__} must implement get_message_meta "
1611
1612
  "(RunManager.Thread) to host @run_manager"
1612
1613
  )
1613
- self._mint_lock = asyncio.Lock()
1614
+ self._mint: "asyncio.Task[Any] | None" = None
1614
1615
  self._mounted: list[RunManager] = []
1615
1616
  api.state["runs"] = []
1616
1617
  api.state["status"] = "ready"
@@ -1628,14 +1629,26 @@ class RunManagerNamespace(TrayMapNamespace):
1628
1629
  return tray
1629
1630
 
1630
1631
  async def _machine(self, run_id: str) -> tuple[RunManager, bool]:
1631
- tray = self.live()
1632
- if tray is not None:
1633
- return tray, False
1634
- async with self._mint_lock:
1632
+ # No await between the live() check and the mint's publication, and no
1633
+ # lock held across storage I/O: same-tick callers await the shared mint
1634
+ # task and merge into the machine it mounts; the creator raises its
1635
+ # mint's failure while followers re-mint and progress.
1636
+ while True:
1635
1637
  tray = self.live()
1636
1638
  if tray is not None:
1637
1639
  return tray, False
1638
- return await self.get_or_create(run_id), True # type: ignore[return-value]
1640
+ pending = self._mint
1641
+ if pending is None:
1642
+ pending = self._api.create_task(self.get_or_create(run_id))
1643
+ self._mint = pending
1644
+ pending.add_done_callback(self._mint_settled)
1645
+ return await pending, True
1646
+ with contextlib.suppress(Exception):
1647
+ await pending
1648
+
1649
+ def _mint_settled(self, task: "asyncio.Task[Any]") -> None:
1650
+ if self._mint is task:
1651
+ self._mint = None
1639
1652
 
1640
1653
  # ─── Mounted view ───────────────────────────────────────
1641
1654
 
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.5
2
2
  Name: harness-sdk-python
3
- Version: 0.25.1
3
+ Version: 0.26.0
4
4
  Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
5
5
  Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
6
6
  License-Expression: MIT
@@ -0,0 +1,9 @@
1
+ harness_sdk/__init__.py,sha256=ehKf5P2F8tmWWGJDdxKB082dGV7GWlxXSo-GAhH3Ne4,827
2
+ harness_sdk/checkpoints.py,sha256=L02l1IyLDj2b-GD7_HGrck7uenALeI4kg8yJSzoNVmc,25999
3
+ harness_sdk/deepagents.py,sha256=Zl5n8Xu8LVQZEwmDnG1sfNzLhiNH5Miv1__bjZPb_bE,8741
4
+ harness_sdk/fenced_postgres.py,sha256=hbbrMR1WaqrHTNgd4wFrXfRrzQFGnyim-c8nZXgwWp4,13235
5
+ harness_sdk/linear_thread.py,sha256=laDRXKLFsMlyWS4snqNAM6t38wO26gevLWXRNivhHSM,1810
6
+ harness_sdk/run_manager.py,sha256=CbY_4dpFeqGx3kJNI1ffsu3uIvzVc-Tc1UB6Nr9SiHY,77654
7
+ harness_sdk_python-0.26.0.dist-info/METADATA,sha256=2nu-IellMnPO7WAGwWMEm2kYIPfqwFo3HXKQG6cs3kE,2200
8
+ harness_sdk_python-0.26.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
9
+ harness_sdk_python-0.26.0.dist-info/RECORD,,
@@ -1,8 +0,0 @@
1
- harness_sdk/__init__.py,sha256=lHRu0sZVppfPjWawxEjXrcHIVSHCkdYQjCtIl5D2wmk,758
2
- harness_sdk/checkpoints.py,sha256=QQ6OOKEK6DQz5zAKTSqS5zg0K-uQk25wbxdz1tgi-zQ,24984
3
- harness_sdk/fenced_postgres.py,sha256=hbbrMR1WaqrHTNgd4wFrXfRrzQFGnyim-c8nZXgwWp4,13235
4
- harness_sdk/linear_thread.py,sha256=laDRXKLFsMlyWS4snqNAM6t38wO26gevLWXRNivhHSM,1810
5
- harness_sdk/run_manager.py,sha256=xL6TsXJk_3SVyA5oNuGlPelDmCqCRmL-bWW5wsfiIBY,77028
6
- harness_sdk_python-0.25.1.dist-info/METADATA,sha256=gQ15chFixL7SjDhbQe2q4qi6TA8P51KC0CmjrJwYvyM,2200
7
- harness_sdk_python-0.25.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
8
- harness_sdk_python-0.25.1.dist-info/RECORD,,