wavemind 2.0.0__py3-none-any.whl

wavemind/indexes.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class IndexResult:
+    id: int
+    score: float
+
+
+def _normalize(vector: np.ndarray) -> np.ndarray:
+    vector = np.asarray(vector, dtype=np.float32)
+    norm = float(np.linalg.norm(vector))
+    if norm <= 1e-12:
+        return vector
+    return (vector / norm).astype(np.float32)
+
+
+class NumpyVectorIndex:
+    name = "numpy-exact"
+
+    def __init__(self, vector_dim: int):
+        self.vector_dim = int(vector_dim)
+        self._vectors: dict[int, np.ndarray] = {}
+        self._ids = np.array([], dtype=np.int64)
+        self._matrix = np.zeros((0, self.vector_dim), dtype=np.float32)
+        self._dirty = True
+
+    def add(self, id: int, vector: np.ndarray) -> None:
+        self._vectors[int(id)] = _normalize(vector)
+        self._dirty = True
+
+    def remove(self, id: int) -> None:
+        self._vectors.pop(int(id), None)
+        self._dirty = True
+
+    def build(self, records: Iterable) -> None:
+        self._vectors.clear()
+        for record in records:
+            self.add(record.id, record.vector)
+        self._dirty = True
+
+    def _ensure_matrix(self) -> None:
+        if not self._dirty:
+            return
+        if not self._vectors:
+            self._ids = np.array([], dtype=np.int64)
+            self._matrix = np.zeros((0, self.vector_dim), dtype=np.float32)
+            self._dirty = False
+            return
+        items = sorted(self._vectors.items())
+        self._ids = np.array([id for id, _ in items], dtype=np.int64)
+        self._matrix = np.stack([vector for _, vector in items]).astype(np.float32)
+        self._dirty = False
+
+    def search(
+        self,
+        vector: np.ndarray,
+        top_k: int = 3,
+        allowed_ids: set[int] | None = None,
+    ) -> list[IndexResult]:
+        if top_k <= 0 or not self._vectors:
+            return []
+
+        self._ensure_matrix()
+        query = _normalize(vector)
+        if allowed_ids is None:
+            ids = self._ids
+            matrix = self._matrix
+        else:
+            mask = np.fromiter((int(id) in allowed_ids for id in self._ids), dtype=bool)
+            if not np.any(mask):
+                return []
+            ids = self._ids[mask]
+            matrix = self._matrix[mask]
+        if ids.size == 0:
+            return []
+
+        scores = matrix @ query
+        order = np.argsort(scores)[::-1][:top_k]
+        return [IndexResult(int(ids[int(i)]), float(scores[int(i)])) for i in order]
+
+    def __len__(self) -> int:
+        return len(self._vectors)
+
+
+class FaissVectorIndex(NumpyVectorIndex):
+    name = "faiss-flat-ip"
+
+    def __init__(self, vector_dim: int):
+        try:
+            import faiss
+        except ImportError as exc:
+            raise ImportError("Install faiss-cpu to use FaissVectorIndex") from exc
+        super().__init__(vector_dim)
+        self._faiss = faiss
+        self._index = faiss.IndexFlatIP(self.vector_dim)
+        self._id_order: list[int] = []
+
+    def build(self, records: Iterable) -> None:
+        self._vectors.clear()
+        self._id_order.clear()
+        vectors = []
+        for record in records:
+            vector = _normalize(record.vector)
+            self._vectors[int(record.id)] = vector
+            self._id_order.append(int(record.id))
+            vectors.append(vector)
+        self._index = self._faiss.IndexFlatIP(self.vector_dim)
+        if vectors:
+            self._index.add(np.stack(vectors).astype(np.float32))
+        self._dirty = True
+
+    def add(self, id: int, vector: np.ndarray) -> None:
+        self._vectors[int(id)] = _normalize(vector)
+        self.build([type("Record", (), {"id": k, "vector": v}) for k, v in self._vectors.items()])
+
+    def remove(self, id: int) -> None:
+        self._vectors.pop(int(id), None)
+        self.build([type("Record", (), {"id": k, "vector": v}) for k, v in self._vectors.items()])
+
+    def search(
+        self,
+        vector: np.ndarray,
+        top_k: int = 3,
+        allowed_ids: set[int] | None = None,
+    ) -> list[IndexResult]:
+        if allowed_ids is not None:
+            return super().search(vector, top_k=top_k, allowed_ids=allowed_ids)
+        if top_k <= 0 or not self._id_order:
+            return []
+        query = _normalize(vector).reshape(1, -1).astype(np.float32)
+        scores, positions = self._index.search(query, min(top_k, len(self._id_order)))
+        results = []
+        for score, pos in zip(scores[0], positions[0]):
+            if pos < 0:
+                continue
+            results.append(IndexResult(self._id_order[int(pos)], float(score)))
+        return results
+
+
+class AnnoyVectorIndex(NumpyVectorIndex):
+    name = "annoy-angular"
+
+    def __init__(self, vector_dim: int, n_trees: int = 16):
+        try:
+            from annoy import AnnoyIndex
+        except ImportError as exc:
+            raise ImportError("Install annoy to use AnnoyVectorIndex") from exc
+        super().__init__(vector_dim)
+        self._AnnoyIndex = AnnoyIndex
+        self.n_trees = int(n_trees)
+        self._index = AnnoyIndex(self.vector_dim, "angular")
+        self._id_order: list[int] = []
+        self._built = False
+
+    def build(self, records: Iterable) -> None:
+        self._vectors.clear()
+        self._id_order.clear()
+        self._index = self._AnnoyIndex(self.vector_dim, "angular")
+        for pos, record in enumerate(records):
+            vector = _normalize(record.vector)
+            self._vectors[int(record.id)] = vector
+            self._id_order.append(int(record.id))
+            self._index.add_item(pos, vector.tolist())
+        if self._id_order:
+            self._index.build(self.n_trees)
+        self._built = True
+        self._dirty = True
+
+    def add(self, id: int, vector: np.ndarray) -> None:
+        self._vectors[int(id)] = _normalize(vector)
+        self.build([type("Record", (), {"id": k, "vector": v}) for k, v in self._vectors.items()])
+
+    def remove(self, id: int) -> None:
+        self._vectors.pop(int(id), None)
+        self.build([type("Record", (), {"id": k, "vector": v}) for k, v in self._vectors.items()])
+
+    def search(
+        self,
+        vector: np.ndarray,
+        top_k: int = 3,
+        allowed_ids: set[int] | None = None,
+    ) -> list[IndexResult]:
+        if allowed_ids is not None:
+            return super().search(vector, top_k=top_k, allowed_ids=allowed_ids)
+        if top_k <= 0 or not self._id_order or not self._built:
+            return []
+        positions, distances = self._index.get_nns_by_vector(
+            _normalize(vector).tolist(),
+            min(top_k, len(self._id_order)),
+            include_distances=True,
+        )
+        return [
+            IndexResult(self._id_order[int(pos)], float(1.0 - distance / 2.0))
+            for pos, distance in zip(positions, distances)
+        ]
+
+
+def create_vector_index(kind: str, vector_dim: int):
+    kind = (kind or "numpy").lower()
+    if kind in {"numpy", "exact"}:
+        return NumpyVectorIndex(vector_dim)
+    if kind == "faiss":
+        return FaissVectorIndex(vector_dim)
+    if kind == "annoy":
+        return AnnoyVectorIndex(vector_dim)
+    raise ValueError(
+        f"Unknown vector index kind: {kind}. Choose an explicit index: numpy, faiss, or annoy."
+    )

