memplex 3.2.0__py3-none-any.whl

memnex/worker.py

@@ -0,0 +1,412 @@
+"""BackgroundWorker -- async task processor for long-running operations.
+
+Runs tasks (index builds, wiki compilation, vector refresh, compaction)
+on a daemon thread so the main session is never blocked.
+
+Task state is persisted to a lightweight JSON file so that pending/running
+tasks survive process crashes and can be recovered on restart.
+
+Usage::
+
+    worker = BackgroundWorker()
+    worker.start()
+    task_id = worker.submit(BackgroundTask.BUILD_INDEX, {"func_id": "abc"})
+    ...
+    status = worker.get_status(task_id)
+    worker.stop()
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+from queue import Empty, Queue
+from threading import Thread, Timer
+from typing import Any, Callable, Dict, List, Optional
+
+from memnex.models import BackgroundTask, TaskInfo, TaskStatus
+
+logger = logging.getLogger(__name__)
+
+
+def _generate_uuid() -> str:
+    return uuid.uuid4().hex
+
+
+def _json_serializer(obj: Any) -> Any:
+    """JSON serializer for non-standard types."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, Path):
+        return str(obj)
+    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+
+# ── TaskStore: lightweight JSON persistence ────────────────────────────
+
+
+class TaskStore:
+    """Persist task state to a single JSON file.
+
+    File format::
+
+        {
+            "tasks": {
+                "<task_id>": { ... TaskInfo dict ... },
+                ...
+            }
+        }
+    """
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._tasks: Dict[str, Dict[str, Any]] = {}
+        self._load()
+
+    # ── Persistence ─────────────────────────────────────────────────
+
+
+    def _load(self) -> None:
+        """Load tasks from disk (no-op if file does not exist)."""
+        if self._path.exists():
+            try:
+                with open(self._path, "r", encoding="utf-8") as fh:
+                    data = json.load(fh)
+                self._tasks = data.get("tasks", {})
+            except (json.JSONDecodeError, OSError) as exc:
+                logger.warning("Failed to load task store from %s: %s", self._path, exc)
+                self._tasks = {}
+
+    def _save(self) -> None:
+        """Flush tasks to disk."""
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with open(self._path, "w", encoding="utf-8") as fh:
+                json.dump({"tasks": self._tasks}, fh, default=_json_serializer, indent=2)
+        except OSError as exc:
+            logger.error("Failed to persist task store to %s: %s", self._path, exc)
+
+    # ── CRUD ────────────────────────────────────────────────────────
+
+
+    def save(self, info: TaskInfo) -> None:
+        """Save or update a TaskInfo."""
+        self._tasks[info.task_id] = self._info_to_dict(info)
+        self._save()
+
+    def get(self, task_id: str) -> Optional[TaskInfo]:
+        """Retrieve a TaskInfo by ID, or ``None``."""
+        data = self._tasks.get(task_id)
+        if data is None:
+            return None
+        return self._dict_to_info(data)
+
+    def list_by_status(self, *statuses: TaskStatus) -> List[TaskInfo]:
+        """Return all tasks matching any of the given statuses."""
+        status_values = {s.value for s in statuses}
+        result: List[TaskInfo] = []
+        for data in self._tasks.values():
+            if data.get("status") in status_values:
+                result.append(self._dict_to_info(data))
+        return result
+
+    # ── Serialisation helpers ───────────────────────────────────────
+
+
+    @staticmethod
+    def _info_to_dict(info: TaskInfo) -> Dict[str, Any]:
+        return {
+            "task_id": info.task_id,
+            "task_type": info.task_type.value,
+            "status": info.status.value,
+            "created_at": info.created_at.isoformat() if info.created_at else None,
+            "completed_at": info.completed_at.isoformat() if info.completed_at else None,
+            "payload": info.payload,
+            "result": info.result,
+            "error": info.error,
+            "retry_count": info.retry_count,
+            "max_retries": info.max_retries,
+        }
+
+    @staticmethod
+    def _dict_to_info(data: Dict[str, Any]) -> TaskInfo:
+        return TaskInfo(
+            task_id=data["task_id"],
+            task_type=BackgroundTask(data["task_type"]),
+            status=TaskStatus(data["status"]),
+            created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else datetime.now(),
+            completed_at=datetime.fromisoformat(data["completed_at"]) if data.get("completed_at") else None,
+            payload=data.get("payload"),
+            result=data.get("result"),
+            error=data.get("error"),
+            retry_count=data.get("retry_count", 0),
+            max_retries=data.get("max_retries", 3),
+        )
+
+
+# ── BackgroundWorker ──────────────────────────────────────────────────
+
+
+class BackgroundWorker:
+    """Background task processor.
+
+    Parameters
+    ----------
+    storage_path:
+        Path to the JSON file used for task persistence.
+        Defaults to ``~/.memnex/tasks.json``.
+    """
+
+    def __init__(
+        self,
+        storage_path: Path = Path("~/.memnex/tasks.json").expanduser(),
+    ) -> None:
+        self._task_store = TaskStore(storage_path)
+        self._queue: Queue = Queue()
+        self._running: bool = False
+        self._worker_thread: Optional[Thread] = None
+        self._recover_pending_tasks()
+
+    # ── Lifecycle ───────────────────────────────────────────────────
+
+
+    def start(self) -> None:
+        """Start the background worker daemon thread."""
+        if self._running:
+            return
+        self._running = True
+        self._worker_thread = Thread(target=self._run_loop, daemon=True)
+        self._worker_thread.start()
+        logger.info("BackgroundWorker started")
+
+    def stop(self, timeout: float = 30.0) -> None:
+        """Gracefully stop the worker, waiting up to *timeout* seconds."""
+        self._running = False
+        if self._worker_thread is not None:
+            self._worker_thread.join(timeout=timeout)
+            if self._worker_thread.is_alive():
+                logger.warning("BackgroundWorker did not stop within %.1fs", timeout)
+        logger.info("BackgroundWorker stopped")
+
+    # ── Public API ──────────────────────────────────────────────────
+
+
+    def submit(
+        self,
+        task: BackgroundTask,
+        payload: dict,
+        callback: Optional[Callable] = None,
+    ) -> str:
+        """Submit a background task, returning the ``task_id``.
+
+        Parameters
+        ----------
+        task:
+            Type of background task.
+        payload:
+            Arbitrary data forwarded to the task handler.
+        callback:
+            Optional function called with the handler's result on success.
+        """
+        task_id = _generate_uuid()
+        info = TaskInfo(
+            task_id=task_id,
+            task_type=task,
+            status=TaskStatus.PENDING,
+            created_at=datetime.now(),
+            payload=payload,
+        )
+        self._task_store.save(info)
+        self._queue.put(
+            {"id": task_id, "task": task, "payload": payload, "callback": callback}
+        )
+        logger.debug("Submitted task %s (%s)", task_id, task.value)
+        return task_id
+
+    def get_status(self, task_id: str) -> TaskStatus:
+        """Return the current status of a task."""
+        info = self._task_store.get(task_id)
+        if info is None:
+            raise KeyError(f"Task {task_id!r} not found")
+        return info.status
+
+    def cancel(self, task_id: str) -> bool:
+        """Cancel a pending task.
+
+        Returns ``True`` if the task was successfully cancelled,
+        ``False`` if it was already running/completed.
+        """
+        info = self._task_store.get(task_id)
+        if info is None:
+            return False
+        if info.status in (TaskStatus.PENDING,):
+            info.status = TaskStatus.CANCELLED
+            self._task_store.save(info)
+            return True
+        return False
+
+    # ── Worker loop ─────────────────────────────────────────────────
+
+
+    def _run_loop(self) -> None:
+        """Main loop: dequeue tasks and execute them."""
+        while self._running:
+            try:
+                task = self._queue.get(timeout=5.0)
+                self._execute_task(task)
+            except Empty:
+                continue
+            except Exception as exc:
+                logger.error("Unexpected error in worker loop: %s", exc, exc_info=True)
+
+    def _execute_task(self, task: dict) -> None:
+        """Execute a single task with retry support.
+
+        Steps:
+        1. Update status to RUNNING.
+        2. Dispatch to the correct handler.
+        3. On success: COMPLETED + optional callback.
+        4. On failure: retry with exponential backoff (Timer), or mark FAILED.
+        """
+        task_id = task["id"]
+        task_type = task["task"]
+        payload = task.get("payload", {})
+
+        info = self._task_store.get(task_id)
+        if info is None:
+            return
+
+        info.status = TaskStatus.RUNNING
+        self._task_store.save(info)
+
+        try:
+            result = self._dispatch(task_type, payload)
+            info.status = TaskStatus.COMPLETED
+            info.result = result
+            info.completed_at = datetime.now()
+
+            callback = task.get("callback")
+            if callback is not None:
+                try:
+                    callback(result)
+                except Exception as cb_exc:
+                    logger.warning("Callback error for task %s: %s", task_id, cb_exc)
+
+        except Exception as exc:
+            if info.retry_count < info.max_retries:
+                info.retry_count += 1
+                info.status = TaskStatus.PENDING
+                self._task_store.save(info)
+                delay = min(2 ** info.retry_count, 30)  # exponential backoff, max 30s
+                logger.info(
+                    "Retrying task %s (%s) in %ds (attempt %d/%d)",
+                    task_id, task_type.value, delay, info.retry_count, info.max_retries,
+                )
+                Timer(
+                    delay,
+                    self._queue.put,
+                    args=[{"id": task_id, "task": task_type, "payload": payload}],
+                ).start()
+                return
+            info.status = TaskStatus.FAILED
+            info.error = str(exc)
+            logger.error("Task %s failed permanently: %s", task_id, exc)
+
+        finally:
+            self._task_store.save(info)
+
+    # ── Dispatch & task handlers ────────────────────────────────────
+
+
+    def _dispatch(self, task_type: BackgroundTask, payload: dict) -> Any:
+        """Route a task to its handler."""
+        handlers = {
+            BackgroundTask.EXTRACT_DOCUMENT: self._handle_extract,
+            BackgroundTask.BUILD_INDEX: self._handle_build_index,
+            BackgroundTask.COMPILE_WIKI: self._handle_compile_wiki,
+            BackgroundTask.REFRESH_VECTOR: self._handle_refresh_vector,
+            BackgroundTask.COMPACTION: self._handle_compaction,
+        }
+        handler = handlers.get(task_type)
+        if handler is None:
+            raise ValueError(f"Unknown task type: {task_type}")
+        return handler(payload)
+
+    def _handle_extract(self, payload: dict) -> dict:
+        """Handle EXTRACT_DOCUMENT tasks.
+
+        Stub: concrete extraction logic is wired by the application layer
+        (MemNexService or a plugin).  This method provides the scaffolding.
+        """
+        logger.info("Extract document: %s", payload.get("source_id", "<unknown>"))
+        return {"status": "completed", "extracted": True}
+
+    def _handle_build_index(self, payload: dict) -> dict:
+        """Handle BUILD_INDEX tasks."""
+        logger.info("Build index: %s", payload.get("func_id", "<batch>"))
+        return {"status": "completed", "indexed": True}
+
+    def _handle_compile_wiki(self, payload: dict) -> dict:
+        """Handle COMPILE_WIKI tasks."""
+        logger.info("Compile wiki: %s", payload.get("domain", "<all>"))
+        return {"status": "completed", "compiled": True}
+
+    def _handle_refresh_vector(self, payload: dict) -> dict:
+        """Handle REFRESH_VECTOR tasks."""
+        logger.info("Refresh vector: %s", payload.get("func_id", "<batch>"))
+        return {"status": "completed", "refreshed": True}
+
+    def _handle_compaction(self, payload: dict) -> dict:
+        """Handle COMPACTION tasks.
+
+        The actual :class:`CompactionPipeline` is invoked here.  Because
+        the pipeline's ``run`` method is async, this handler calls
+        ``asyncio.run`` (or the thread-safe equivalent) when a pipeline
+        instance is injected.
+        """
+        trigger = payload.get("trigger", "manual")
+        scope = payload.get("scope", "global")
+        logger.info("Compaction triggered: trigger=%s scope=%s", trigger, scope)
+        return {"status": "completed", "trigger": trigger, "scope": scope}
+
+    # ── Recovery ────────────────────────────────────────────────────
+
+
+    def _recover_pending_tasks(self) -> None:
+        """Re-queue tasks that were pending or running when the process died."""
+        pending = self._task_store.list_by_status(
+            TaskStatus.PENDING, TaskStatus.RUNNING
+        )
+        for t in pending:
+            if t.status == TaskStatus.RUNNING:
+                # Only re-queue RUNNING tasks that have exceeded a 1-hour timeout
+                elapsed = (datetime.now() - t.created_at).total_seconds()
+                if elapsed > 3600:
+                    t.status = TaskStatus.PENDING
+                    self._task_store.save(t)
+                    self._queue.put(
+                        {
+                            "id": t.task_id,
+                            "task": t.task_type,
+                            "payload": t.payload or {},
+                        }
+                    )
+                else:
+                    logger.warning(
+                        "Task %s (%s) was RUNNING before shutdown; "
+                        "skipping re-queue (not timed out)",
+                        t.task_id,
+                        t.task_type.value,
+                    )
+            else:
+                self._queue.put(
+                    {
+                        "id": t.task_id,
+                        "task": t.task_type,
+                        "payload": t.payload or {},
+                    }
+                )

