memex-python 0.13.0__py3-none-any.whl

memex/transplant.py

@@ -0,0 +1,480 @@
+"""Transplant — export a slice of the three graphs and import it elsewhere.
+
+The import side optionally re-ids colliding entities (``re_id_on_difference``),
+and a per-graph re-id *pre-pass* populates the id maps before anything is
+processed so cross-references (``parents`` / ``parent_id`` / ``intent_id`` /
+memory id lists) remap correctly regardless of slice ordering.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, NamedTuple
+
+from pydantic import BaseModel
+
+from ._uuid import uuid7
+from .errors import InvalidTimestampError
+from .graph import GraphState
+from .intent import Intent, IntentState, apply_intent_command
+from .models import Edge, MemoryItem
+from .query import extract_timestamp, get_children, get_edges
+from .reducer import apply_command
+from .task import Task, TaskState, apply_task_command
+
+__all__ = [
+    "ExportOptions",
+    "MemexExport",
+    "ImportOptions",
+    "ImportBucket",
+    "ImportReport",
+    "ImportResult",
+    "export_slice",
+    "import_slice",
+]
+
+
+# ---------------------------------------------------------------------------
+# Re-id helpers
+# ---------------------------------------------------------------------------
+
+
+def _uuid_from_ms(ms: int) -> str:
+    """Build a UUIDv7-shaped id from a given ms timestamp + random suffix."""
+    hex_ms = format(ms, "x").rjust(12, "0")
+    rand = uuid7().replace("-", "")
+    return "-".join([
+        hex_ms[0:8],
+        hex_ms[8:12],
+        "7" + rand[13:16],
+        rand[16:20],
+        rand[20:32],
+    ])
+
+
+def _re_id_for(original_id: str, existing_ids: set[str], created_at: int | None = None) -> str:
+    """Generate a fresh id 1ms after the original, incrementing on collision."""
+    if created_at is None:
+        try:
+            created_at = extract_timestamp(original_id)
+        except InvalidTimestampError as err:
+            raise ValueError(
+                f'Cannot re-id "{original_id}": provide created_at or use a UUIDv7 id'
+            ) from err
+    ms = created_at + 1
+    new_id = _uuid_from_ms(ms)
+    while new_id in existing_ids:
+        ms += 1
+        new_id = _uuid_from_ms(ms)
+    return new_id
+
+
+def _rewrite_id(id_: str, id_map: dict[str, str]) -> str:
+    return id_map.get(id_, id_)
+
+
+def _rewrite_ids(ids: list[str] | None, id_map: dict[str, str]) -> list[str] | None:
+    if ids is None:
+        return None
+    return [id_map.get(i, i) for i in ids]
+
+
+# ---------------------------------------------------------------------------
+# Export
+# ---------------------------------------------------------------------------
+
+
+class ExportOptions(BaseModel):
+    memory_ids: list[str] | None = None
+    intent_ids: list[str] | None = None
+    task_ids: list[str] | None = None
+    include_parents: bool = False
+    include_children: bool = False
+    include_aliases: bool = False
+    include_related_tasks: bool = False
+    include_related_intents: bool = False
+
+
+class MemexExport(BaseModel):
+    memories: list[MemoryItem] = []
+    edges: list[Edge] = []
+    intents: list[Intent] = []
+    tasks: list[Task] = []
+
+
+def export_slice(
+    mem_state: GraphState,
+    intent_state: IntentState,
+    task_state: TaskState,
+    *,
+    memory_ids: list[str] | None = None,
+    intent_ids: list[str] | None = None,
+    task_ids: list[str] | None = None,
+    include_parents: bool = False,
+    include_children: bool = False,
+    include_aliases: bool = False,
+    include_related_tasks: bool = False,
+    include_related_intents: bool = False,
+) -> MemexExport:
+    memory_id_set: set[str] = set(memory_ids or [])
+    intent_id_set: set[str] = set(intent_ids or [])
+    task_id_set: set[str] = set(task_ids or [])
+    edge_id_set: set[str] = set()
+
+    # walk parents up-graph
+    if include_parents:
+        queue = list(memory_id_set)
+        while queue:
+            id_ = queue.pop()
+            item = mem_state.items.get(id_)
+            if item and item.parents:
+                for pid in item.parents:
+                    if pid not in memory_id_set:
+                        memory_id_set.add(pid)
+                        queue.append(pid)
+
+    # walk children down-graph
+    if include_children:
+        queue = list(memory_id_set)
+        while queue:
+            id_ = queue.pop()
+            for child in get_children(mem_state, id_):
+                if child.id not in memory_id_set:
+                    memory_id_set.add(child.id)
+                    queue.append(child.id)
+
+    # walk aliases (both directions)
+    if include_aliases:
+        queue = list(memory_id_set)
+        visited: set[str] = set()
+        while queue:
+            id_ = queue.pop()
+            if id_ in visited:
+                continue
+            visited.add(id_)
+            for edge in get_edges(mem_state, {"from": id_, "kind": "ALIAS", "active_only": True}):
+                edge_id_set.add(edge.edge_id)
+                if edge.to not in memory_id_set:
+                    memory_id_set.add(edge.to)
+                    queue.append(edge.to)
+            for edge in get_edges(mem_state, {"to": id_, "kind": "ALIAS", "active_only": True}):
+                edge_id_set.add(edge.edge_id)
+                if edge.from_ not in memory_id_set:
+                    memory_id_set.add(edge.from_)
+                    queue.append(edge.from_)
+
+    # collect edges between included memories
+    for edge in mem_state.edges.values():
+        if edge.from_ in memory_id_set and edge.to in memory_id_set:
+            edge_id_set.add(edge.edge_id)
+
+    # walk related intents
+    if include_related_intents:
+        for intent in intent_state.intents.values():
+            if intent.root_memory_ids:
+                for mid in intent.root_memory_ids:
+                    if mid in memory_id_set:
+                        intent_id_set.add(intent.id)
+                        break
+        for mid in memory_id_set:
+            item = mem_state.items.get(mid)
+            if item and item.intent_id:
+                intent_id_set.add(item.intent_id)
+
+    # walk related tasks
+    if include_related_tasks:
+        for task in task_state.tasks.values():
+            if task.intent_id in intent_id_set:
+                task_id_set.add(task.id)
+                continue
+            input_match = task.input_memory_ids and any(mid in memory_id_set for mid in task.input_memory_ids)
+            output_match = task.output_memory_ids and any(mid in memory_id_set for mid in task.output_memory_ids)
+            if input_match or output_match:
+                task_id_set.add(task.id)
+        for mid in memory_id_set:
+            item = mem_state.items.get(mid)
+            if item and item.task_id:
+                task_id_set.add(item.task_id)
+
+    memories = [mem_state.items[i] for i in memory_id_set if i in mem_state.items]
+    edges = [mem_state.edges[i] for i in edge_id_set if i in mem_state.edges]
+    intents = [intent_state.intents[i] for i in intent_id_set if i in intent_state.intents]
+    tasks = [task_state.tasks[i] for i in task_id_set if i in task_state.tasks]
+
+    return MemexExport(memories=memories, edges=edges, intents=intents, tasks=tasks)
+
+
+# ---------------------------------------------------------------------------
+# Import
+# ---------------------------------------------------------------------------
+
+
+class ImportOptions(BaseModel):
+    skip_existing_ids: bool = True
+    shallow_compare_existing: bool = False
+    re_id_on_difference: bool = False
+
+
+@dataclass
+class ImportBucket:
+    memories: list[str] = field(default_factory=list)
+    intents: list[str] = field(default_factory=list)
+    tasks: list[str] = field(default_factory=list)
+    edges: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ImportReport:
+    created: ImportBucket = field(default_factory=ImportBucket)
+    updated: ImportBucket = field(default_factory=ImportBucket)
+    skipped: ImportBucket = field(default_factory=ImportBucket)
+    conflicts: ImportBucket = field(default_factory=ImportBucket)
+
+
+class ImportResult(NamedTuple):
+    mem_state: GraphState
+    intent_state: IntentState
+    task_state: TaskState
+    report: ImportReport
+
+
+def _shallow_equal(a: BaseModel, b: BaseModel) -> bool:
+    """Deep structural equality (order-independent), matching the TS helper."""
+    return a.model_dump() == b.model_dump()
+
+
+def import_slice(
+    mem_state: GraphState,
+    intent_state: IntentState,
+    task_state: TaskState,
+    slice: MemexExport | dict[str, Any],
+    *,
+    skip_existing_ids: bool = True,
+    shallow_compare_existing: bool = False,
+    re_id_on_difference: bool = False,
+) -> ImportResult:
+    sl = slice if isinstance(slice, MemexExport) else MemexExport.model_validate(slice)
+
+    skip_existing = skip_existing_ids
+    shallow_compare = shallow_compare_existing
+    do_re_id = re_id_on_difference
+
+    report = ImportReport()
+
+    mem_id_map: dict[str, str] = {}
+    intent_id_map: dict[str, str] = {}
+    task_id_map: dict[str, str] = {}
+
+    all_mem_ids = set(mem_state.items.keys())
+    all_intent_ids = set(intent_state.intents.keys())
+    all_task_ids = set(task_state.tasks.keys())
+
+    current_mem = mem_state
+    current_intent = intent_state
+    current_task = task_state
+
+    # --- memory re-id pre-pass ---
+    if skip_existing and shallow_compare and do_re_id:
+        for item in sl.memories:
+            existing = mem_state.items.get(item.id)
+            if existing is not None and not _shallow_equal(existing, item):
+                new_id = _re_id_for(item.id, all_mem_ids, item.created_at)
+                all_mem_ids.add(new_id)
+                mem_id_map[item.id] = new_id
+
+    # --- import memories ---
+    for item in sl.memories:
+        existing = current_mem.items.get(item.id)
+        if existing is not None:
+            if skip_existing:
+                if shallow_compare and not _shallow_equal(existing, item):
+                    if do_re_id:
+                        new_id = mem_id_map[item.id]
+                        remapped = item.model_copy(update={
+                            "id": new_id,
+                            "parents": _rewrite_ids(item.parents, mem_id_map),
+                        })
+                        current_mem = apply_command(current_mem, {"type": "memory.create", "item": remapped}).state
+                        report.created.memories.append(new_id)
+                    else:
+                        report.conflicts.memories.append(item.id)
+                else:
+                    report.skipped.memories.append(item.id)
+                continue
+            # skip_existing False — update existing item
+            partial = item.model_dump(exclude_none=True)
+            partial.pop("id", None)
+            rewritten = _rewrite_ids(item.parents, mem_id_map)
+            if rewritten is not None:
+                partial["parents"] = rewritten
+            current_mem = apply_command(
+                current_mem,
+                {"type": "memory.update", "item_id": item.id, "partial": partial, "author": item.author},
+            ).state
+            report.updated.memories.append(item.id)
+            continue
+        # no collision — create
+        remapped = item.model_copy(update={"parents": _rewrite_ids(item.parents, mem_id_map)})
+        current_mem = apply_command(current_mem, {"type": "memory.create", "item": remapped}).state
+        report.created.memories.append(item.id)
+
+    all_edge_ids = set(current_mem.edges.keys())
+
+    # --- import edges ---
+    for edge in sl.edges:
+        existing_edge = current_mem.edges.get(edge.edge_id)
+        if existing_edge is not None:
+            if skip_existing:
+                if shallow_compare and not _shallow_equal(existing_edge, edge):
+                    if do_re_id:
+                        new_id = _re_id_for(edge.edge_id, all_edge_ids)
+                        all_edge_ids.add(new_id)
+                        remapped_edge = edge.model_copy(update={
+                            "edge_id": new_id,
+                            "from_": _rewrite_id(edge.from_, mem_id_map),
+                            "to": _rewrite_id(edge.to, mem_id_map),
+                        })
+                        current_mem = apply_command(current_mem, {"type": "edge.create", "edge": remapped_edge}).state
+                        report.created.edges.append(new_id)
+                    else:
+                        report.conflicts.edges.append(edge.edge_id)
+                else:
+                    report.skipped.edges.append(edge.edge_id)
+                continue
+            partial = edge.model_dump(exclude_none=True)
+            for k in ("edge_id", "from", "from_", "to"):
+                partial.pop(k, None)
+            current_mem = apply_command(
+                current_mem,
+                {"type": "edge.update", "edge_id": edge.edge_id, "partial": partial, "author": edge.author},
+            ).state
+            report.updated.edges.append(edge.edge_id)
+            continue
+        remapped_edge = edge.model_copy(update={
+            "from_": _rewrite_id(edge.from_, mem_id_map),
+            "to": _rewrite_id(edge.to, mem_id_map),
+        })
+        current_mem = apply_command(current_mem, {"type": "edge.create", "edge": remapped_edge}).state
+        report.created.edges.append(edge.edge_id)
+
+    # --- intent re-id pre-pass ---
+    if skip_existing and shallow_compare and do_re_id:
+        for intent in sl.intents:
+            existing_intent = current_intent.intents.get(intent.id)
+            if existing_intent is not None and not _shallow_equal(existing_intent, intent):
+                new_id = _re_id_for(intent.id, all_intent_ids)
+                all_intent_ids.add(new_id)
+                intent_id_map[intent.id] = new_id
+
+    # --- import intents ---
+    for intent in sl.intents:
+        existing_intent = current_intent.intents.get(intent.id)
+        if existing_intent is not None:
+            if skip_existing:
+                if shallow_compare and not _shallow_equal(existing_intent, intent):
+                    if do_re_id:
+                        new_id = intent_id_map[intent.id]
+                        remapped_intent = intent.model_copy(update={
+                            "id": new_id,
+                            "parent_id": _rewrite_id(intent.parent_id, intent_id_map) if intent.parent_id else None,
+                            "root_memory_ids": _rewrite_ids(intent.root_memory_ids, mem_id_map),
+                        })
+                        current_intent = apply_intent_command(current_intent, {"type": "intent.create", "intent": remapped_intent}).state
+                        report.created.intents.append(new_id)
+                    else:
+                        report.conflicts.intents.append(intent.id)
+                else:
+                    report.skipped.intents.append(intent.id)
+                continue
+            partial = intent.model_dump(exclude_none=True)
+            for k in ("id", "status"):
+                partial.pop(k, None)
+            partial["parent_id"] = _rewrite_id(intent.parent_id, intent_id_map) if intent.parent_id else None
+            partial["root_memory_ids"] = _rewrite_ids(intent.root_memory_ids, mem_id_map)
+            current_intent = apply_intent_command(
+                current_intent,
+                {"type": "intent.update", "intent_id": intent.id, "partial": partial, "author": intent.owner},
+            ).state
+            report.updated.intents.append(intent.id)
+            continue
+        remapped_intent = intent.model_copy(update={
+            "parent_id": _rewrite_id(intent.parent_id, intent_id_map) if intent.parent_id else None,
+            "root_memory_ids": _rewrite_ids(intent.root_memory_ids, mem_id_map),
+        })
+        current_intent = apply_intent_command(current_intent, {"type": "intent.create", "intent": remapped_intent}).state
+        report.created.intents.append(intent.id)
+
+    # --- task re-id pre-pass ---
+    if skip_existing and shallow_compare and do_re_id:
+        for task in sl.tasks:
+            existing_task = current_task.tasks.get(task.id)
+            if existing_task is not None and not _shallow_equal(existing_task, task):
+                new_id = _re_id_for(task.id, all_task_ids)
+                all_task_ids.add(new_id)
+                task_id_map[task.id] = new_id
+
+    # --- import tasks ---
+    for task in sl.tasks:
+        existing_task = current_task.tasks.get(task.id)
+        if existing_task is not None:
+            if skip_existing:
+                if shallow_compare and not _shallow_equal(existing_task, task):
+                    if do_re_id:
+                        new_id = task_id_map[task.id]
+                        remapped_task = task.model_copy(update={
+                            "id": new_id,
+                            "intent_id": _rewrite_id(task.intent_id, intent_id_map),
+                            "parent_id": _rewrite_id(task.parent_id, task_id_map) if task.parent_id else None,
+                            "input_memory_ids": _rewrite_ids(task.input_memory_ids, mem_id_map),
+                            "output_memory_ids": _rewrite_ids(task.output_memory_ids, mem_id_map),
+                        })
+                        current_task = apply_task_command(current_task, {"type": "task.create", "task": remapped_task}).state
+                        report.created.tasks.append(new_id)
+                    else:
+                        report.conflicts.tasks.append(task.id)
+                else:
+                    report.skipped.tasks.append(task.id)
+                continue
+            partial = task.model_dump(exclude_none=True)
+            for k in ("id", "status"):
+                partial.pop(k, None)
+            partial["intent_id"] = _rewrite_id(task.intent_id, intent_id_map)
+            partial["parent_id"] = _rewrite_id(task.parent_id, task_id_map) if task.parent_id else None
+            partial["input_memory_ids"] = _rewrite_ids(task.input_memory_ids, mem_id_map)
+            partial["output_memory_ids"] = _rewrite_ids(task.output_memory_ids, mem_id_map)
+            current_task = apply_task_command(
+                current_task,
+                {"type": "task.update", "task_id": task.id, "partial": partial, "author": task.agent_id or "system:import"},
+            ).state
+            report.updated.tasks.append(task.id)
+            continue
+        remapped_task = task.model_copy(update={
+            "intent_id": _rewrite_id(task.intent_id, intent_id_map),
+            "parent_id": _rewrite_id(task.parent_id, task_id_map) if task.parent_id else None,
+            "input_memory_ids": _rewrite_ids(task.input_memory_ids, mem_id_map),
+            "output_memory_ids": _rewrite_ids(task.output_memory_ids, mem_id_map),
+        })
+        current_task = apply_task_command(current_task, {"type": "task.create", "task": remapped_task}).state
+        report.created.tasks.append(task.id)
+
+    # --- second pass: remap intent_id / task_id on imported memories ---
+    if intent_id_map or task_id_map:
+        imported_mem_ids = [*report.created.memories, *report.updated.memories]
+        for mem_id in imported_mem_ids:
+            stored_item = current_mem.items.get(mem_id)
+            if stored_item is None:
+                continue
+            new_intent_id = intent_id_map.get(stored_item.intent_id) if stored_item.intent_id else None
+            new_task_id = task_id_map.get(stored_item.task_id) if stored_item.task_id else None
+            if new_intent_id or new_task_id:
+                partial = {}
+                if new_intent_id:
+                    partial["intent_id"] = new_intent_id
+                if new_task_id:
+                    partial["task_id"] = new_task_id
+                current_mem = apply_command(
+                    current_mem,
+                    {"type": "memory.update", "item_id": mem_id, "partial": partial, "author": "system:import"},
+                ).state
+
+    return ImportResult(current_mem, current_intent, current_task, report)

memex_python-0.13.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: memex-python
+Version: 0.13.0
+Summary: MemEX memory layer (Pydantic port) — Multi-session continuity for AI systems
+Author: ai2070
+License: Apache-2.0
+License-File: LICENSE
+Keywords: agents,ai,knowledge-graph,memory,pydantic
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.6
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: fast-uuid
+Requires-Dist: uuid-utils>=0.7; extra == 'fast-uuid'
+Description-Content-Type: text/markdown
+
+# memex-python
+
+**Structured, provenance-tracked memory for AI agents — a faithful Pydantic port of [`@ai2070/memex`](https://www.npmjs.com/package/@ai2070/memex).**
+
+MemEX stores beliefs, evidence, conflicts, and updates — not just retrieved text. It separates three graphs (what is *believed* / *wanted* / *done*) and makes retrieval, contradiction, decay, and identity first-class. This is the Python implementation: every typed structure is a Pydantic v2 model, and behavior matches the TypeScript original (the full upstream test suite is ported — **575 tests**).
+
+- **Pure & immutable** — every mutation is `apply_command(state, cmd) -> (new_state, events)`.
+- **Pydantic-native** — models validate on construction; the discriminated-union commands *are* the schema.
+- **Wire-compatible** — command tags, enum values, and JSON keys are byte-identical to the TS library, so a Python service and a TS service can share one event log.
+
+## Install
+
+```bash
+pip install memex-python      # import name: `memex`
+```
+
+Only runtime dependency: `pydantic>=2.6`.
+
+## Quickstart (functional core)
+
+```python
+from memex import create_graph_state, create_memory_item, apply_command, get_scored_items
+
+state = create_graph_state()
+
+obs = create_memory_item(
+    scope="user:laz/general",
+    kind="observation",
+    content={"key": "login_count", "value": 42},
+    author="agent:monitor",
+    source_kind="observed",
+    authority=0.9,
+    importance=0.7,
+)
+state, events = apply_command(state, {"type": "memory.create", "item": obs})
+
+top = get_scored_items(state, {"authority": 1.0, "importance": 0.5})
+```
+
+Filters, options, and weights accept plain dicts *or* the typed models:
+
+```python
+from memex import get_items, smart_retrieve
+
+recent = get_items(state, {"kind": "observation", "range": {"authority": {"min": 0.5}}})
+
+packed = smart_retrieve(
+    state,
+    budget=2000,
+    cost_fn=lambda item: len(str(item.content)),
+    weights={"authority": 0.6, "importance": 0.4},
+    contradictions="surface",   # or "filter"
+    diversity={"author_penalty": 0.2},
+)
+```
+
+## Quickstart (`MemexStore` facade)
+
+For a stateful, object-oriented surface that rebinds state for you:
+
+```python
+from memex import MemexStore
+
+store = MemexStore()
+a = store.create(scope="user:laz", kind="observation", content={"v": 1},
+                 author="agent:x", source_kind="observed", authority=0.9)
+b = store.create(scope="user:laz", kind="assertion", content={"v": 2},
+                 author="agent:y", source_kind="user_explicit", authority=0.4)
+
+store.mark_contradiction(a.id, b.id, "system:detector")
+store.resolve_contradiction(a.id, b.id, "system:resolver")   # b's authority drops
+
+intent = store.create_intent(label="find target", priority=0.9, owner="user:laz")
+task = store.create_task(intent_id=intent.id, action="search", priority=0.8)
+
+snapshot = store.dumps(pretty=True)        # JSON; MemexStore.loads(...) restores
+```
+
+## The three graphs
+
+| Graph  | Reducer                 | Core type    | Holds                                   |
+|--------|-------------------------|--------------|-----------------------------------------|
+| Memory | `apply_command`         | `MemoryItem` | beliefs, evidence, contradictions, edges|
+| Intent | `apply_intent_command`  | `Intent`     | active goals with a status machine      |
+| Task   | `apply_task_command`    | `Task`       | units of work tied to intents           |
+
+Each item carries three orthogonal `0..1` scores — **authority** (trust), **conviction** (author confidence), **importance** (current salience) — plus `kind`, `source_kind`, `parents` (provenance), and typed `edges` (`DERIVED_FROM`, `CONTRADICTS`, `SUPPORTS`, `ABOUT`, `SUPERSEDES`, `ALIAS`).
+
+## Validating external input
+
+```python
+from memex.schemas import validate_command
+from memex import apply_command
+
+cmd = validate_command(raw)          # raises pydantic.ValidationError on a bad shape
+state = apply_command(state, cmd).state
+```
+
+## Intentional divergences from the TS library
+
+1. **Always-on validation** — constructing any model with an out-of-range score raises `pydantic.ValidationError` (TS only validated inside the factories). Use `Model.model_construct(...)` to bypass for deliberately-invalid fixtures.
+2. **Error types** — score-bound violations surface as `ValidationError`; `cost_fn` contract violations and unknown sort/decay enums as `ValueError` (the TS `RangeError`).
+3. **Frozen entities** — `MemoryItem` / `Edge` / `Intent` / `Task` are immutable; "edits" produce new instances (`model_copy(update=...)`).
+4. **`from_` field** — `from` is a Python keyword, so `Edge.from_` is the attribute; it serializes to `"from"` via its alias.
+
+Everything else — command tags, JSON shape, scoring/decay math, contradiction determinism, replay tolerance, transplant re-id semantics — matches the TS library exactly.
+
+## Development
+
+CI uses [uv](https://docs.astral.sh/uv/) (see `.github/workflows/`):
+
+```bash
+uv sync --all-extras
+uv run ruff check .
+uv run mypy
+uv run pytest            # 582 tests
+```
+
+Or with plain pip:
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+Releases publish to PyPI via `release.yml` (trusted publishing) on a published
+GitHub release, or manually via `workflow_dispatch`.
+
+## License
+
+Apache-2.0 (matching upstream).

memex_python-0.13.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+memex/__init__.py,sha256=gjFi-oJ0VkC4plkpQAGLRbYeH47e_-6RwRb7lpGP4cE,7049
+memex/_time.py,sha256=vL2v-X1V_bfBk6YmA1odOLB3enD8B93YHVpoEjRxl5E,813
+memex/_uuid.py,sha256=CMwTk0mal31OaxDV2mDvvYZzNKmrpfBw3y8L2b1b270,1802
+memex/bulk.py,sha256=qsNycVKTPX9y42GE7ppCtcDWavps53Mf8vErJID0G_8,4977
+memex/commands.py,sha256=oxucr0T0I5-zL2uQX40NbLFYFXvTRtqd54TiQI_l7G4,1820
+memex/envelope.py,sha256=Hawb4WwKJCkAvuLd0Yy2fUw7RRcWcIiWADM0EKmTs3Y,1957
+memex/errors.py,sha256=SeWkp-LS480G335Tf9YFkDzHj40SOjCMVK1ZlVLkOLE,1496
+memex/factories.py,sha256=doUQVtHZMcYFGhTB8SDATY9vARkE-_gUhVJ0c-2we8A,2481
+memex/graph.py,sha256=cOKy4aHyGHpvpW01PQN9oSXi90dljtlCVsk_xtOm-Wo,990
+memex/integrity.py,sha256=6ag3aWBu6D5tZF42CzBX5d3PTgJ_jrqeba0G0ZouH-o,9970
+memex/intent.py,sha256=0fC5psB4XL4bmTwKcESwatWtJM-lxzcLAcV4w7NbIwU,9760
+memex/models.py,sha256=y-21g1yaYDqHGJhhJxZ2sglzvmPurhZHxGQ86Bw5u6I,7165
+memex/query.py,sha256=viA0VUfwb9T6h_P_kSXDcRQ8TKXXEWbb2v_nxkxkipA,13997
+memex/reducer.py,sha256=LizTv0Sq0KrKI3rCdRfxqYFI5FlCjmJ9kh9VHzVKP6o,5850
+memex/replay.py,sha256=n5STHAph9X0InwjgHbhaB6yc3lw4WH9SosS_CNQJO_4,4906
+memex/retrieval.py,sha256=I6yGL4-k5yAcprcSH1pGat4btdI_jroo8ml_Dp_SNKw,9478
+memex/schemas.py,sha256=Y615cHv0q-vq5HYwSZt9009Sux65G1G7eBuwsA9m_fk,1945
+memex/serialization.py,sha256=qxDq6JUatW0MWNPBwyuceA23cUmDlY9I2BdIRvsJLLs,1540
+memex/stats.py,sha256=FQIx22V6sukTR75lUms49q0qaw-9_DS1F6DVbyhfge4,1726
+memex/store.py,sha256=RRQ8C4MT3J1KJBowvwI5nfloZ7HK22vZbe_DFb6EFcg,8907
+memex/task.py,sha256=rxx5kqyVHE-R2WdytIXS8SMnDVsJ6dGK040_6CL3PMU,11863
+memex/transplant.py,sha256=DPlEyGCXEvR4fq4QMaX_Cq2wm7z7VTiSaRTwWcQIVHM,19911
+memex_python-0.13.0.dist-info/METADATA,sha256=ZyUKfx_hBsB0mCGiVNOQUzmX9aFMUag6ptZfz4liNHQ,5902
+memex_python-0.13.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+memex_python-0.13.0.dist-info/licenses/LICENSE,sha256=oc05WPTsmK3_T41pcWhsaIIB0l3hwgn5Yaku9Iqkkv4,10757
+memex_python-0.13.0.dist-info/RECORD,,

memex_python-0.13.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any