wavemind/storage.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+
+
+@dataclass
+class MemoryRecord:
+    text: str
+    vector: np.ndarray
+    pattern: np.ndarray
+    namespace: str = "default"
+    tags: tuple[str, ...] = ()
+    metadata: dict[str, Any] = field(default_factory=dict)
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    expires_at: float | None = None
+    priority: float = 1.0
+    access_count: int = 0
+    id: int | None = None
+
+    @property
+    def is_expired(self) -> bool:
+        return self.expires_at is not None and self.expires_at <= time.time()
+
+
+def _array_to_blob(array: np.ndarray) -> bytes:
+    return np.asarray(array, dtype=np.float32).tobytes()
+
+
+def _array_from_blob(blob: bytes, shape: Iterable[int]) -> np.ndarray:
+    return np.frombuffer(blob, dtype=np.float32).copy().reshape(tuple(shape))
+
+
+class SQLiteMemoryStore:
+    def __init__(self, path: str | Path | None = None):
+        self.path = str(path or ":memory:")
+        if self.path != ":memory:":
+            Path(self.path).parent.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(self.path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        self.ensure_schema()
+
+    def ensure_schema(self) -> None:
+        self.conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS memories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                namespace TEXT NOT NULL,
+                text TEXT NOT NULL,
+                vector BLOB NOT NULL,
+                vector_dim INTEGER NOT NULL,
+                pattern BLOB NOT NULL,
+                pattern_shape TEXT NOT NULL,
+                tags TEXT NOT NULL,
+                metadata TEXT NOT NULL,
+                created_at REAL NOT NULL,
+                updated_at REAL NOT NULL,
+                expires_at REAL,
+                priority REAL NOT NULL,
+                access_count INTEGER NOT NULL DEFAULT 0
+            )
+            """
+        )
+        self.conn.execute("CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace)")
+        self.conn.execute("CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at)")
+        self.conn.commit()
+
+    def insert(self, record: MemoryRecord) -> int:
+        now = time.time()
+        record.created_at = record.created_at or now
+        record.updated_at = now
+        cur = self.conn.execute(
+            """
+            INSERT INTO memories (
+                namespace, text, vector, vector_dim, pattern, pattern_shape,
+                tags, metadata, created_at, updated_at, expires_at, priority, access_count
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                record.namespace,
+                record.text,
+                _array_to_blob(record.vector),
+                int(record.vector.shape[0]),
+                _array_to_blob(record.pattern),
+                json.dumps(list(record.pattern.shape)),
+                json.dumps(list(record.tags), ensure_ascii=False),
+                json.dumps(record.metadata, ensure_ascii=False),
+                record.created_at,
+                record.updated_at,
+                record.expires_at,
+                float(record.priority),
+                int(record.access_count),
+            ),
+        )
+        self.conn.commit()
+        record.id = int(cur.lastrowid)
+        return record.id
+
+    def get(self, id: int) -> MemoryRecord | None:
+        row = self.conn.execute("SELECT * FROM memories WHERE id = ?", (int(id),)).fetchone()
+        return self._row_to_record(row) if row else None
+
+    def list(
+        self,
+        namespace: str | None = None,
+        include_expired: bool = False,
+        tags: Iterable[str] | None = None,
+    ) -> list[MemoryRecord]:
+        params: list[Any] = []
+        where = []
+        if namespace is not None:
+            where.append("namespace = ?")
+            params.append(namespace)
+        if not include_expired:
+            where.append("(expires_at IS NULL OR expires_at > ?)")
+            params.append(time.time())
+        sql = "SELECT * FROM memories"
+        if where:
+            sql += " WHERE " + " AND ".join(where)
+        rows = self.conn.execute(sql, params).fetchall()
+        records = [self._row_to_record(row) for row in rows]
+        required_tags = set(tags or [])
+        if required_tags:
+            records = [
+                record
+                for record in records
+                if required_tags.issubset(set(record.tags))
+            ]
+        return records
+
+    def delete(
+        self,
+        id: int | None = None,
+        text: str | None = None,
+        namespace: str | None = None,
+    ) -> list[MemoryRecord]:
+        params: list[Any] = []
+        where = []
+        if id is not None:
+            where.append("id = ?")
+            params.append(int(id))
+        if text is not None:
+            where.append("text = ?")
+            params.append(text)
+        if namespace is not None:
+            where.append("namespace = ?")
+            params.append(namespace)
+        if not where:
+            raise ValueError("delete requires id or text")
+
+        sql_where = " AND ".join(where)
+        rows = self.conn.execute(f"SELECT * FROM memories WHERE {sql_where}", params).fetchall()
+        records = [self._row_to_record(row) for row in rows]
+        self.conn.execute(f"DELETE FROM memories WHERE {sql_where}", params)
+        self.conn.commit()
+        return records
+
+    def purge_expired(self) -> int:
+        rows = self.conn.execute(
+            "SELECT * FROM memories WHERE expires_at IS NOT NULL AND expires_at <= ?",
+            (time.time(),),
+        ).fetchall()
+        ids = [int(row["id"]) for row in rows]
+        if ids:
+            placeholders = ",".join("?" for _ in ids)
+            self.conn.execute(f"DELETE FROM memories WHERE id IN ({placeholders})", ids)
+            self.conn.commit()
+        return len(ids)
+
+    def touch(self, id: int, priority_delta: float = 0.05) -> None:
+        self.conn.execute(
+            """
+            UPDATE memories
+            SET access_count = access_count + 1,
+                priority = priority + ?,
+                updated_at = ?
+            WHERE id = ?
+            """,
+            (float(priority_delta), time.time(), int(id)),
+        )
+        self.conn.commit()
+
+    def count(self, namespace: str | None = None, include_expired: bool = False) -> int:
+        return len(self.list(namespace=namespace, include_expired=include_expired))
+
+    def backup(self, destination: str | Path) -> Path:
+        destination = Path(destination)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        target = sqlite3.connect(str(destination))
+        with target:
+            self.conn.backup(target)
+        target.close()
+        return destination
+
+    def close(self) -> None:
+        self.conn.close()
+
+    def _row_to_record(self, row: sqlite3.Row) -> MemoryRecord:
+        pattern_shape = json.loads(row["pattern_shape"])
+        vector_dim = int(row["vector_dim"])
+        return MemoryRecord(
+            id=int(row["id"]),
+            namespace=row["namespace"],
+            text=row["text"],
+            vector=_array_from_blob(row["vector"], (vector_dim,)),
+            pattern=_array_from_blob(row["pattern"], pattern_shape),
+            tags=tuple(json.loads(row["tags"])),
+            metadata=json.loads(row["metadata"]),
+            created_at=float(row["created_at"]),
+            updated_at=float(row["updated_at"]),
+            expires_at=row["expires_at"],
+            priority=float(row["priority"]),
+            access_count=int(row["access_count"]),
+        )
+