memplex-3.2.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: memplex
+Version: 3.2.0
+Summary: Memplex - Memory Complex: multi-agent knowledge graph memory system with 3-layer retrieval
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: embedding
+Requires-Dist: sentence-transformers>=2.0; extra == "embedding"
+Provides-Extra: extractors
+Requires-Dist: pdfplumber>=0.9.0; extra == "extractors"
+Requires-Dist: python-docx>=0.8.11; extra == "extractors"
+Requires-Dist: Pillow>=9.0; extra == "extractors"
+Requires-Dist: pytesseract>=0.3.10; extra == "extractors"
+Provides-Extra: vector
+Requires-Dist: chromadb>=0.4.0; extra == "vector"
+Requires-Dist: sentence-transformers>=2.0; extra == "vector"
+Provides-Extra: graph
+Requires-Dist: networkx>=3.0; extra == "graph"
+Requires-Dist: python-louvain>=0.16; extra == "graph"
+Provides-Extra: http
+Requires-Dist: fastapi>=0.100.0; extra == "http"
+Requires-Dist: uvicorn>=0.23.0; extra == "http"
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.30.0; extra == "llm"
+Requires-Dist: openai>=1.0.0; extra == "llm"
+Provides-Extra: postgres
+Requires-Dist: asyncpg>=0.29.0; extra == "postgres"
+Provides-Extra: neo4j
+Requires-Dist: neo4j>=5.0.0; extra == "neo4j"
+Provides-Extra: all
+Requires-Dist: memnex[embedding,extractors,graph,http,llm,vector]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"

