atomicmemory 1.0.0__py3-none-any.whl

atomicmemory/storage/types.py

@@ -0,0 +1,305 @@
+"""Types for the backend artifact-storage API.
+
+Port of `atomicmemory-sdk/src/storage/types.ts`. Python callers use
+snake_case field names while Pydantic aliases accept the TypeScript
+SDK's camelCase spellings at the public boundary.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+StorageArtifactStatus = Literal[
+    "stored",
+    "pending",
+    "available",
+    "unavailable",
+    "deleting",
+    "deleted",
+    "delete_failed",
+    "failed",
+]
+StorageAddressingMode = Literal["location", "content", "provider_native"]
+StorageConsistency = Literal["immediate", "eventual"]
+StorageAvailabilityModel = Literal["immediate", "delayed", "scheduled", "best_effort"]
+StorageDeleteSemantics = Literal["delete", "unpin", "tombstone", "provider_retained"]
+StorageMode = Literal["pointer", "managed"]
+ContentEncoding = Literal["identity", "aes_gcm"]
+DeleteArtifactPolicy = Literal["artifact_only", "with_documents"]
+ArtifactMetadata = dict[str, str | int | float | bool]
+ManagedBody = bytes | bytearray | memoryview
+
+
+class StorageClientConfig(BaseModel):
+    """Configuration for sync and async storage clients."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    api_url: str = Field(alias="apiUrl")
+    api_key: str = Field(alias="apiKey")
+    user_id: str = Field(alias="userId")
+    timeout_seconds: float = Field(default=30.0, alias="timeoutSeconds")
+
+    @field_validator("api_url")
+    @classmethod
+    def _validate_api_url(cls, value: str) -> str:
+        stripped = value.strip()
+        parsed = urlparse(stripped)
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            raise ValueError("api_url must be an http(s) URL")
+        return stripped
+
+    @field_validator("api_key", "user_id")
+    @classmethod
+    def _validate_non_empty_secret(cls, value: str) -> str:
+        stripped = value.strip()
+        if stripped == "":
+            raise ValueError("value must not be empty")
+        return stripped
+
+    @field_validator("timeout_seconds")
+    @classmethod
+    def _validate_timeout(cls, value: float) -> float:
+        if value <= 0:
+            raise ValueError("timeout_seconds must be greater than zero")
+        return value
+
+    @model_validator(mode="after")
+    def _require_non_empty(self) -> StorageClientConfig:
+        if not self.api_url:
+            raise ValueError("api_url is required")
+        if not self.api_key:
+            raise ValueError("api_key is required")
+        if not self.user_id:
+            raise ValueError("user_id is required")
+        return self
+
+
+class ArtifactRef(BaseModel):
+    """Stable reference to a storage artifact.
+
+    At least one identifier is required. v1 follow-up operations use
+    ``artifact_id`` as the canonical handle.
+    """
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    artifact_id: str | None = Field(default=None, alias="artifactId")
+    uri: str | None = None
+    content_hash: str | None = Field(default=None, alias="contentHash")
+
+    @model_validator(mode="after")
+    def _require_one_identifier(self) -> ArtifactRef:
+        if self.artifact_id is None and self.uri is None and self.content_hash is None:
+            raise ValueError("ArtifactRef requires artifact_id, uri, or content_hash")
+        return self
+
+
+class StorageLifecycle(BaseModel):
+    """Provider-agnostic availability and delete-semantics summary."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    availability: StorageAvailabilityModel | None = None
+    delete_semantics: StorageDeleteSemantics | None = Field(default=None, alias="deleteSemantics")
+
+
+class ReplicationState(BaseModel):
+    """Optional replication state for backends such as Filecoin."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    desired_copies: int | None = Field(default=None, alias="desiredCopies")
+    confirmed_copies: int | None = Field(default=None, alias="confirmedCopies")
+
+
+class VerificationState(BaseModel):
+    """Optional provider-proof or content-verification state."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    provider_proof_status: Literal["pending", "verified", "failed", "unsupported"] | None = Field(
+        default=None,
+        alias="providerProofStatus",
+    )
+    last_verified_at: str | None = Field(default=None, alias="lastVerifiedAt")
+
+
+class RetrievalState(BaseModel):
+    """Optional retrieval-readiness state."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    status: Literal["not_checked", "retrievable", "not_retrievable", "unsupported"] | None = None
+    last_checked_at: str | None = Field(default=None, alias="lastCheckedAt")
+
+
+class StoredArtifact(BaseModel):
+    """Artifact metadata returned by ``storage.put`` and ``storage.get``."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    artifact_id: str = Field(alias="artifactId")
+    provider: str
+    mode: StorageMode
+    uri: str | None
+    status: StorageArtifactStatus
+    size_bytes: int | None = Field(alias="sizeBytes")
+    content_type: str | None = Field(alias="contentType")
+    content_hash: str | None = Field(default=None, alias="contentHash")
+    content_encoding: ContentEncoding = Field(alias="contentEncoding")
+    identifiers: dict[str, str] = Field(default_factory=dict)
+    lifecycle: StorageLifecycle = Field(default_factory=StorageLifecycle)
+    replication: ReplicationState | None = None
+    verification: VerificationState | None = None
+    retrieval: RetrievalState | None = None
+    provider_details: dict[str, Any] | None = Field(default=None, alias="providerDetails")
+    metadata: ArtifactMetadata = Field(default_factory=dict)
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+
+
+class ArtifactRange(BaseModel):
+    """Byte range for future range-read capable storage backends."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    start: int
+    end: int
+
+    @model_validator(mode="after")
+    def _validate_range(self) -> ArtifactRange:
+        if self.start < 0:
+            raise ValueError("start must be non-negative")
+        if self.end < self.start:
+            raise ValueError("end must be greater than or equal to start")
+        return self
+
+
+class PutPointerInput(BaseModel):
+    """Pointer-mode put input. The server stores metadata only."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    mode: Literal["pointer"] = "pointer"
+    uri: str
+    content_type: str = Field(alias="contentType")
+    size_bytes: int | None = Field(default=None, alias="sizeBytes")
+    content_hash: str | None = Field(default=None, alias="contentHash")
+    metadata: ArtifactMetadata | None = None
+
+    @field_validator("content_type")
+    @classmethod
+    def _validate_content_type(cls, value: str) -> str:
+        stripped = value.strip()
+        if stripped == "":
+            raise ValueError("content_type must not be empty")
+        return stripped
+
+
+class PutManagedInput(BaseModel):
+    """Managed-mode put input for known-length byte bodies."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True, arbitrary_types_allowed=True)
+
+    mode: Literal["managed"] = "managed"
+    body: ManagedBody
+    content_type: str = Field(alias="contentType")
+    disclose_content_hash: bool = Field(default=False, alias="discloseContentHash")
+    metadata: ArtifactMetadata | None = None
+
+    @field_validator("body", mode="before")
+    @classmethod
+    def _validate_body(cls, value: Any) -> Any:
+        if isinstance(value, bytes | bytearray | memoryview):
+            return value
+        raise ValueError("body must be bytes, bytearray, or memoryview")
+
+    @field_validator("content_type")
+    @classmethod
+    def _validate_content_type(cls, value: str) -> str:
+        stripped = value.strip()
+        if stripped == "":
+            raise ValueError("content_type must not be empty")
+        return stripped
+
+
+PutArtifactInput = PutPointerInput | PutManagedInput
+
+
+class ArtifactHead(BaseModel):
+    """Metadata projection returned by ``storage.head``."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    artifact_id: str = Field(alias="artifactId")
+    provider: str
+    mode: StorageMode
+    status: StorageArtifactStatus
+    size_bytes: int | None = Field(alias="sizeBytes")
+    content_type: str | None = Field(alias="contentType")
+
+
+class DeleteArtifactOptions(BaseModel):
+    """Options for ``storage.delete``."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    policy: DeleteArtifactPolicy | None = None
+
+
+class DeleteArtifactResult(BaseModel):
+    """Result returned by ``storage.delete``."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    artifact_id: str = Field(alias="artifactId")
+    status: StorageArtifactStatus
+    cascaded_document_ids: list[str] | None = Field(default=None, alias="cascadedDocumentIds")
+
+
+class VerifyArtifactOptions(BaseModel):
+    """Reserved verification options for future storage backends."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    mode: Literal["head_only", "hash_verify"] | None = None
+
+
+class VerificationResult(BaseModel):
+    """Provider verification result."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    kind: Literal["verified", "failed", "unsupported"]
+    details: dict[str, Any] | None = None
+    reason: str | None = None
+
+
+class StorageCapabilities(BaseModel):
+    """Direct storage API capability snapshot."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    provider: str
+    addressing: list[StorageAddressingMode]
+    consistency: StorageConsistency
+    max_upload_bytes: int | None = Field(default=None, alias="maxUploadBytes")
+    min_upload_bytes: int | None = Field(default=None, alias="minUploadBytes")
+    supports_direct_upload: bool = Field(alias="supportsDirectUpload")
+    supports_range_read: bool = Field(alias="supportsRangeRead")
+    supports_delete: bool = Field(alias="supportsDelete")
+    supports_tombstone: bool = Field(alias="supportsTombstone")
+    supports_bundles: bool = Field(alias="supportsBundles")
+    supported_bundle_formats: list[str] = Field(alias="supportedBundleFormats")
+    supports_verification: bool = Field(alias="supportsVerification")
+    supports_provider_proofs: bool = Field(alias="supportsProviderProofs")
+    supports_replication: bool = Field(alias="supportsReplication")
+    supports_retrieval_status: bool = Field(alias="supportsRetrievalStatus")
+    supports_content_hash: bool = Field(alias="supportsContentHash")
+    supports_content_addressed_uri: bool = Field(alias="supportsContentAddressedUri")
+    delete_semantics: list[StorageDeleteSemantics] = Field(alias="deleteSemantics")
+    availability_model: StorageAvailabilityModel = Field(alias="availabilityModel")