wavemind-2.0.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: wavemind
+Version: 2.0.0
+Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CaspianG/wavemind
+Project-URL: Repository, https://github.com/CaspianG/wavemind
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2
+Requires-Dist: pypdf>=4
+Provides-Extra: sentence
+Requires-Dist: sentence-transformers>=3; extra == "sentence"
+Provides-Extra: ml
+Requires-Dist: sentence-transformers>=3; extra == "ml"
+Provides-Extra: indexes
+Requires-Dist: annoy>=1.17; extra == "indexes"
+Requires-Dist: faiss-cpu>=1.8; platform_system != "Windows" and extra == "indexes"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# WaveMind is persistent dynamic memory for AI agents: vector search first, wave-field priority second, SQLite as the source of truth.
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+[![Tests](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml/badge.svg)](https://github.com/CaspianG/wavemind/actions/workflows/tests.yml)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Terminal Demo
+
+```text
+$ python examples/demo.py
+✓ Remembered: "Andrey is a trader who tracks market breakouts."
+✓ Remembered: "Andrey prefers short practical answers about AI agents."
+
+Query: "Andrey trader agent"
+→ Result 1 (0.54): "Andrey is a trader who tracks market breakouts."
+→ Result 2 (0.30): "Andrey prefers short practical answers about AI agents."
+```
+
+The demo is offline, keyless, and uses the built-in hash encoder.
+
+## Quick Start
+
+```sh
+python -m pip install -e .
+wavemind remember "Andrey is a trader" --namespace demo
+wavemind query "trader" --namespace demo
+```
+
+This creates `wavemind.sqlite3` in your current working directory.
+
+For sentence-transformer embeddings:
+
+```sh
+python -m pip install -e ".[sentence]"
+wavemind --encoder sentence remember "Andrey is a trader" --namespace demo
+wavemind --encoder sentence query "What does Andrey do?" --namespace demo
+```
+
+One-file setup scripts are also included:
+
+```sh
+sh install.sh
+```
+
+```bat
+install.bat
+```
+
+## Benchmark
+
+Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
+
+| metric | hash | sentence-transformers |
+|---|---:|---:|
+| precision@1 | 1.00 | 1.00 |
+| precision@3 | 1.00 | 1.00 |
+| avg query | 0.49 ms | 52.84 ms |
+
+Capacity check with the hash encoder:
+
+| memories | precision@1 | precision@3 | avg query |
+|---:|---:|---:|---:|
+| 200 | 1.00 | 1.00 | 0.49 ms |
+| 1000 | 0.88 | 1.00 | 1.50 ms |
+| 5000 | 0.72 | 0.88 | 5.68 ms |
+
+Run locally:
+
+```sh
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder hash --index numpy
+python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
+```
+
+## Comparison
+
+| feature | WaveMind | Chroma | Qdrant |
+|---|---|---|---|
+| Primary role | Agent memory engine | Embedding database | Production vector database |
+| Local SQLite persistence | Yes | Yes | No, separate service/storage |
+| HTTP API | FastAPI included | Included | Included |
+| Dynamic memory priority | Wave-field hotness, TTL, priority | Metadata/filter driven | Payload/filter driven |
+| Built-in forgetting | TTL and explicit forget | Manual delete/filtering | Manual delete/filtering |
+| Best fit | Small to medium agent memory with dynamic recall | Local RAG apps and prototypes | Large-scale vector search |
+| Scale target today | Up to 1000 optimal on NumPy, FAISS recommended beyond 5000 | Larger than WaveMind local mode | Production scale |
+
+WaveMind is not trying to replace dedicated vector databases at scale. Its difference is dynamic priority: frequently used memories can become hotter while old or low-priority memories fade.
+
+## Known Limitations
+
+- Optimal capacity on the current NumPy exact index is up to 1000 records.
+- At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
+- For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
+- `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
+- The bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+
+## Roadmap
+
+- FAISS-first production index path with persisted index rebuilds.
+- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- Better semantic query expansion for short and ambiguous queries.
+- Namespace quotas, backups, and daemon hardening for SaaS use.
+- Webhook on recall for agent runtimes.
+- OHLCV pattern-memory experiments for market research and backtests.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

wavemind-2.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+wavemind/__init__.py,sha256=6FmY1qcTZByc-cDOEUvb6uShlKUghXWkRB6lp-Kjv4A,496
+wavemind/__main__.py,sha256=4BTAfHHF2u3j_oUg_Wluqu0HyxnXfAHBQUcnPQ-e1xs,50
+wavemind/api.py,sha256=vthe2fUxv4dTeXhIU8Z4boqULSk4gAFJPyO5OCFRMQw,5146
+wavemind/benchmark.py,sha256=oL3zAiyRwzj5Puh1Ex6c9U-0_mAY9bS1pSA-xUxEpUg,2081
+wavemind/cli.py,sha256=c40q_34_FJA1ojuoPoiIG1jELmNeW5jO7z-2_H8PBto,8341
+wavemind/core.py,sha256=nsgb4Yuw6BND2SE8dm6s7YK_jHU-jCMl2zdI-0yeYz8,16198
+wavemind/encoders.py,sha256=c9BfW3SBGxinpJVtoYBN7l1wqxi3aGoA9h2lX6LuKUA,4338
+wavemind/importers.py,sha256=cwuBIwEXQqHM35iWg23BGfHJTSCVLNt4MoFW-AEN7Hw,4023
+wavemind/indexes.py,sha256=gUX7uvfD5KQjqr0Hgz18q5gAuq8ipAlcWvbVHyo0330,7300
+wavemind/storage.py,sha256=Yx3f7xfDEJrBRS2oS1U8zrPh7zFP10gGTZ-hBhJeEkA,7867
+wavemind-2.0.0.dist-info/licenses/LICENSE,sha256=3774fYet-ActxR0N3xkWV1n-qGV8usVH8lO95fa0TSw,1078
+wavemind-2.0.0.dist-info/METADATA,sha256=MVNXOyt3-VFLZBnoS4YK9kaeI2WQuqdw7zXoAi5tD_4,5099
+wavemind-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wavemind-2.0.0.dist-info/entry_points.txt,sha256=2t66WjNTzGr9_af4T8eQO9OyMhJsA5RqzUBUCi1x1fU,47
+wavemind-2.0.0.dist-info/top_level.txt,sha256=n3jjV6Gcmic3b4D5TgTObdq2sQOCJwb7hZgdIv305QI,9
+wavemind-2.0.0.dist-info/RECORD,,

wavemind-2.0.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
+

wavemind-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wavemind = wavemind.cli:main

wavemind-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WaveMind contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

wavemind-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wavemind