memplex-3.2.0.dist-info/RECORD

@@ -0,0 +1,83 @@
+memnex/__init__.py,sha256=Fvq5TO_UfCi4rm4NStjFO21JAzz8LxmqyQkse3VHWhc,625
+memnex/__main__.py,sha256=vyokcq-HeGBLwJl0ioY95yHrNKCCdqomN7tKk7u-1S8,111
+memnex/compaction.py,sha256=wOdLRKpVeDuFcxWc2AYBcgMkUR8kKAB03KXrB1ehaGQ,20703
+memnex/config.py,sha256=DdH4Xb8vBEV5yw28i8tPO3gfZ9OBQl5GOt_UKch3pgk,11799
+memnex/service.py,sha256=LnnhwWnVZnvkMaSygR8OM6vrek_blf7llDSTf6WxySs,33827
+memnex/worker.py,sha256=szJcIADLQP1779OsYhr1W7Dwa-k8xpev7UytqrVtfMI,15516
+memnex/_plugin/.mcp.json,sha256=gV4HuPqbWm68yZZA1zN4lzzq027iijN207oX3ZE8yVc,149
+memnex/_plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memnex/_plugin/.claude-plugin/plugin.json,sha256=5VMvDw2OGl4isox_GOnii8AbWxDFBrPN5ddUux7c4_A,546
+memnex/_plugin/hooks/hooks.json,sha256=F9CUi_qfM5IqGTc0mLVbbjgjd723eeeF_GGFBFZhSC0,1415
+memnex/_plugin/scripts/hook-runner.py,sha256=9nz5rJ7NhPDf1rdCy0nRRLqe_KDiYUmC0nHIZSxu6LQ,4977
+memnex/_plugin/skills/mem-explore/SKILL.md,sha256=n4a5jumCKK5EFqlcr3Kqh6Dh1yCPVcTzsWF7EWvVW-w,1868
+memnex/_plugin/skills/mem-manage/SKILL.md,sha256=BCA8T126UpfkchP0bzxcBbaDv4d-AI-Mr8UkH68omZ4,1795
+memnex/_plugin/skills/mem-search/SKILL.md,sha256=iXEVA-p3Pw9jh4Pci9In8b8gsXEr0Vi0-e-uBKT2K7s,2134
+memnex/_plugin/skills/mem-write/SKILL.md,sha256=o7-ASDZ07yX5CakRAYLVajxXlayuw5MK3NhUxKaHYdY,1830
+memnex/adapters/__init__.py,sha256=hozQpKX4T-yYaf_8r_PM0XJ2mYDxUH_kbitdVOny0Lg,489
+memnex/adapters/claude_skill.py,sha256=016WGTfqHS5IeuXjsFAKdXyqBCRCOGUuiUpeIz2M9sU,4702
+memnex/adapters/cli.py,sha256=jlS0HTk5IQckP97KQbxaizQLFT7usTjFYz1D9KTRAWY,15983
+memnex/adapters/http_api.py,sha256=Img2GnY8XPlMyQyBLf21yUsDbjsvu4Y6T3dJdXszwYY,11159
+memnex/adapters/mcp_server.py,sha256=K_aEpvNo4TDXiiBAkDmycPsBo8ec2nK1DC1USzMnzDg,16197
+memnex/core/__init__.py,sha256=oM1wY1hnMULz3y-cA1I-Rs_EwH6aocrEMyKVMnTpJ0g,244
+memnex/core/engine.py,sha256=qqALfdMcHPetK8eRNRvOzvHe5bDcUG74vKY9ngS5QeA,26002
+memnex/core/associator/__init__.py,sha256=RIio0mK9v3IwwmQk3AtQ4pZnT32-xKjN4vXGOh_2wH4,276
+memnex/core/associator/domain_classifier.py,sha256=n4QtJwmq42mINpFnU6rg9qSmaGwfXpsjKdEPAk4XAus,3264
+memnex/core/associator/entity_aligner.py,sha256=vsKjrGeehXL11SsFcistKwNgYO_b5RAcwIIuy55-B2c,4263
+memnex/core/associator/ref_linker.py,sha256=iqOsDaTZdVE4KgKDGBpHhgvRpPw12UwJ2iERwF-1kjc,7067
+memnex/core/associator/term_mapper.py,sha256=_bMJ519UIooAI3xy6_92VsXKhs1XQ7OG2HAu4aSYAEQ,2760
+memnex/core/dictionaries/__init__.py,sha256=F191-dJCbewWIccBLIlng6nEs4ckIUVK4oEB7cxMGzg,1652
+memnex/core/extractors/__init__.py,sha256=obVyUCZMNbNlwlDBz4BogzTAjP8K_RM-1SznlmDW0Hs,347
+memnex/core/extractors/docx.py,sha256=4JJi77uRa3uXrqnZx2CuP0OhuDee-Au5B6Z7Os88NpQ,2749
+memnex/core/extractors/image.py,sha256=n63ZfzQ6v6mRfH6qNOEYZNHIXax6B6Nd0OvPq8fsmY8,8424
+memnex/core/extractors/markdown.py,sha256=0AvLSDtVPGUCqfw7rWKAW1R7H7QqKsxP5TgoBKS2c-E,4858
+memnex/core/extractors/pdf.py,sha256=95u2HdI1R92s2wq3Od9QOABs8hP24uXWwkpx5S4mFTU,4962
+memnex/core/extractors/vision_mapper.py,sha256=a3DB0aLdzdNvfSC4GgCa10jeWDG4oS4xrY4EZ8iHXGY,4201
+memnex/core/handlers/__init__.py,sha256=xhTYXT6UMsICyHT2r1nJ6jrl5NalyCHfpciCeI_SJU8,226
+memnex/core/handlers/clipboard.py,sha256=CJiTMs7CpJdx0tuOFcPqx7TH6gvklPbtqG7bhbz0mQ0,996
+memnex/core/handlers/file_handler.py,sha256=kCQFt1g4P4abbE_YFlKChvF8HLsRyl2LusFs-t90f50,1723
+memnex/core/handlers/url_handler.py,sha256=2EWsxQIUM_YtwenLQQzg3T7XCCpSitIF6r-BCLMVer4,4290
+memnex/llm/__init__.py,sha256=8jUzWx7fGplalWmvYFeXXs3yTohr7qLVtnCzhiBLh4E,857
+memnex/llm/enhancer.py,sha256=4ZCKUHQsiXaz7zb2DWh4KS0JLlIotveGYTYpUVSHKqU,8373
+memnex/llm/fallback_chain.py,sha256=jZpV529CTFvTBTr07UNPzz28FRAI2io915KrTcIyNmY,3138
+memnex/llm/injection_guard.py,sha256=T3x8UYTKR4cPOsrOJvbVlWNmmoF4SRnVZzptw-d524s,6082
+memnex/llm/provider.py,sha256=yQcWCD0moWLBpohoqnygUJpGodJL-X3-a1g7TOjNZjk,4219
+memnex/llm/sanitizer.py,sha256=ufjRGa-8bRlRQqZKrMkDRT6YjwyCJ1c-xcwiAe3oM8M,2198
+memnex/llm/providers/__init__.py,sha256=7s1zR8QNx-h_IvGn-6PbRIWcI52ogfexb14mIEsHvv4,751
+memnex/llm/providers/anthropic.py,sha256=2yqsopfH3kFgTrtKZQe63qa1MEe0qdvqzlzvVVz_FBg,4765
+memnex/llm/providers/local.py,sha256=_5l0frfqd2v_v86NcgC2zQw08--jjcpGQ3hTj7v1iEA,4852
+memnex/llm/providers/rule_based.py,sha256=2pQixBI_M4hRTUKp31fmLNeVVly99K45dV5PhFpnKdU,2396
+memnex/models/__init__.py,sha256=wvoToWac6Nyh2ihZnbDkENyt02PYOQnVzHL6v0Dge1Y,1113
+memnex/models/feedback.py,sha256=gGoeGteYT4R-uNp3_B7HSj_Q4n4uZHh2a6rCvr8sMPA,1103
+memnex/models/graph.py,sha256=Kquzk-dOivI4SPLzIQxjp7kp5eZPBPoUxUOYxgNgWCo,831
+memnex/models/memory.py,sha256=r_TWV5vD4Gpo4jxzXTE50BeTr8MP_HCrzqlGjLhTiAc,3193
+memnex/models/misc.py,sha256=X6VbkH1J9xToMkY5MSFnUfVjx07n2FCYpcXt-ZK2PVc,4873
+memnex/models/paragraph.py,sha256=yUIA8zl1bmYyWsBkVVBhzv73Q5JLLQlP2y7PTmUJzfA,1062
+memnex/models/search.py,sha256=Z_TniJoiuTryYUNcmLXEqJbYg5xdnLK5nQQf3CjcScA,1244
+memnex/models/source.py,sha256=TsM_ps9tlu7Im86FyYyzDDEl6vPHAgDKncB-oJGesME,554
+memnex/models/task.py,sha256=QmeCjFDVawLjXpnQpII6tmDI_c1Kw-UkECsm6ptdF3Y,1311
+memnex/processing/__init__.py,sha256=jmRg4f0OMcMb0ik4cYNd37EszTUA3H3ASbRJ3sGMU1E,70
+memnex/processing/graph_builder.py,sha256=HmCv7ZQFOqsBjqYImq50zvehW2kEyCE7CG0pkVDOfHM,9985
+memnex/processing/merger/__init__.py,sha256=GswF67EW40RnOoZu4XDngl7wteT5Ab2vl7EwRAkG2xM,228
+memnex/processing/merger/confidence_calculator.py,sha256=_UjzDat0xVR_Gg1jHQBtvm-uC7zzpD0jGF2-4kUQ-w0,3632
+memnex/processing/merger/conflict_resolver.py,sha256=-W6qTFMVkgTvZcYrm3FlGXoyfv1UWSbSjeT800WDCjg,4303
+memnex/retrieval/__init__.py,sha256=U2tfpBNkpxGUiTrCbFRgW0LNwBOiSzngGqD2XPB6EZo,63
+memnex/retrieval/dedup.py,sha256=XJZE6VzF6qARriytAQyo63PP9Q5DG24jZpoXZrRfAo4,13755
+memnex/retrieval/embedding.py,sha256=WV4mQYMcMb3rU2ELLz2_YDBVb6bl2ejjSh3Nt0xuwg0,9926
+memnex/retrieval/reranker.py,sha256=VMYa00mjdImfOyLg398giCg8ZHTVxDnipoBkajtvRn0,10493
+memnex/storage/__init__.py,sha256=a3eSLKcW43-vhYtg64dDifWmab1_0J022vJeli8Vz18,1769
+memnex/storage/base.py,sha256=keClRSIRSSvDEnjG-BpZIYJqib8qwTV4jXOAGet7Vio,4329
+memnex/storage/changelog.py,sha256=NeJPaeyP1b0xsm0C3WE7xwqP0Ey15DtY_YSnFyfR818,3516
+memnex/storage/feedback.py,sha256=KX5nh0wUyMHH3_N63CCN22pbsPp9RLI3XAV-G0Skg4k,17809
+memnex/storage/vector.py,sha256=3NMcW7ZGTns8ztXxXUNSU3jNhSzIZUAriHaPGzp-qMM,9149
+memnex/storage/lite/__init__.py,sha256=tkb36Zswwho1MV2VVP7asgLd8pm50BIHh-emsttr7IA,146
+memnex/storage/lite/store.py,sha256=qcPdZhz8DnDKwgzSmSt_5DDpjOWByODIK-xwbZt9FUE,22225
+memnex/wiki/__init__.py,sha256=Ecbi5q42fou-YCW4SJlLTIdKUbo6zaoorimS3OK1wn0,302
+memnex/wiki/community.py,sha256=MBlsH3KQSxPZvr6btGhl6lLpDX8WA4huAflVw_gq5hk,6797
+memnex/wiki/compiler.py,sha256=4J2Fpm_Tuc-Z4tnRraZLfeZvVsR_3S5LWu08vIXnVHY,19377
+memnex/wiki/generator.py,sha256=88074p1YsniKfSjO03_N4FBrpPQSJ4i7YCmB6aaaGts,9708
+memnex/wiki/search.py,sha256=ChRIY64mBGHusmsOegHaV0ZHsFCC74s89birhSbgWbc,9935
+memplex-3.2.0.dist-info/METADATA,sha256=U2hg8XAvGYPzqffOdf0i_5hCxNlPfwl2fIw4v7lqJeU,1496
+memplex-3.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+memplex-3.2.0.dist-info/entry_points.txt,sha256=-Yxo9jmeV9cE-H9dv6O1FMgXtP9CxtNsk4gt5ICBsY8,39
+memplex-3.2.0.dist-info/top_level.txt,sha256=PvQgcpCkjlAM8AHaruBtzobW2qVjHtCutBWNgg4j8XQ,7
+memplex-3.2.0.dist-info/RECORD,,

memplex-3.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

memplex-3.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memnex = memnex:main

memplex-3.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+memnex