memorysync 1.7.3__tar.gz → 1.8.0__tar.gz

{memorysync-1.7.3 → memorysync-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync
-Version: 1.7.3
+Version: 1.8.0
 Summary: Official Python client for the MemorySync API.
 Project-URL: Homepage, https://memorysync.io
 Project-URL: Documentation, https://docs.memorysync.io

memorysync-1.8.0/src/memorysync/_version.py

@@ -0,0 +1 @@
+__version__ = "1.8.0"

{memorysync-1.7.3 → memorysync-1.8.0}/src/memorysync/client.py

@@ -193,6 +193,7 @@ class _RequestBuilder:
         session_id: Optional[str],
         metadata: Optional[Dict[str, Any]],
         end_user_id: Optional[str],
+        client_ref: Optional[str] = None,
     ) -> Dict[str, Any]:
         return _strip_none(
             {
@@ -203,6 +204,7 @@ class _RequestBuilder:
                 "session_id": session_id,
                 "metadata": metadata,
                 "end_user_id": end_user_id,
+                "client_ref": client_ref,
             }
         )
 
@@ -364,7 +366,18 @@ class MemorySyncClient:
         session_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         end_user_id: Optional[str] = None,
+        client_ref: Optional[str] = None,
     ) -> AddResult:
+        """Store one memory candidate.
+
+        Pass ``client_ref`` -- your own identifier for the record, at most 128
+        characters -- and re-sending it is recognised rather than stored a second
+        time: the call returns an :class:`AddSkippedResponse` with reason
+        ``already_ingested`` and the ids the first write produced. That makes an
+        interrupted write safe to retry without first checking whether it landed.
+        Near-duplicate detection is always on, but it compares *meaning*, so it is
+        a filter and not a guarantee.
+        """
         body = _RequestBuilder.add(
             text,
             source=source,
@@ -373,6 +386,7 @@ class MemorySyncClient:
             session_id=session_id,
             metadata=metadata,
             end_user_id=end_user_id,
+            client_ref=client_ref,
         )
         raw = self._request("POST", "/memory/add", json=body, end_user_override=end_user_id)
         skipped = _as_skipped(raw, default_reason="no_high_value_content")
@@ -1057,7 +1071,18 @@ class AsyncMemorySyncClient:
         session_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         end_user_id: Optional[str] = None,
+        client_ref: Optional[str] = None,
     ) -> AddResult:
+        """Store one memory candidate.
+
+        Pass ``client_ref`` -- your own identifier for the record, at most 128
+        characters -- and re-sending it is recognised rather than stored a second
+        time: the call returns an :class:`AddSkippedResponse` with reason
+        ``already_ingested`` and the ids the first write produced. That makes an
+        interrupted write safe to retry without first checking whether it landed.
+        Near-duplicate detection is always on, but it compares *meaning*, so it is
+        a filter and not a guarantee.
+        """
         body = _RequestBuilder.add(
             text,
             source=source,
@@ -1066,6 +1091,7 @@ class AsyncMemorySyncClient:
             session_id=session_id,
             metadata=metadata,
             end_user_id=end_user_id,
+            client_ref=client_ref,
         )
         raw = await self._request("POST", "/memory/add", json=body, end_user_override=end_user_id)
         skipped = _as_skipped(raw, default_reason="no_high_value_content")

{memorysync-1.7.3 → memorysync-1.8.0}/src/memorysync/types.py

@@ -79,6 +79,14 @@ class BulkAddItem:
     metadata: Optional[Dict[str, Any]] = None
     importance: Optional[float] = None
     end_user_id: Optional[str] = None
+    #: Your own identifier for this record, at most 128 characters.
+    #:
+    #: Send it and re-submitting the record is recognised rather than stored a
+    #: second time: the item comes back ``skipped`` with reason
+    #: ``already_ingested`` and the ids the first submission produced. This is
+    #: what makes a large import safe to re-run. Near-duplicate detection is
+    #: always on but compares *meaning*, so it is a filter and not a guarantee.
+    client_ref: Optional[str] = None
 
     def to_dict(self) -> Dict[str, Any]:
         out: Dict[str, Any] = {"text": self.text}
@@ -94,6 +102,8 @@ class BulkAddItem:
             out["importance"] = self.importance
         if self.end_user_id is not None:
             out["end_user_id"] = self.end_user_id
+        if self.client_ref is not None:
+            out["client_ref"] = self.client_ref
         return out
 
 

memorysync-1.7.3/src/memorysync/_version.py

@@ -1 +0,0 @@
-__version__ = "1.7.3"