chore: rename store to document_store for clarity (#5547)

* store -> document_store

* fix leftovers

* fix import name

* moar leftovers

* rebase on main, update MemoryDocumentStore to the new protocol

* Update haystack/preview/pipeline.py

Co-authored-by: Silvano Cerza <[email protected]>

---------

Co-authored-by: Silvano Cerza <[email protected]>

Author: masci

haystack/preview/__init__.py

@@ -1,4 +1,4 @@
 from canals.component import component
-from haystack.preview.document_stores.decorator import store
+from haystack.preview.document_stores.decorator import document_store
 from haystack.preview.dataclasses import Document
-from haystack.preview.pipeline import Pipeline, PipelineError, NoSuchStoreError, load_pipelines, save_pipelines
+from haystack.preview.pipeline import Pipeline, PipelineError, NoSuchDocumentStoreError, load_pipelines, save_pipelines

haystack/preview/components/retrievers/memory.py

@@ -1,18 +1,18 @@
 from typing import Dict, List, Any, Optional
 
 from haystack.preview import component, Document
-from haystack.preview.document_stores import MemoryDocumentStore, StoreAwareMixin
+from haystack.preview.document_stores import MemoryDocumentStore, DocumentStoreAwareMixin
 
 
 @component
-class MemoryRetriever(StoreAwareMixin):
+class MemoryRetriever(DocumentStoreAwareMixin):
     """
     A component for retrieving documents from a MemoryDocumentStore using the BM25 algorithm.
 
     Needs to be connected to a MemoryDocumentStore to run.
     """
 
-    supported_stores = [MemoryDocumentStore]
+    supported_document_stores = [MemoryDocumentStore]
 
     def __init__(self, filters: Optional[Dict[str, Any]] = None, top_k: int = 10, scale_score: bool = True):
         """
@@ -46,14 +46,16 @@ def run(
         :param filters: A dictionary with filters to narrow down the search space.
         :param top_k: The maximum number of documents to return.
         :param scale_score: Whether to scale the BM25 scores or not.
-        :param stores: A dictionary mapping document store names to instances.
+        :param document_stores: A dictionary mapping DocumentStore names to instances.
         :return: The retrieved documents.
 
-        :raises ValueError: If the specified document store is not found or is not a MemoryDocumentStore instance.
+        :raises ValueError: If the specified DocumentStore is not found or is not a MemoryDocumentStore instance.
         """
-        self.store: MemoryDocumentStore
-        if not self.store:
-            raise ValueError("MemoryRetriever needs a store to run: set the store instance to the self.store attribute")
+        self.document_store: MemoryDocumentStore
+        if not self.document_store:
+            raise ValueError(
+                "MemoryRetriever needs a DocumentStore to run: set the DocumentStore instance to the self.document_store attribute"
+            )
 
         if filters is None:
             filters = self.filters
@@ -64,5 +66,7 @@ def run(
 
         docs = []
         for query in queries:
-            docs.append(self.store.bm25_retrieval(query=query, filters=filters, top_k=top_k, scale_score=scale_score))
+            docs.append(
+                self.document_store.bm25_retrieval(query=query, filters=filters, top_k=top_k, scale_score=scale_score)
+            )
         return {"documents": docs}

haystack/preview/document_stores/__init__.py

@@ -1,5 +1,5 @@
-from haystack.preview.document_stores.protocols import Store, DuplicatePolicy
-from haystack.preview.document_stores.mixins import StoreAwareMixin
+from haystack.preview.document_stores.protocols import DocumentStore, DuplicatePolicy
+from haystack.preview.document_stores.mixins import DocumentStoreAwareMixin
 from haystack.preview.document_stores.memory.document_store import MemoryDocumentStore
-from haystack.preview.document_stores.errors import StoreError, DuplicateDocumentError, MissingDocumentError
-from haystack.preview.document_stores.decorator import store
+from haystack.preview.document_stores.errors import DocumentStoreError, DuplicateDocumentError, MissingDocumentError
+from haystack.preview.document_stores.decorator import document_store

haystack/preview/document_stores/decorator.py

@@ -1,37 +1,34 @@
 from typing import Dict, Any, Type
 import logging
 
-from haystack.preview.document_stores.protocols import Store
-from haystack.preview.document_stores.errors import StoreDeserializationError
+from haystack.preview.document_stores.protocols import DocumentStore
+from haystack.preview.document_stores.errors import DocumentStoreDeserializationError
 
 logger = logging.getLogger(__name__)
 
 
-class _Store:
+class _DocumentStore:
     """
-    Marks a class as an Haystack Store.
-    All classes decorated with @store will be registered here and can be used in Haystack Pipelines.
+    Marks a class as an Haystack _DocumentStore.
+    All classes decorated with @document_store will be registered here and can be used in Haystack Pipelines.
     """
 
     def __init__(self):
         self.registry = {}
 
     def _decorate(self, cls):
-        cls.__haystack_store__ = True
+        cls.__haystack_document_store__ = True
 
         if cls.__name__ in self.registry:
             logger.error(
-                "Store %s is already registered. Previous imported from '%s', new imported from '%s'",
+                "DocumentStore %s is already registered. Previous imported from '%s', new imported from '%s'",
                 cls.__name__,
                 self.registry[cls.__name__],
                 cls,
             )
 
         self.registry[cls.__name__] = cls
-        logger.debug("Registered Store %s", cls)
-
-        cls.to_dict = _default_store_to_dict
-        cls.from_dict = classmethod(_default_store_from_dict)
+        logger.debug("Registered DocumentStore %s", cls)
 
         return cls
 
@@ -42,13 +39,13 @@ def __call__(self, cls=None):
         return self._decorate
 
 
-store = _Store()
+document_store = _DocumentStore()
 
 
-def _default_store_to_dict(store_: Store) -> Dict[str, Any]:
+def default_document_store_to_dict(store_: DocumentStore) -> Dict[str, Any]:
     """
-    Default store serializer.
-    Serializes a store to a dictionary.
+    Default DocumentStore serializer.
+    Serializes a DocumentStore to a dictionary.
     """
     return {
         "hash": id(store_),
@@ -57,14 +54,16 @@ def _default_store_to_dict(store_: Store) -> Dict[str, Any]:
     }
 
 
-def _default_store_from_dict(cls: Type[Store], data: Dict[str, Any]) -> Store:
+def default_document_store_from_dict(cls: Type[DocumentStore], data: Dict[str, Any]) -> DocumentStore:
     """
-    Default store deserializer.
+    Default DocumentStore deserializer.
     The "type" field in `data` must match the class that is being deserialized into.
     """
     init_params = data.get("init_parameters", {})
     if "type" not in data:
-        raise StoreDeserializationError("Missing 'type' in store serialization data")
+        raise DocumentStoreDeserializationError("Missing 'type' in DocumentStore serialization data")
     if data["type"] != cls.__name__:
-        raise StoreDeserializationError(f"Store '{data['type']}' can't be deserialized as '{cls.__name__}'")
+        raise DocumentStoreDeserializationError(
+            f"DocumentStore '{data['type']}' can't be deserialized as '{cls.__name__}'"
+        )
     return cls(**init_params)

haystack/preview/document_stores/errors.py

@@ -1,18 +1,18 @@
-class StoreError(Exception):
+class DocumentStoreError(Exception):
     pass
 
 
-class FilterError(StoreError):
+class FilterError(DocumentStoreError):
     pass
 
 
-class DuplicateDocumentError(StoreError):
+class DuplicateDocumentError(DocumentStoreError):
     pass
 
 
-class MissingDocumentError(StoreError):
+class MissingDocumentError(DocumentStoreError):
     pass
 
 
-class StoreDeserializationError(StoreError):
+class DocumentStoreDeserializationError(DocumentStoreError):
     pass

haystack/preview/document_stores/memory/document_store.py

@@ -7,9 +7,13 @@
 import rank_bm25
 from tqdm.auto import tqdm
 
-from haystack.preview.document_stores.decorator import store
+from haystack.preview.document_stores.decorator import (
+    document_store,
+    default_document_store_to_dict,
+    default_document_store_from_dict,
+)
 from haystack.preview.dataclasses import Document
-from haystack.preview.document_stores.protocols import DuplicatePolicy
+from haystack.preview.document_stores.protocols import DuplicatePolicy, DocumentStore
 from haystack.preview.document_stores.memory._filters import match
 from haystack.preview.document_stores.errors import DuplicateDocumentError, MissingDocumentError
 from haystack.utils.scipy_utils import expit
@@ -24,7 +28,7 @@
 SCALING_FACTOR = 8
 
 
-@store
+@document_store
 class MemoryDocumentStore:
     """
     Stores data in-memory. It's ephemeral and cannot be saved to disk.
@@ -37,7 +41,7 @@ def __init__(
         bm25_parameters: Optional[Dict] = None,
     ):
         """
-        Initializes the store.
+        Initializes the DocumentStore.
         """
         self.storage: Dict[str, Document] = {}
         self.tokenizer = re.compile(bm25_tokenization_regex).findall
@@ -54,9 +58,22 @@ def __init__(
             "bm25_parameters": self.bm25_parameters,
         }
 
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes this store to a dictionary.
+        """
+        return default_document_store_to_dict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DocumentStore":
+        """
+        Deserializes the store from a dictionary.
+        """
+        return default_document_store_from_dict(cls, data)
+
     def count_documents(self) -> int:
         """
-        Returns the number of how many documents are present in the document store.
+        Returns the number of how many documents are present in the DocumentStore.
         """
         return len(self.storage.keys())
 
@@ -137,11 +154,11 @@ def filter_documents(self, filters: Optional[Dict[str, Any]] = None) -> List[Doc
 
     def write_documents(self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.FAIL) -> None:
         """
-        Writes (or overwrites) documents into the store.
+        Writes (or overwrites) documents into the DocumentStore.
 
         :param documents: a list of documents.
         :param policy: documents with the same ID count as duplicates. When duplicates are met,
-            the store can:
+            the DocumentStore can:
              - skip: keep the existing document and ignore the new one.
              - overwrite: remove the old document and write the new one.
              - fail: an error is raised
@@ -165,8 +182,8 @@ def write_documents(self, documents: List[Document], policy: DuplicatePolicy = D
 
     def delete_documents(self, document_ids: List[str]) -> None:
         """
-        Deletes all documents with a matching document_ids from the document store.
-        Fails with `MissingDocumentError` if no document with this id is present in the store.
+        Deletes all documents with a matching document_ids from the DocumentStore.
+        Fails with `MissingDocumentError` if no document with this id is present in the DocumentStore.
 
         :param object_ids: the object_ids to delete
         """
@@ -218,7 +235,7 @@ def bm25_retrieval(
                 csv_content = str_content.to_csv(index=False)
                 lower_case_documents.append(csv_content.lower())
 
-        # Tokenize the entire content of the document store
+        # Tokenize the entire content of the DocumentStore
         tokenized_corpus = [
             self.tokenizer(doc) for doc in tqdm(lower_case_documents, unit=" docs", desc="Ranking by BM25...")
         ]

haystack/preview/document_stores/mixins.py

@@ -1,40 +1,40 @@
 from typing import List, Optional, Type
 
 
-from haystack.preview.document_stores.protocols import Store
+from haystack.preview.document_stores.protocols import DocumentStore
 
 
-class StoreAwareMixin:
+class DocumentStoreAwareMixin:
     """
-    Adds the capability of a component to use a single document store from the `self.store` property.
+    Adds the capability of a component to use a single DocumentStore from the `self.document_store` property.
 
-    To use this mixin you must specify which document stores to support by setting a value to `supported_stores`.
-    To support any document store, set it to `[Store]`.
+    To use this mixin you must specify which DocumentStores to support by setting a value to `supported_stores`.
+    To support any DocumentStore, set it to `[DocumentStore]`.
     """
 
-    _store: Optional[Store] = None
+    _document_store: Optional[DocumentStore] = None
     # This is necessary to ease serialisation when converting a Component that uses
-    # a Store into a dictionary.
+    # a DocumentStore into a dictionary.
     # This is only set when calling `Pipeline.add_component()`.
-    _store_name: str = ""
-    supported_stores: List[Type[Store]]  # type: ignore # (see https://github.com/python/mypy/issues/4717)
+    _document_store_name: str = ""
+    supported_document_stores: List[Type[DocumentStore]]  # type: ignore # (see https://github.com/python/mypy/issues/4717)
 
     @property
-    def store(self) -> Optional[Store]:
-        return self._store
-
-    @store.setter
-    def store(self, store: Store):
-        if not getattr(store, "__haystack_store__", False):
-            raise ValueError(f"'{type(store).__name__}' is not decorate with @store.")
-        if not self._is_supported(store):
+    def document_store(self) -> Optional[DocumentStore]:
+        return self._document_store
+
+    @document_store.setter
+    def document_store(self, document_store: DocumentStore):
+        if not getattr(document_store, "__haystack_document_store__", False):
+            raise ValueError(f"'{type(document_store).__name__}' is not decorate with @document_store.")
+        if not self._is_supported(document_store):
             raise ValueError(
-                f"Store type '{type(store).__name__}' is not compatible with this component. "
-                f"Compatible store types: {[type_.__name__ for type_ in type(self).supported_stores]}"
+                f"DocumentStore type '{type(document_store).__name__}' is not compatible with this component. "
+                f"Compatible DocumentStore types: {[type_.__name__ for type_ in type(self).supported_document_stores]}"
             )
-        self._store = store
+        self._document_store = document_store
 
-    def _is_supported(self, store: Store):
-        if Store in self.supported_stores:
+    def _is_supported(self, document_store: DocumentStore):
+        if DocumentStore in self.supported_document_stores:
             return True
-        return any(isinstance(store, type_) for type_ in self.supported_stores)
+        return any(isinstance(document_store, type_) for type_ in self.supported_document_stores)

haystack/preview/document_stores/protocols.py

@@ -14,14 +14,14 @@ class DuplicatePolicy(Enum):
     FAIL = "fail"
 
 
-class Store(Protocol):
+class DocumentStore(Protocol):
     """
     Stores Documents to be used by the components of a Pipeline.
 
     Classes implementing this protocol often store the documents permanently and allow specialized components to
     perform retrieval on them, either by embedding, by keyword, hybrid, and so on, depending on the backend used.
 
-    In order to retrieve documents, consider using a Retriever that supports the document store implementation that
+    In order to retrieve documents, consider using a Retriever that supports the DocumentStore implementation that
     you're using.
     """
 
@@ -31,7 +31,7 @@ def to_dict(self) -> Dict[str, Any]:
         """
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Store":
+    def from_dict(cls, data: Dict[str, Any]) -> "DocumentStore":
         """
         Deserializes the store from a dictionary.
         """
@@ -115,11 +115,11 @@ def filter_documents(self, filters: Optional[Dict[str, Any]] = None) -> List[Doc
 
     def write_documents(self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.FAIL) -> None:
         """
-        Writes (or overwrites) documents into the store.
+        Writes (or overwrites) documents into the DocumentStore.
 
         :param documents: a list of documents.
         :param policy: documents with the same ID count as duplicates. When duplicates are met,
-            the store can:
+            the DocumentStore can:
              - skip: keep the existing document and ignore the new one.
              - overwrite: remove the old document and write the new one.
              - fail: an error is raised
@@ -129,8 +129,8 @@ def write_documents(self, documents: List[Document], policy: DuplicatePolicy = D
 
     def delete_documents(self, document_ids: List[str]) -> None:
         """
-        Deletes all documents with a matching document_ids from the document store.
-        Fails with `MissingDocumentError` if no document with this id is present in the store.
+        Deletes all documents with a matching document_ids from the DocumentStore.
+        Fails with `MissingDocumentError` if no document with this id is present in the DocumentStore.
 
         :param object_ids: the object_ids to delete
         """