File size: 8,500 Bytes
4ff79c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | # SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
#
# SPDX-License-Identifier: Apache-2.0
import hashlib
import io
from dataclasses import asdict, dataclass, field, fields
from typing import Any, Dict, List, Optional
from numpy import ndarray
from pandas import DataFrame, read_json
from haystack import logging
from haystack.dataclasses.byte_stream import ByteStream
from haystack.dataclasses.sparse_embedding import SparseEmbedding
logger = logging.getLogger(__name__)
class _BackwardCompatible(type):
"""
Metaclass that handles Document backward compatibility.
"""
def __call__(cls, *args, **kwargs):
"""
Called before Document.__init__, will remap legacy fields to new ones.
Also handles building a Document from a flattened dictionary.
"""
# Move `content` to new fields depending on the type
content = kwargs.get("content")
if isinstance(content, DataFrame):
kwargs["dataframe"] = content
del kwargs["content"]
# Not used anymore
if "content_type" in kwargs:
del kwargs["content_type"]
# Embedding were stored as NumPy arrays in 1.x, so we convert it to the new type
if isinstance(embedding := kwargs.get("embedding"), ndarray):
kwargs["embedding"] = embedding.tolist()
# id_hash_keys is not used anymore
if "id_hash_keys" in kwargs:
del kwargs["id_hash_keys"]
return super().__call__(*args, **kwargs)
@dataclass
class Document(metaclass=_BackwardCompatible):
"""
Base data class containing some data to be queried.
Can contain text snippets, tables, and file paths to images or audios. Documents can be sorted by score and saved
to/from dictionary and JSON.
:param id: Unique identifier for the document. When not set, it's generated based on the Document fields' values.
:param content: Text of the document, if the document contains text.
:param dataframe: Pandas dataframe with the document's content, if the document contains tabular data.
:param blob: Binary data associated with the document, if the document has any binary data associated with it.
:param meta: Additional custom metadata for the document. Must be JSON-serializable.
:param score: Score of the document. Used for ranking, usually assigned by retrievers.
:param embedding: dense vector representation of the document.
:param sparse_embedding: sparse vector representation of the document.
"""
id: str = field(default="")
content: Optional[str] = field(default=None)
dataframe: Optional[DataFrame] = field(default=None)
blob: Optional[ByteStream] = field(default=None)
meta: Dict[str, Any] = field(default_factory=dict)
score: Optional[float] = field(default=None)
embedding: Optional[List[float]] = field(default=None)
sparse_embedding: Optional[SparseEmbedding] = field(default=None)
def __repr__(self):
fields = []
if self.content is not None:
fields.append(
f"content: '{self.content}'" if len(self.content) < 100 else f"content: '{self.content[:100]}...'"
)
if self.dataframe is not None:
fields.append(f"dataframe: {self.dataframe.shape}")
if self.blob is not None:
fields.append(f"blob: {len(self.blob.data)} bytes")
if len(self.meta) > 0:
fields.append(f"meta: {self.meta}")
if self.score is not None:
fields.append(f"score: {self.score}")
if self.embedding is not None:
fields.append(f"embedding: vector of size {len(self.embedding)}")
if self.sparse_embedding is not None:
fields.append(f"sparse_embedding: vector with {len(self.sparse_embedding.indices)} non-zero elements")
fields_str = ", ".join(fields)
return f"{self.__class__.__name__}(id={self.id}, {fields_str})"
def __eq__(self, other):
"""
Compares Documents for equality.
Two Documents are considered equals if their dictionary representation is identical.
"""
if type(self) != type(other):
return False
return self.to_dict() == other.to_dict()
def __post_init__(self):
"""
Generate the ID based on the init parameters.
"""
# Generate an id only if not explicitly set
self.id = self.id or self._create_id()
def _create_id(self):
"""
Creates a hash of the given content that acts as the document's ID.
"""
text = self.content or None
dataframe = self.dataframe.to_json() if self.dataframe is not None else None
blob = self.blob.data if self.blob is not None else None
mime_type = self.blob.mime_type if self.blob is not None else None
meta = self.meta or {}
embedding = self.embedding if self.embedding is not None else None
sparse_embedding = self.sparse_embedding.to_dict() if self.sparse_embedding is not None else ""
data = f"{text}{dataframe}{blob}{mime_type}{meta}{embedding}{sparse_embedding}"
return hashlib.sha256(data.encode("utf-8")).hexdigest()
def to_dict(self, flatten=True) -> Dict[str, Any]:
"""
Converts Document into a dictionary.
`dataframe` and `blob` fields are converted to JSON-serializable types.
:param flatten:
Whether to flatten `meta` field or not. Defaults to `True` to be backward-compatible with Haystack 1.x.
"""
data = asdict(self)
if (dataframe := data.get("dataframe")) is not None:
data["dataframe"] = dataframe.to_json()
if (blob := data.get("blob")) is not None:
data["blob"] = {"data": list(blob["data"]), "mime_type": blob["mime_type"]}
if flatten:
meta = data.pop("meta")
return {**data, **meta}
return data
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "Document":
"""
Creates a new Document object from a dictionary.
The `dataframe` and `blob` fields are converted to their original types.
"""
if (dataframe := data.get("dataframe")) is not None:
data["dataframe"] = read_json(io.StringIO(dataframe))
if blob := data.get("blob"):
data["blob"] = ByteStream(data=bytes(blob["data"]), mime_type=blob["mime_type"])
if sparse_embedding := data.get("sparse_embedding"):
data["sparse_embedding"] = SparseEmbedding.from_dict(sparse_embedding)
# Store metadata for a moment while we try un-flattening allegedly flatten metadata.
# We don't expect both a `meta=` keyword and flatten metadata keys so we'll raise a
# ValueError later if this is the case.
meta = data.pop("meta", {})
# Unflatten metadata if it was flattened. We assume any keyword argument that's not
# a document field is a metadata key. We treat legacy fields as document fields
# for backward compatibility.
flatten_meta = {}
legacy_fields = ["content_type", "id_hash_keys"]
document_fields = legacy_fields + [f.name for f in fields(cls)]
for key in list(data.keys()):
if key not in document_fields:
flatten_meta[key] = data.pop(key)
# We don't support passing both flatten keys and the `meta` keyword parameter
if meta and flatten_meta:
raise ValueError(
"You can pass either the 'meta' parameter or flattened metadata keys as keyword arguments, "
"but currently you're passing both. Pass either the 'meta' parameter or flattened metadata keys."
)
# Finally put back all the metadata
return cls(**data, meta={**meta, **flatten_meta})
@property
def content_type(self):
"""
Returns the type of the content for the document.
This is necessary to keep backward compatibility with 1.x.
:raises ValueError:
If both `text` and `dataframe` fields are set or both are missing.
"""
if self.content is not None and self.dataframe is not None:
raise ValueError("Both text and dataframe are set.")
if self.content is not None:
return "text"
elif self.dataframe is not None:
return "table"
raise ValueError("Neither text nor dataframe is set.")
|