Spaces:
Runtime error
Runtime error
File size: 5,989 Bytes
ed4d993 |
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 |
from __future__ import annotations
import logging
from functools import cached_property
from typing import Any, Dict, List, Optional
from langchain_core.embeddings import Embeddings
from langchain_core.pydantic_v1 import BaseModel, root_validator
logger = logging.getLogger(__name__)
MAX_BATCH_SIZE_CHARS = 1000000
MAX_BATCH_SIZE_PARTS = 90
class GigaChatEmbeddings(BaseModel, Embeddings):
"""GigaChat Embeddings models.
Example:
.. code-block:: python
from langchain_community.embeddings.gigachat import GigaChatEmbeddings
embeddings = GigaChatEmbeddings(
credentials=..., scope=..., verify_ssl_certs=False
)
"""
base_url: Optional[str] = None
""" Base API URL """
auth_url: Optional[str] = None
""" Auth URL """
credentials: Optional[str] = None
""" Auth Token """
scope: Optional[str] = None
""" Permission scope for access token """
access_token: Optional[str] = None
""" Access token for GigaChat """
model: Optional[str] = None
"""Model name to use."""
user: Optional[str] = None
""" Username for authenticate """
password: Optional[str] = None
""" Password for authenticate """
timeout: Optional[float] = 600
""" Timeout for request. By default it works for long requests. """
verify_ssl_certs: Optional[bool] = None
""" Check certificates for all requests """
ca_bundle_file: Optional[str] = None
cert_file: Optional[str] = None
key_file: Optional[str] = None
key_file_password: Optional[str] = None
# Support for connection to GigaChat through SSL certificates
@cached_property
def _client(self) -> Any:
"""Returns GigaChat API client"""
import gigachat
return gigachat.GigaChat(
base_url=self.base_url,
auth_url=self.auth_url,
credentials=self.credentials,
scope=self.scope,
access_token=self.access_token,
model=self.model,
user=self.user,
password=self.password,
timeout=self.timeout,
verify_ssl_certs=self.verify_ssl_certs,
ca_bundle_file=self.ca_bundle_file,
cert_file=self.cert_file,
key_file=self.key_file,
key_file_password=self.key_file_password,
)
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate authenticate data in environment and python package is installed."""
try:
import gigachat # noqa: F401
except ImportError:
raise ImportError(
"Could not import gigachat python package. "
"Please install it with `pip install gigachat`."
)
fields = set(cls.__fields__.keys())
diff = set(values.keys()) - fields
if diff:
logger.warning(f"Extra fields {diff} in GigaChat class")
return values
def embed_documents(self, texts: List[str]) -> List[List[float]]:
"""Embed documents using a GigaChat embeddings models.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
result: List[List[float]] = []
size = 0
local_texts = []
embed_kwargs = {}
if self.model is not None:
embed_kwargs["model"] = self.model
for text in texts:
local_texts.append(text)
size += len(text)
if size > MAX_BATCH_SIZE_CHARS or len(local_texts) > MAX_BATCH_SIZE_PARTS:
for embedding in self._client.embeddings(
texts=local_texts, **embed_kwargs
).data:
result.append(embedding.embedding)
size = 0
local_texts = []
# Call for last iteration
if local_texts:
for embedding in self._client.embeddings(
texts=local_texts, **embed_kwargs
).data:
result.append(embedding.embedding)
return result
async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
"""Embed documents using a GigaChat embeddings models.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
result: List[List[float]] = []
size = 0
local_texts = []
embed_kwargs = {}
if self.model is not None:
embed_kwargs["model"] = self.model
for text in texts:
local_texts.append(text)
size += len(text)
if size > MAX_BATCH_SIZE_CHARS or len(local_texts) > MAX_BATCH_SIZE_PARTS:
embeddings = await self._client.aembeddings(
texts=local_texts, **embed_kwargs
)
for embedding in embeddings.data:
result.append(embedding.embedding)
size = 0
local_texts = []
# Call for last iteration
if local_texts:
embeddings = await self._client.aembeddings(
texts=local_texts, **embed_kwargs
)
for embedding in embeddings.data:
result.append(embedding.embedding)
return result
def embed_query(self, text: str) -> List[float]:
"""Embed a query using a GigaChat embeddings models.
Args:
text: The text to embed.
Returns:
Embeddings for the text.
"""
return self.embed_documents(texts=[text])[0]
async def aembed_query(self, text: str) -> List[float]:
"""Embed a query using a GigaChat embeddings models.
Args:
text: The text to embed.
Returns:
Embeddings for the text.
"""
docs = await self.aembed_documents(texts=[text])
return docs[0]
|