atomicmemory/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Misc utility helpers shared across the SDK."""
+
+from atomicmemory.utils.environment import is_test_environment
+
+__all__ = ["is_test_environment"]

atomicmemory/utils/environment.py

@@ -0,0 +1,23 @@
+"""Environment introspection helpers.
+
+Port of `atomicmemory-sdk/src/utils/environment.ts`. Used internally to
+gate noisy diagnostics and skip optional behavior in tests.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+
+def is_test_environment() -> bool:
+    """Return True when the SDK is running under pytest or `PYTEST_*`.
+
+    The check is deliberately heuristic — it asks "is pytest the entry
+    point" by inspecting `sys.modules` and `os.environ`. Callers must not
+    use this for security-sensitive branches; it exists only to silence
+    diagnostics that would otherwise spam test output.
+    """
+    if "pytest" in sys.modules:
+        return True
+    return "PYTEST_CURRENT_TEST" in os.environ

atomicmemory-1.0.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: atomicmemory
+Version: 1.0.0
+Summary: Python client SDK for AtomicMemory memory and artifact storage.
+Project-URL: Homepage, https://github.com/atomicstrata/atomicmemory-python
+Project-URL: Repository, https://github.com/atomicstrata/atomicmemory-python
+Project-URL: Issues, https://github.com/atomicstrata/atomicmemory-python/issues
+Author: AtomicMemory
+License: MIT
+License-File: LICENSE
+Keywords: agent,atomicmemory,llm,mem0,memory,rag
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2.7
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-mock>=3.12; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: vulture>=2.11; extra == 'dev'
+Provides-Extra: embeddings
+Requires-Dist: sentence-transformers>=3.0; extra == 'embeddings'
+Description-Content-Type: text/markdown
+
+# atomicmemory-python
+
+Python client SDK for [AtomicMemory](https://github.com/atomicstrata) memory and artifact storage.
+
+A backend-agnostic memory and storage client: ingest conversations and documents, search them semantically, package retrieval-ready context, register or upload raw artifacts, and access AtomicMemory-specific features (lifecycle, audit, lessons, agents/trust, runtime config) through typed namespace handles.
+
+This is a Python port of the TypeScript [`atomicmemory-sdk`](https://github.com/atomicstrata/atomicmemory-sdk). It mirrors the public surface 1:1 while staying idiomatic to Python (Pydantic models, `httpx` sync + async clients, `match` statements, `snake_case`).
+
+## Status
+
+Stable release — `1.0.0` on [PyPI](https://pypi.org/project/atomicmemory/).
+
+## Quick start
+
+```python
+from atomicmemory import AtomicMemoryClient
+
+with AtomicMemoryClient({
+    "apiUrl": "http://localhost:3050",
+    "apiKey": "server-api-key",
+    "userId": "demo",
+}) as client:
+    client.memory.initialize()
+
+    client.memory.ingest({
+        "mode": "messages",
+        "messages": [
+            {"role": "user", "content": "I prefer aisle seats on flights."},
+        ],
+        "scope": {"user": "demo"},
+    })
+
+    page = client.memory.search({"query": "seat preference", "scope": {"user": "demo"}})
+    for hit in page.results:
+        print(hit.memory.content, hit.score)
+
+    artifact = client.storage.put({
+        "mode": "pointer",
+        "uri": "https://example.com/manual.pdf",
+        "contentType": "application/pdf",
+    })
+    print(artifact.artifact_id)
+```
+
+## Async usage
+
+```python
+import asyncio
+from atomicmemory import AsyncAtomicMemoryClient
+
+async def main() -> None:
+    async with AsyncAtomicMemoryClient({
+        "apiUrl": "http://localhost:3050",
+        "apiKey": "server-api-key",
+        "userId": "demo",
+    }) as client:
+        await client.memory.initialize()
+        results = await client.memory.search({"query": "seat preference", "scope": {"user": "demo"}})
+        for hit in results.results:
+            print(hit.memory.content)
+
+asyncio.run(main())
+```
+
+## AtomicMemory-specific features
+
+When configured with the `atomicmemory` provider, the client exposes a typed handle for backend-specific routes:
+
+```python
+trail = client.memory.atomicmemory.audit.trail(memory_id="mem-123", user_id="demo")
+health = client.memory.atomicmemory.config.health()
+```
+
+Categories: `lifecycle`, `audit`, `lessons`, `config`, `agents`.
+
+## Artifact storage
+
+The `client.storage` namespace mirrors the TypeScript SDK's direct storage API:
+
+- `capabilities()` reports active backend support.
+- `put({"mode": "pointer", ...})` registers a pointer to caller-owned bytes.
+- `put({"mode": "managed", "body": b"...", ...})` uploads known-length bytes to the configured raw content store.
+- `get`, `get_content`, `head`, `delete`, and `verify` address artifacts by `artifact_id`.
+- `stream_content` streams large artifact bodies without buffering the entire response in memory.
+
+Every storage request sends `Authorization: Bearer <apiKey>` and `X-AtomicMemory-User-Id`. The SDK never sends the legacy `?user_id=` URL parameter.
+
+## Installation
+
+```bash
+pip install atomicmemory                    # core + local search + SQLite store
+pip install 'atomicmemory[embeddings]'      # + sentence-transformers for local embeddings
+```
+
+## Development
+
+```bash
+uv sync --extra dev --extra embeddings
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy atomicmemory --strict
+uv run vulture atomicmemory tests .vulture_whitelist.py --min-confidence 90
+```
+
+## License
+
+MIT

atomicmemory-1.0.0.dist-info/RECORD

@@ -0,0 +1,67 @@
+atomicmemory/__init__.py,sha256=dGbYABwc3qpefct9OMCMmYW4kC-dcwrOM229db5heuo,3927
+atomicmemory/_version.py,sha256=qtodX2wTJerDeZidLhVlfcZBglrhPmyrTn5pVe7DZyA,79
+atomicmemory/client/__init__.py,sha256=ZOGuWYtVcnFOtISX5jj9Ii2f4UCPxdNQHqFFbn3Gpho,676
+atomicmemory/client/async_memory_client.py,sha256=DHuMi1gk0u88uy1Vrooy37SzS_tDbizLQTyCRXX73ls,7443
+atomicmemory/client/atomic_memory_client.py,sha256=7LtqEBgVmtmnzhyrMMohweggfMI3nOz6tTSrVcAbbZs,6199
+atomicmemory/client/memory_client.py,sha256=HMzPV_nk_-lAanyg9_0txfbZlemH_fbfbnqYJ7mqI1A,11096
+atomicmemory/core/__init__.py,sha256=YqnArzYJ4xC2xKj7_fob8wlkgf3sj90ugPpBa-2lbr8,897
+atomicmemory/core/errors.py,sha256=rhzK2KV6p7e5lS1oeXbBtevVLn52iPWrZhQ_OKHdgY0,3847
+atomicmemory/core/events.py,sha256=OMoH5SwAkC_BszpvRi9kPQqotQsJA-mVOMLv_Jm2MTM,2124
+atomicmemory/core/logging.py,sha256=bh-I7LMvt2AuGaozYuiPxpzwpLxmdmizhmxd1wdUjGU,1151
+atomicmemory/core/retry.py,sha256=tjes8NP2TwSGqQhvCWbmNnLRDeLGB269fJKfE9Loioc,4234
+atomicmemory/core/validation.py,sha256=pTHBFd6Ksqc0DM6DIIKkJJwoNR5WNKdd4gmU8sZmRks,796
+atomicmemory/embeddings/__init__.py,sha256=bJVq54A_s_TWV-Iim9vXgFtYJsCF3ijZFMcat7G_Dxw,602
+atomicmemory/embeddings/base.py,sha256=gAo8I3euGkQ0_YhIy0a7EwP2PgVq-Ks-2SKU4R6YOiQ,971
+atomicmemory/embeddings/sentence_transformers.py,sha256=_0K8klsV1V4EgAe0e4_PbWME1H7o_f-zrh-f7_0D3xY,3462
+atomicmemory/kv_cache/__init__.py,sha256=pTm1kP-smBuTfSYRcjBQ9zyOYgDIrrNU7NfYG2WO89M,781
+atomicmemory/kv_cache/adapter.py,sha256=BQ3ekePv3W_L7MQJN07IqfSaC-X3aT6BjDzcYTnx8UA,1468
+atomicmemory/kv_cache/memory_storage.py,sha256=HYPV5J9_ShvH6QJcaNp1jBQvwLITJVuTqzqEMDuvqtE,2963
+atomicmemory/kv_cache/sqlite_storage.py,sha256=noMe7OGqMsb0cRimv33UjtQPuNmpHIbF-lEyYluaAjA,4187
+atomicmemory/memory/__init__.py,sha256=5j1vIE-DsO74ZzfKM6TW9aAPAzXCY_APBdbZHTEYsSY,1635
+atomicmemory/memory/filters.py,sha256=7dVi_NQf2uqaftNaSRqFYhxS6FRa-qak1KVs5fLEULU,1568
+atomicmemory/memory/pipeline.py,sha256=LbyufJMmSWVHRJVem_3SpdhWCiL5CGgCP3MkV3BYv1E,1467
+atomicmemory/memory/provider.py,sha256=fZPqRW3rCqIG_oKJs49t0TYjOxawTb_-K_oFqaqIYt8,12619
+atomicmemory/memory/registry.py,sha256=CNbXUPnqRQs7px7JJEvdWcCWazpRLXZiBEgS2tpfd6o,2975
+atomicmemory/memory/service.py,sha256=AxhaMl4vGexJjq_tigoQ44Lheh2KnS6jXnGmNJV-m6U,7879
+atomicmemory/memory/types.py,sha256=6TUYwC0JLGxjMymLyuZWdTa9TLScI4yQDkr36QbFySk,11138
+atomicmemory/providers/__init__.py,sha256=DR8rK2eyn_VIgW3sMHWJnhLtb8W2pbnEajAMRM6jiIk,155
+atomicmemory/providers/atomicmemory/__init__.py,sha256=GL2fdEW8fO4A458IS6cy9NQM3_yTUha-pG9voXNVGHE,1490
+atomicmemory/providers/atomicmemory/agents.py,sha256=rbB0D_8sLDh9oTWth2eGoIdqUjaYRAqEl1V1KClFEYQ,5422
+atomicmemory/providers/atomicmemory/async_handle_impl.py,sha256=2YfIuEiZGmfV2UyhT9HPcDAqi0FZ7f3LI8zaMS_DdUU,8125
+atomicmemory/providers/atomicmemory/async_provider.py,sha256=J3hWUJDftpY7ctzXwueJpFyvxX_lq9B0VL1V7_I3c6c,9671
+atomicmemory/providers/atomicmemory/audit.py,sha256=r8oonF9pZjMDocH0ICBPOb39OE91Hn0cyKKFv6REyfk,2929
+atomicmemory/providers/atomicmemory/config.py,sha256=rt3-xe9hGZLZZw3zMA7CW80vyzFZzPUx6inybDDsRM0,1336
+atomicmemory/providers/atomicmemory/config_handle.py,sha256=DfA81nEecRgRcbGJo7ONLi0zj2nHqbQWh_dI9eWkI4I,4751
+atomicmemory/providers/atomicmemory/handle.py,sha256=cIjMICQCrGCTZFnj2F6iAOipF41bdQbyLI2eO9wnaBk,15361
+atomicmemory/providers/atomicmemory/handle_impl.py,sha256=JoQYgJ1R1jWX_UGrP7Z5LfM5UNWi91RtIVfaDygkCzg,13366
+atomicmemory/providers/atomicmemory/http.py,sha256=XU0NreFhGpseaES5HnFKRZKlfXTktI5a5DxR-QNjT5M,7052
+atomicmemory/providers/atomicmemory/lessons.py,sha256=QnZgti96YdJ05w-1KbT8CPrLnJBI3c0qQ80pD8xO-IA,4512
+atomicmemory/providers/atomicmemory/lifecycle.py,sha256=pX6gZTgeaCDzoSMh6O6K6Lw9tWH-eV4is9U4z_PVaWE,7000
+atomicmemory/providers/atomicmemory/mappers.py,sha256=dsHC9Y0fP2vn83KmN4Aid7wg5Fl2X57EgkTRqSVIW20,4157
+atomicmemory/providers/atomicmemory/path.py,sha256=-99ZiITsu9vYVoOkefMCGDrryNG8N90TwDLi6kz8YRI,538
+atomicmemory/providers/atomicmemory/provider.py,sha256=g87TqZ6hzpTeNOEyW_CtWM3SUfHXsLORXOkem_9-G3k,11467
+atomicmemory/providers/atomicmemory/scope_mapper.py,sha256=ndm6fEptppW6tItDjrzfgOEd1aCAfOUmBwB_5M1VR7E,3610
+atomicmemory/providers/mem0/__init__.py,sha256=U56wstuAuchnPYw-nyLewb3JaHhUVPcqhqVyVhV0EQM,1266
+atomicmemory/providers/mem0/async_provider.py,sha256=moKefYiLRCKDEOfg4U-tF3N3L-CGdPJkQk5BCCJQktU,6910
+atomicmemory/providers/mem0/config.py,sha256=8fOpK19xgqJv4HCeg4HYHNovVKoclG9fvVe2H5XqZgg,1726
+atomicmemory/providers/mem0/http.py,sha256=kDtLLQu6_y1CMMoyv23HxPBbRQ5nyxHriZ1e5_SRGZU,5541
+atomicmemory/providers/mem0/mappers.py,sha256=CRFryLWkRhU_6sGnyrBi25McNjAgitPABks4RFtJCyI,4850
+atomicmemory/providers/mem0/provider.py,sha256=IMnvDI6zegqmC7mhc2laq-NjgQPAjbvOpvSGaRrJmro,7268
+atomicmemory/search/__init__.py,sha256=RD_G1WMR5ae9P2KqGLMrK2IJLatqvFYXxio7hmSESqM,1221
+atomicmemory/search/chunking.py,sha256=rmevW2tuGZjSqHPg0XEkY8Xu4__zQcPH_sMnMhBRwEA,5514
+atomicmemory/search/ranking.py,sha256=AzhyTmO6o0X5W9ORMk-V9Ec-wj4PuO1z-jGZM63GzNk,2922
+atomicmemory/search/semantic_search.py,sha256=tJizviYA7Ewo3WSg0H1RO-jaSSXm6gR4AoDlyafptfw,4741
+atomicmemory/search/similarity.py,sha256=8sTcnt1NecWEYRNPcfNfy6E0PRLanqUH-GhHutUe5OI,3602
+atomicmemory/storage/__init__.py,sha256=fGZBT15cjm6TCyJby19vAmpHpyGOmv-fNkhnhZvbLq4,1684
+atomicmemory/storage/_mapping.py,sha256=xS9CVFHmW3YLG2nXvSI8Sn39DwdfCa3kvt4teBlY4Xo,11841
+atomicmemory/storage/async_client.py,sha256=6x0RW8uhepvUVU_pj3Izsaf3dtA0DbnQWMWurNFJoqI,7452
+atomicmemory/storage/client.py,sha256=s78u-pGVG6DtWVPr8gwqryPLvMHeOT1xwT9KQwtuXek,12473
+atomicmemory/storage/errors.py,sha256=3R8vbGfW_8RaFlYIZ5oAxrdVKqih34JVtshi-LYQdNU,3790
+atomicmemory/storage/types.py,sha256=uzUP5NEKHYbVSJ-ljcsdZ5WKp2WOOO4avwKcTPepIK0,11030
+atomicmemory/utils/__init__.py,sha256=RqKXEYX5ZNHdTOt_NOY7B1DU1VsiUDak1CL3YnDOCAU,149
+atomicmemory/utils/environment.py,sha256=vTyN_opmNtfur9rsjGdXGSpouNT3MckUgTm7Voe7Qmw,723
+atomicmemory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+atomicmemory-1.0.0.dist-info/METADATA,sha256=NteFycOA0bUbVOut2QbxYXht0EOT3N5Kg9RCSjoCOMg,5226
+atomicmemory-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+atomicmemory-1.0.0.dist-info/licenses/LICENSE,sha256=vMGL9gR35PGpiGIytzTt1H2uHZLO3N_bPAMu_Uk5pR0,1069
+atomicmemory-1.0.0.dist-info/RECORD,,

atomicmemory-1.0.0.dist-info/WHEEL

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

atomicmemory-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AtomicMemory
+
+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.