pinecone 7.3.1.dev1__tar.gz → 7.3.1.dev2__tar.gz

{pinecone-7.3.1.dev1 → pinecone-7.3.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pinecone
-Version: 7.3.1.dev1
+Version: 7.3.1.dev2
 Summary: Pinecone client and SDK
 License: Apache-2.0
 License-File: LICENSE.txt

pinecone-7.3.1.dev2/pinecone/__version__

@@ -0,0 +1 @@
+7.3.1.dev2

{pinecone-7.3.1.dev1 → pinecone-7.3.1.dev2}/pinecone/repository_data/__init__.py

@@ -1,10 +1,11 @@
 from .repository import Repository
+from .models.document import Document
 
 
 _Repository = Repository  # alias for backwards compatibility
 
 
-__all__ = ["_Repository"]
+__all__ = ["_Repository", "Document"]
 
 
 def __getattr__(name):

pinecone-7.3.1.dev2/pinecone/repository_data/models/__init__.py

@@ -0,0 +1,4 @@
+from .document import Document
+
+
+__all__ = ["Document"]

pinecone-7.3.1.dev2/pinecone/repository_data/models/document.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict, Optional
+from dataclasses import dataclass, field
+
+
+# -----------------------
+# Model
+# -----------------------
+@dataclass(frozen=True)
+class Document:
+    """
+    Lightweight model for a Repository document.
+
+    _id is optional: it will be present for fetched/listed documents,
+    but not required when creating/upserting.
+    """
+
+    _id: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @staticmethod
+    def _extract_id(payload: Dict[str, Any]) -> Optional[str]:
+        return payload.get("_id")
+
+    @classmethod
+    def from_api(cls, payload: Dict[str, Any]) -> "Document":
+        if not isinstance(payload, dict):
+            raise TypeError("Document.from_api payload must be a dict")
+
+        doc_id = cls._extract_id(payload)
+        if not doc_id:
+            raise ValueError("Document.from_api payload missing an '_id' field")
+
+        return cls(_id=str(doc_id), raw=payload)
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "Document":
+        """
+        Create a Document directly from a dict (e.g., user-supplied).
+        The dict must contain an '_id' field.
+        """
+        if not isinstance(payload, dict):
+            raise TypeError("payload must be a dict.")
+
+        doc_id = cls._extract_id(payload)  # may be None
+        return cls(_id=str(doc_id), raw=dict(payload))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the Document into a dict suitable for upsert.
+        """
+        return dict(self.raw)
+
+    def __str__(self) -> str:
+        truncate = 50
+        as_str = self.raw.__str__()
+        return as_str[:truncate] + (" ... " if len(as_str) > truncate else "")
+
+    def __repr__(self) -> str:
+        # Make a shallow copy of raw without the _id key (if present)
+        raw_copy = {k: v for k, v in self.raw.items() if k != "_id"}
+
+        truncate = 50
+        as_str = repr(raw_copy)
+        return (
+            f"Document(_id={self._id!r}, raw={as_str[:truncate]}"
+            f"{' ... ' if len(as_str) > truncate else ''})"
+        )
+
+    def __getitem__(self, key: str) -> Any:
+        return self.raw[key]
+
+    # attribute-style passthrough into raw
+    # e.g., doc.title instead of doc.raw["title"]
+    def __getattr__(self, attr: str) -> Any:
+        # __getattr__ is only called if normal attribute lookup fails
+        raw = object.__getattribute__(self, "raw")
+        if attr in raw:
+            return raw[attr]
+        raise AttributeError(f"{self.__class__.__name__!s} has no attribute {attr!r}")

{pinecone-7.3.1.dev1 → pinecone-7.3.1.dev2}/pinecone/repository_data/repository.py

@@ -1,6 +1,6 @@
 import logging
 import json
-from typing import Optional, Dict, Any, Tuple
+from typing import Optional, Dict, List, Any, Tuple, Union
 from urllib.parse import urljoin
 
 import requests
@@ -8,6 +8,7 @@ from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 from multiprocessing import cpu_count
 from pinecone.core.openapi.repository_data import API_VERSION
+from .models.document import Document
 
 logger = logging.getLogger(__name__)
 
@@ -108,7 +109,7 @@ class Repository:
         headers: Optional[dict] = None,
         params: Optional[dict] = None,
         echo: Optional[bool] = None,
-    ) -> dict:
+    ) -> Dict:
         url = urljoin(self._base_url + "/", path.lstrip("/"))
         hdrs = dict(self._default_headers)
         if headers:
@@ -167,26 +168,41 @@ class Repository:
     # -------------
     # API methods
     # -------------
-    def upsert(self, namespace: str, document: Dict[str, Any], **kwargs) -> dict:
+    def upsert(self, namespace: str, document: Union[Dict[str, Any], Document], **kwargs) -> Dict:
         """
         POST /namespaces/{namespace}/documents/upsert
         Returns UpsertDocumentResponse as dict.
         """
-        if not isinstance(document, dict):
-            raise TypeError("document must be a dict (JSON-serializable).")
+        if isinstance(document, Document):
+            json_body = document.to_dict()
+        elif isinstance(document, dict):
+            json_body = document
+        else:
+            raise TypeError("document must be a dict or Document.")
 
         path = f"/namespaces/{namespace}/documents/upsert"
-        return self._request("POST", path, json_body=document, **kwargs)
+        return self._request("POST", path, json_body=json_body, **kwargs)
 
-    def fetch(self, namespace: str, document_id: str, **kwargs) -> dict:
+    def fetch(self, namespace: str, document_id: str, **kwargs) -> Document:
         """
         GET /namespaces/{namespace}/documents/{document_id}
         Returns GetDocumentResponse as dict.
         """
         path = f"/namespaces/{namespace}/documents/{document_id}"
-        return self._request("GET", path, **kwargs)
+        payload = self._request("GET", path, **kwargs)
 
-    def list(self, namespace: str, **kwargs) -> dict:
+        if not isinstance(payload, dict):
+            raise ValueError("Unexpected fetch-documents response format, expected dict response")
+
+        doc = payload.get("document")
+        if not doc or not isinstance(doc, dict):
+            raise ValueError(
+                "Unexpected fetch-documents response format, expected 'document' key of type dict"
+            )
+
+        return Document.from_api(doc)
+
+    def list(self, namespace: str, **kwargs) -> List[Document]:
         """
         GET /namespaces/{namespace}/documents
         Returns ListDocumentsResponse as dict.
@@ -194,9 +210,23 @@ class Repository:
         path = f"/namespaces/{namespace}/documents"
         # Spec does not define query params, but keep hook if server adds (e.g., pagination).
         params = kwargs.get("params")
-        return self._request("GET", path, params=params, **kwargs)
+        payload = self._request("GET", path, params=params, **kwargs)
+
+        candidates: List[Dict[str, Any]] = []
+        if not isinstance(payload, dict):
+            raise ValueError("Unexpected list-documents response format, expected dict response")
+
+        docs = payload.get("documents")
+        if not docs or not isinstance(docs, list):
+            raise ValueError(
+                "Unexpected list-documents response format, expected 'documents' key of type list"
+            )
+
+        candidates = docs
+
+        return [Document.from_api(doc) for doc in candidates]
 
-    def delete(self, namespace: str, document_id: str, **kwargs) -> dict:
+    def delete(self, namespace: str, document_id: str, **kwargs):
         """
         DELETE /namespaces/{namespace}/documents/{document_id}
         Returns DeleteDocumentResponse as dict.

{pinecone-7.3.1.dev1 → pinecone-7.3.1.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pinecone"
-version = "7.3.1.dev1"
+version = "7.3.1.dev2"
 packages = [
     { include="pinecone", from="." },
 ]

pinecone-7.3.1.dev1/pinecone/__version__

@@ -1 +0,0 @@
-7.3.1.dev1