method_name
stringlengths 1
78
| method_body
stringlengths 3
9.66k
| full_code
stringlengths 31
10.7k
| docstring
stringlengths 4
4.74k
⌀ |
|---|---|---|---|
draw | """
CPAL chain can draw its resulting DAG.
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> cpal_chain.draw(path="graph.svg")
>>> SVG('graph.svg')
"""
self._story._networkx_wrapper.draw_graphviz(**kwargs) | def draw(self, **kwargs: Any) ->None:
"""
CPAL chain can draw its resulting DAG.
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> cpal_chain.draw(path="graph.svg")
>>> SVG('graph.svg')
"""
self._story._networkx_wrapper.draw_graphviz(**kwargs) | CPAL chain can draw its resulting DAG.
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> cpal_chain.draw(path="graph.svg")
>>> SVG('graph.svg') |
similarity_search | """Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
fetch_k: (Optional[int]) Number of Documents to fetch before filtering.
Defaults to 20.
Returns:
List of Documents most similar to the query.
"""
docs_and_scores = self.similarity_search_with_score(query, k, filter=filter,
fetch_k=fetch_k, **kwargs)
return [doc for doc, _ in docs_and_scores] | def similarity_search(self, query: str, k: int=4, filter: Optional[Dict[str,
Any]]=None, fetch_k: int=20, **kwargs: Any) ->List[Document]:
"""Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
fetch_k: (Optional[int]) Number of Documents to fetch before filtering.
Defaults to 20.
Returns:
List of Documents most similar to the query.
"""
docs_and_scores = self.similarity_search_with_score(query, k, filter=
filter, fetch_k=fetch_k, **kwargs)
return [doc for doc, _ in docs_and_scores] | Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter: (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
fetch_k: (Optional[int]) Number of Documents to fetch before filtering.
Defaults to 20.
Returns:
List of Documents most similar to the query. |
on_llm_start | """Run when LLM starts running.""" | def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **
kwargs: Any) ->None:
"""Run when LLM starts running.""" | Run when LLM starts running. |
cosine_similarity_top_k | """Row-wise cosine similarity with optional top-k and score threshold filtering.
Args:
X: Matrix.
Y: Matrix, same width as X.
top_k: Max number of results to return.
score_threshold: Minimum cosine similarity of results.
Returns:
Tuple of two lists. First contains two-tuples of indices (X_idx, Y_idx),
second contains corresponding cosine similarities.
"""
if len(X) == 0 or len(Y) == 0:
return [], []
score_array = cosine_similarity(X, Y)
score_threshold = score_threshold or -1.0
score_array[score_array < score_threshold] = 0
top_k = min(top_k or len(score_array), np.count_nonzero(score_array))
top_k_idxs = np.argpartition(score_array, -top_k, axis=None)[-top_k:]
top_k_idxs = top_k_idxs[np.argsort(score_array.ravel()[top_k_idxs])][::-1]
ret_idxs = np.unravel_index(top_k_idxs, score_array.shape)
scores = score_array.ravel()[top_k_idxs].tolist()
return list(zip(*ret_idxs)), scores | def cosine_similarity_top_k(X: Matrix, Y: Matrix, top_k: Optional[int]=5,
score_threshold: Optional[float]=None) ->Tuple[List[Tuple[int, int]],
List[float]]:
"""Row-wise cosine similarity with optional top-k and score threshold filtering.
Args:
X: Matrix.
Y: Matrix, same width as X.
top_k: Max number of results to return.
score_threshold: Minimum cosine similarity of results.
Returns:
Tuple of two lists. First contains two-tuples of indices (X_idx, Y_idx),
second contains corresponding cosine similarities.
"""
if len(X) == 0 or len(Y) == 0:
return [], []
score_array = cosine_similarity(X, Y)
score_threshold = score_threshold or -1.0
score_array[score_array < score_threshold] = 0
top_k = min(top_k or len(score_array), np.count_nonzero(score_array))
top_k_idxs = np.argpartition(score_array, -top_k, axis=None)[-top_k:]
top_k_idxs = top_k_idxs[np.argsort(score_array.ravel()[top_k_idxs])][::-1]
ret_idxs = np.unravel_index(top_k_idxs, score_array.shape)
scores = score_array.ravel()[top_k_idxs].tolist()
return list(zip(*ret_idxs)), scores | Row-wise cosine similarity with optional top-k and score threshold filtering.
Args:
X: Matrix.
Y: Matrix, same width as X.
top_k: Max number of results to return.
score_threshold: Minimum cosine similarity of results.
Returns:
Tuple of two lists. First contains two-tuples of indices (X_idx, Y_idx),
second contains corresponding cosine similarities. |
_import_zapier_tool_ZapierNLAListActions | from langchain_community.tools.zapier.tool import ZapierNLAListActions
return ZapierNLAListActions | def _import_zapier_tool_ZapierNLAListActions() ->Any:
from langchain_community.tools.zapier.tool import ZapierNLAListActions
return ZapierNLAListActions | null |
test_model_response | msg = AIMessage(content='Model response.')
result = _parse_ai_message(msg)
assert isinstance(result, AgentFinish)
assert result.return_values == {'output': 'Model response.'}
assert result.log == 'Model response.' | def test_model_response(self) ->None:
msg = AIMessage(content='Model response.')
result = _parse_ai_message(msg)
assert isinstance(result, AgentFinish)
assert result.return_values == {'output': 'Model response.'}
assert result.log == 'Model response.' | null |
__init__ | super().__init__(**kwargs)
self.function_callback = function | def __init__(self, function: Callable[[str], None], **kwargs: Any) ->None:
super().__init__(**kwargs)
self.function_callback = function | null |
_import_requests_tool_RequestsPatchTool | from langchain_community.tools.requests.tool import RequestsPatchTool
return RequestsPatchTool | def _import_requests_tool_RequestsPatchTool() ->Any:
from langchain_community.tools.requests.tool import RequestsPatchTool
return RequestsPatchTool | null |
__repr__ | map_for_repr = ',\n '.join(
f"{k}: {indent_lines_after_first(repr(v), ' ' + k + ': ')}" for k, v in
self.steps.items())
return '{\n ' + map_for_repr + '\n}' | def __repr__(self) ->str:
map_for_repr = ',\n '.join(
f"{k}: {indent_lines_after_first(repr(v), ' ' + k + ': ')}" for k,
v in self.steps.items())
return '{\n ' + map_for_repr + '\n}' | null |
__init__ | self.json_data = json_data
self.status_code = status_code | def __init__(self, json_data: Dict, status_code: int):
self.json_data = json_data
self.status_code = status_code | null |
call | """call."""
headers = {'Content-Type': 'application/json', 'Authorization': 'Bearer ' +
self.endpoint_api_key}
if self.deployment_name != '':
headers['azureml-model-deployment'] = self.deployment_name
req = urllib.request.Request(self.endpoint_url, body, headers)
response = urllib.request.urlopen(req, timeout=kwargs.get('timeout', 50))
result = response.read()
return result | def call(self, body: bytes, **kwargs: Any) ->bytes:
"""call."""
headers = {'Content-Type': 'application/json', 'Authorization':
'Bearer ' + self.endpoint_api_key}
if self.deployment_name != '':
headers['azureml-model-deployment'] = self.deployment_name
req = urllib.request.Request(self.endpoint_url, body, headers)
response = urllib.request.urlopen(req, timeout=kwargs.get('timeout', 50))
result = response.read()
return result | call. |
test_scann_vector_sim_with_score_threshold | """Test vector similarity."""
texts = ['foo', 'bar', 'baz']
docsearch = ScaNN.from_texts(texts, FakeEmbeddings())
index_to_id = docsearch.index_to_docstore_id
expected_docstore = InMemoryDocstore({index_to_id[0]: Document(page_content
='foo'), index_to_id[1]: Document(page_content='bar'), index_to_id[2]:
Document(page_content='baz')})
assert docsearch.docstore.__dict__ == expected_docstore.__dict__
query_vec = FakeEmbeddings().embed_query(text='foo')
output = docsearch.similarity_search_by_vector(query_vec, k=2,
score_threshold=0.2)
assert output == [Document(page_content='foo')] | def test_scann_vector_sim_with_score_threshold() ->None:
"""Test vector similarity."""
texts = ['foo', 'bar', 'baz']
docsearch = ScaNN.from_texts(texts, FakeEmbeddings())
index_to_id = docsearch.index_to_docstore_id
expected_docstore = InMemoryDocstore({index_to_id[0]: Document(
page_content='foo'), index_to_id[1]: Document(page_content='bar'),
index_to_id[2]: Document(page_content='baz')})
assert docsearch.docstore.__dict__ == expected_docstore.__dict__
query_vec = FakeEmbeddings().embed_query(text='foo')
output = docsearch.similarity_search_by_vector(query_vec, k=2,
score_threshold=0.2)
assert output == [Document(page_content='foo')] | Test vector similarity. |
test_qdrant_similarity_search_with_relevance_score_no_threshold | """Test end to end construction and search."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i, 'metadata': {'page': i + 1, 'pages': [i + 2, -1]}} for
i in range(len(texts))]
docsearch = Qdrant.from_texts(texts, ConsistentFakeEmbeddings(), metadatas=
metadatas, location=':memory:', vector_name=vector_name)
output = docsearch.similarity_search_with_relevance_scores('foo', k=3,
score_threshold=None)
assert len(output) == 3
for i in range(len(output)):
assert round(output[i][1], 2) >= 0
assert round(output[i][1], 2) <= 1 | @pytest.mark.parametrize('vector_name', [None, 'my-vector'])
def test_qdrant_similarity_search_with_relevance_score_no_threshold(vector_name
: Optional[str]) ->None:
"""Test end to end construction and search."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i, 'metadata': {'page': i + 1, 'pages': [i + 2, -
1]}} for i in range(len(texts))]
docsearch = Qdrant.from_texts(texts, ConsistentFakeEmbeddings(),
metadatas=metadatas, location=':memory:', vector_name=vector_name)
output = docsearch.similarity_search_with_relevance_scores('foo', k=3,
score_threshold=None)
assert len(output) == 3
for i in range(len(output)):
assert round(output[i][1], 2) >= 0
assert round(output[i][1], 2) <= 1 | Test end to end construction and search. |
full_table_id | return self._full_table_id | @property
def full_table_id(self) ->str:
return self._full_table_id | null |
test_results_with_custom_params | """Test that call gives correct answer with custom params."""
search = SearchApiAPIWrapper()
output = search.results('cafeteria', hl='es', gl='es', google_domain=
'google.es', location='Madrid, Spain')
assert 'Madrid' in output['search_information']['detected_location'] | def test_results_with_custom_params() ->None:
"""Test that call gives correct answer with custom params."""
search = SearchApiAPIWrapper()
output = search.results('cafeteria', hl='es', gl='es', google_domain=
'google.es', location='Madrid, Spain')
assert 'Madrid' in output['search_information']['detected_location'] | Test that call gives correct answer with custom params. |
test_pgvector_max_marginal_relevance_search_with_score | """Test max marginal relevance search with relevance scores."""
texts = ['foo', 'bar', 'baz']
docsearch = PGVector.from_texts(texts=texts, collection_name=
'test_collection', embedding=FakeEmbeddingsWithAdaDimension(),
connection_string=CONNECTION_STRING, pre_delete_collection=True)
output = docsearch.max_marginal_relevance_search_with_score('foo', k=1,
fetch_k=3)
assert output == [(Document(page_content='foo'), 0.0)] | def test_pgvector_max_marginal_relevance_search_with_score() ->None:
"""Test max marginal relevance search with relevance scores."""
texts = ['foo', 'bar', 'baz']
docsearch = PGVector.from_texts(texts=texts, collection_name=
'test_collection', embedding=FakeEmbeddingsWithAdaDimension(),
connection_string=CONNECTION_STRING, pre_delete_collection=True)
output = docsearch.max_marginal_relevance_search_with_score('foo', k=1,
fetch_k=3)
assert output == [(Document(page_content='foo'), 0.0)] | Test max marginal relevance search with relevance scores. |
search_results | from zep_python import MemorySearchResult, Message
search_result = [{'message': {'uuid':
'66830914-19f5-490b-8677-1ba06bcd556b', 'created_at':
'2023-05-18T20:40:42.743773Z', 'role': 'user', 'content':
"I'm looking to plan a trip to Iceland. Can you help me?",
'token_count': 17}, 'summary': None, 'dist': 0.8734284910450115}, {
'message': {'uuid': '015e618c-ba9d-45b6-95c3-77a8e611570b',
'created_at': '2023-05-18T20:40:42.743773Z', 'role': 'user', 'content':
'How much does a trip to Iceland typically cost?', 'token_count': 12},
'summary': None, 'dist': 0.8554048017463456}]
return [MemorySearchResult(message=Message.parse_obj(result['message']),
summary=result['summary'], dist=result['dist']) for result in search_result
] | @pytest.fixture
def search_results() ->List[MemorySearchResult]:
from zep_python import MemorySearchResult, Message
search_result = [{'message': {'uuid':
'66830914-19f5-490b-8677-1ba06bcd556b', 'created_at':
'2023-05-18T20:40:42.743773Z', 'role': 'user', 'content':
"I'm looking to plan a trip to Iceland. Can you help me?",
'token_count': 17}, 'summary': None, 'dist': 0.8734284910450115}, {
'message': {'uuid': '015e618c-ba9d-45b6-95c3-77a8e611570b',
'created_at': '2023-05-18T20:40:42.743773Z', 'role': 'user',
'content': 'How much does a trip to Iceland typically cost?',
'token_count': 12}, 'summary': None, 'dist': 0.8554048017463456}]
return [MemorySearchResult(message=Message.parse_obj(result['message']),
summary=result['summary'], dist=result['dist']) for result in
search_result] | null |
_get_dataforseo_api_search_json | return DataForSeoAPISearchResults(api_wrapper=DataForSeoAPIWrapper(**kwargs)) | def _get_dataforseo_api_search_json(**kwargs: Any) ->BaseTool:
return DataForSeoAPISearchResults(api_wrapper=DataForSeoAPIWrapper(**
kwargs)) | null |
test_placeholder | """Used for compiling integration tests without running any real tests."""
pass | @pytest.mark.compile
def test_placeholder() ->None:
"""Used for compiling integration tests without running any real tests."""
pass | Used for compiling integration tests without running any real tests. |
__init__ | """Initialize with access token, ids, and key.
Args:
access_token: The access token for the Figma REST API.
ids: The ids of the Figma file.
key: The key for the Figma file
"""
self.access_token = access_token
self.ids = ids
self.key = key | def __init__(self, access_token: str, ids: str, key: str):
"""Initialize with access token, ids, and key.
Args:
access_token: The access token for the Figma REST API.
ids: The ids of the Figma file.
key: The key for the Figma file
"""
self.access_token = access_token
self.ids = ids
self.key = key | Initialize with access token, ids, and key.
Args:
access_token: The access token for the Figma REST API.
ids: The ids of the Figma file.
key: The key for the Figma file |
_identifying_params | """Get the identifying parameters."""
return {**{'model_path': self.model_path}, **self._default_params} | @property
def _identifying_params(self) ->Dict[str, Any]:
"""Get the identifying parameters."""
return {**{'model_path': self.model_path}, **self._default_params} | Get the identifying parameters. |
__init__ | """Initialize the parser.
Args:
text_kwargs: Keyword arguments to pass to ``pdfplumber.Page.extract_text()``
dedupe: Avoiding the error of duplicate characters if `dedupe=True`.
"""
self.text_kwargs = text_kwargs or {}
self.dedupe = dedupe
self.extract_images = extract_images | def __init__(self, text_kwargs: Optional[Mapping[str, Any]]=None, dedupe:
bool=False, extract_images: bool=False) ->None:
"""Initialize the parser.
Args:
text_kwargs: Keyword arguments to pass to ``pdfplumber.Page.extract_text()``
dedupe: Avoiding the error of duplicate characters if `dedupe=True`.
"""
self.text_kwargs = text_kwargs or {}
self.dedupe = dedupe
self.extract_images = extract_images | Initialize the parser.
Args:
text_kwargs: Keyword arguments to pass to ``pdfplumber.Page.extract_text()``
dedupe: Avoiding the error of duplicate characters if `dedupe=True`. |
test_mget | store = UpstashRedisByteStore(client=redis_client, ttl=None)
keys = ['key1', 'key2']
redis_client.mset({'key1': 'value1', 'key2': 'value2'})
result = store.mget(keys)
assert result == [b'value1', b'value2'] | def test_mget(redis_client: Redis) ->None:
store = UpstashRedisByteStore(client=redis_client, ttl=None)
keys = ['key1', 'key2']
redis_client.mset({'key1': 'value1', 'key2': 'value2'})
result = store.mget(keys)
assert result == [b'value1', b'value2'] | null |
_identifying_params | """Gets the identifying parameters."""
return {**{'model_name': self.model_name}, **self._default_params} | @property
def _identifying_params(self) ->Dict[str, Any]:
"""Gets the identifying parameters."""
return {**{'model_name': self.model_name}, **self._default_params} | Gets the identifying parameters. |
_identifying_params | """Get the identifying parameters."""
return {**{'model_name': self.model_name}, **self._default_params} | @property
def _identifying_params(self) ->Dict[str, Any]:
"""Get the identifying parameters."""
return {**{'model_name': self.model_name}, **self._default_params} | Get the identifying parameters. |
__getitem__ | return getattr(self, item) | def __getitem__(self, item: str) ->Any:
return getattr(self, item) | null |
_import_supabase | from langchain_community.vectorstores.supabase import SupabaseVectorStore
return SupabaseVectorStore | def _import_supabase() ->Any:
from langchain_community.vectorstores.supabase import SupabaseVectorStore
return SupabaseVectorStore | null |
assert_docs | for doc in docs:
assert doc.metadata
assert set(doc.metadata) == {'Copyright Information', 'uid', 'Title',
'Published'} | def assert_docs(docs: List[Document]) ->None:
for doc in docs:
assert doc.metadata
assert set(doc.metadata) == {'Copyright Information', 'uid',
'Title', 'Published'} | null |
__init__ | """Initialize with bagel client"""
try:
import bagel
import bagel.config
except ImportError:
raise ImportError('Please install bagel `pip install betabageldb`.')
if client is not None:
self._client_settings = client_settings
self._client = client
else:
if client_settings:
_client_settings = client_settings
else:
_client_settings = bagel.config.Settings(bagel_api_impl='rest',
bagel_server_host='api.bageldb.ai')
self._client_settings = _client_settings
self._client = bagel.Client(_client_settings)
self._cluster = self._client.get_or_create_cluster(name=cluster_name,
metadata=cluster_metadata)
self.override_relevance_score_fn = relevance_score_fn
self._embedding_function = embedding_function | def __init__(self, cluster_name: str=_LANGCHAIN_DEFAULT_CLUSTER_NAME,
client_settings: Optional[bagel.config.Settings]=None,
embedding_function: Optional[Embeddings]=None, cluster_metadata:
Optional[Dict]=None, client: Optional[bagel.Client]=None,
relevance_score_fn: Optional[Callable[[float], float]]=None) ->None:
"""Initialize with bagel client"""
try:
import bagel
import bagel.config
except ImportError:
raise ImportError('Please install bagel `pip install betabageldb`.')
if client is not None:
self._client_settings = client_settings
self._client = client
else:
if client_settings:
_client_settings = client_settings
else:
_client_settings = bagel.config.Settings(bagel_api_impl='rest',
bagel_server_host='api.bageldb.ai')
self._client_settings = _client_settings
self._client = bagel.Client(_client_settings)
self._cluster = self._client.get_or_create_cluster(name=cluster_name,
metadata=cluster_metadata)
self.override_relevance_score_fn = relevance_score_fn
self._embedding_function = embedding_function | Initialize with bagel client |
__from | if metric not in INDEX_METRICS:
raise ValueError(
f'Unsupported distance metric: {metric}. Expected one of {list(INDEX_METRICS)}'
)
tiledb_vs, tiledb = dependable_tiledb_import()
input_vectors = np.array(embeddings).astype(np.float32)
cls.create(index_uri=index_uri, index_type=index_type, dimensions=
input_vectors.shape[1], vector_type=input_vectors.dtype, metadatas=
metadatas is not None, config=config)
with tiledb.scope_ctx(ctx_or_config=config):
if not embeddings:
raise ValueError('embeddings must be provided to build a TileDB index')
vector_index_uri = get_vector_index_uri(index_uri)
docs_uri = get_documents_array_uri(index_uri)
if ids is None:
ids = [str(random.randint(0, MAX_UINT64 - 1)) for _ in texts]
external_ids = np.array(ids).astype(np.uint64)
tiledb_vs.ingestion.ingest(index_type=index_type, index_uri=
vector_index_uri, input_vectors=input_vectors, external_ids=
external_ids, index_timestamp=index_timestamp if index_timestamp !=
0 else None, config=config, **kwargs)
with tiledb.open(docs_uri, 'w') as A:
if external_ids is None:
external_ids = np.zeros(len(texts), dtype=np.uint64)
for i in range(len(texts)):
external_ids[i] = i
data = {}
data['text'] = np.array(texts)
if metadatas is not None:
metadata_attr = np.empty([len(metadatas)], dtype=object)
i = 0
for metadata in metadatas:
metadata_attr[i] = np.frombuffer(pickle.dumps(metadata),
dtype=np.uint8)
i += 1
data['metadata'] = metadata_attr
A[external_ids] = data
return cls(embedding=embedding, index_uri=index_uri, metric=metric, config=
config, **kwargs) | @classmethod
def __from(cls, texts: List[str], embeddings: List[List[float]], embedding:
Embeddings, index_uri: str, *, metadatas: Optional[List[dict]]=None,
ids: Optional[List[str]]=None, metric: str=DEFAULT_METRIC, index_type:
str='FLAT', config: Optional[Mapping[str, Any]]=None, index_timestamp:
int=0, **kwargs: Any) ->TileDB:
if metric not in INDEX_METRICS:
raise ValueError(
f'Unsupported distance metric: {metric}. Expected one of {list(INDEX_METRICS)}'
)
tiledb_vs, tiledb = dependable_tiledb_import()
input_vectors = np.array(embeddings).astype(np.float32)
cls.create(index_uri=index_uri, index_type=index_type, dimensions=
input_vectors.shape[1], vector_type=input_vectors.dtype, metadatas=
metadatas is not None, config=config)
with tiledb.scope_ctx(ctx_or_config=config):
if not embeddings:
raise ValueError(
'embeddings must be provided to build a TileDB index')
vector_index_uri = get_vector_index_uri(index_uri)
docs_uri = get_documents_array_uri(index_uri)
if ids is None:
ids = [str(random.randint(0, MAX_UINT64 - 1)) for _ in texts]
external_ids = np.array(ids).astype(np.uint64)
tiledb_vs.ingestion.ingest(index_type=index_type, index_uri=
vector_index_uri, input_vectors=input_vectors, external_ids=
external_ids, index_timestamp=index_timestamp if
index_timestamp != 0 else None, config=config, **kwargs)
with tiledb.open(docs_uri, 'w') as A:
if external_ids is None:
external_ids = np.zeros(len(texts), dtype=np.uint64)
for i in range(len(texts)):
external_ids[i] = i
data = {}
data['text'] = np.array(texts)
if metadatas is not None:
metadata_attr = np.empty([len(metadatas)], dtype=object)
i = 0
for metadata in metadatas:
metadata_attr[i] = np.frombuffer(pickle.dumps(metadata),
dtype=np.uint8)
i += 1
data['metadata'] = metadata_attr
A[external_ids] = data
return cls(embedding=embedding, index_uri=index_uri, metric=metric,
config=config, **kwargs) | null |
visit_comparison | if isinstance(comparison.value, list):
return self.visit_operation(Operation(operator=Operator.AND, arguments=
(Comparison(comparator=comparison.comparator, attribute=comparison.
attribute, value=value) for value in comparison.value)))
return '.'.join([
f'{self.metadata_column}{self._get_json_operator(comparison.value)}{comparison.attribute}'
, f'{self._map_comparator(comparison.comparator)}', f'{comparison.value}']) | def visit_comparison(self, comparison: Comparison) ->str:
if isinstance(comparison.value, list):
return self.visit_operation(Operation(operator=Operator.AND,
arguments=(Comparison(comparator=comparison.comparator,
attribute=comparison.attribute, value=value) for value in
comparison.value)))
return '.'.join([
f'{self.metadata_column}{self._get_json_operator(comparison.value)}{comparison.attribute}'
, f'{self._map_comparator(comparison.comparator)}',
f'{comparison.value}']) | null |
get_named_result | """
Get a named result from a query.
Args:
connection: The connection to the database
query: The query to execute
Returns:
List[dict[str, Any]]: The result of the query
"""
cursor = connection.cursor()
cursor.execute(query)
columns = cursor.description
result = []
for value in cursor.fetchall():
r = {}
for idx, datum in enumerate(value):
k = columns[idx][0]
r[k] = datum
result.append(r)
debug_output(result)
cursor.close()
return result | def get_named_result(connection: Any, query: str) ->List[dict[str, Any]]:
"""
Get a named result from a query.
Args:
connection: The connection to the database
query: The query to execute
Returns:
List[dict[str, Any]]: The result of the query
"""
cursor = connection.cursor()
cursor.execute(query)
columns = cursor.description
result = []
for value in cursor.fetchall():
r = {}
for idx, datum in enumerate(value):
k = columns[idx][0]
r[k] = datum
result.append(r)
debug_output(result)
cursor.close()
return result | Get a named result from a query.
Args:
connection: The connection to the database
query: The query to execute
Returns:
List[dict[str, Any]]: The result of the query |
input_keys | extra_keys = [k for k in self.llm_chain.input_keys if k != self.
document_variable_name]
return super().input_keys + extra_keys | @property
def input_keys(self) ->List[str]:
extra_keys = [k for k in self.llm_chain.input_keys if k != self.
document_variable_name]
return super().input_keys + extra_keys | null |
_import_promptlayer_chat | from langchain_community.llms.promptlayer_openai import PromptLayerOpenAIChat
return PromptLayerOpenAIChat | def _import_promptlayer_chat() ->Any:
from langchain_community.llms.promptlayer_openai import PromptLayerOpenAIChat
return PromptLayerOpenAIChat | null |
elasticsearch_connection | from elasticsearch import Elasticsearch
es_url = os.environ.get('ES_URL', 'http://localhost:9200')
cloud_id = os.environ.get('ES_CLOUD_ID')
es_username = os.environ.get('ES_USERNAME', 'elastic')
es_password = os.environ.get('ES_PASSWORD', 'changeme')
if cloud_id:
es = Elasticsearch(cloud_id=cloud_id, basic_auth=(es_username, es_password)
)
yield {'es_cloud_id': cloud_id, 'es_user': es_username, 'es_password':
es_password}
else:
es = Elasticsearch(hosts=es_url)
yield {'es_url': es_url}
index_names = es.indices.get(index='_all').keys()
for index_name in index_names:
if index_name.startswith('test_'):
es.indices.delete(index=index_name)
es.indices.refresh(index='_all')
try:
response = es.ingest.get_pipeline(id='test_*,*_sparse_embedding')
for pipeline_id, _ in response.items():
try:
es.ingest.delete_pipeline(id=pipeline_id)
print(f'Deleted pipeline: {pipeline_id}')
except Exception as e:
print(f'Pipeline error: {e}')
except Exception:
pass | @pytest.fixture(scope='class', autouse=True)
def elasticsearch_connection(self) ->Union[dict, Generator[dict, None, None]]:
from elasticsearch import Elasticsearch
es_url = os.environ.get('ES_URL', 'http://localhost:9200')
cloud_id = os.environ.get('ES_CLOUD_ID')
es_username = os.environ.get('ES_USERNAME', 'elastic')
es_password = os.environ.get('ES_PASSWORD', 'changeme')
if cloud_id:
es = Elasticsearch(cloud_id=cloud_id, basic_auth=(es_username,
es_password))
yield {'es_cloud_id': cloud_id, 'es_user': es_username,
'es_password': es_password}
else:
es = Elasticsearch(hosts=es_url)
yield {'es_url': es_url}
index_names = es.indices.get(index='_all').keys()
for index_name in index_names:
if index_name.startswith('test_'):
es.indices.delete(index=index_name)
es.indices.refresh(index='_all')
try:
response = es.ingest.get_pipeline(id='test_*,*_sparse_embedding')
for pipeline_id, _ in response.items():
try:
es.ingest.delete_pipeline(id=pipeline_id)
print(f'Deleted pipeline: {pipeline_id}')
except Exception as e:
print(f'Pipeline error: {e}')
except Exception:
pass | null |
on_llm_start | """Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({'action': 'on_llm_start'})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp['prompts'] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step) | def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **
kwargs: Any) ->None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({'action': 'on_llm_start'})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp['prompts'] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step) | Run when LLM starts. |
test_pickbest_textembedder_more_namespaces_w_full_label_w_partial_emakeep | feature_embedder = pick_best_chain.PickBestFeatureEmbedder(auto_embed=False,
model=MockEncoder())
str1 = '0'
str2 = '1'
str3 = '2'
encoded_str1 = rl_chain.stringify_embedding(list(encoded_keyword + str1))
encoded_str3 = rl_chain.stringify_embedding(list(encoded_keyword + str3))
ctx_str_1 = 'context1'
ctx_str_2 = 'context2'
encoded_ctx_str_2 = rl_chain.stringify_embedding(list(encoded_keyword +
ctx_str_2))
named_actions = {'action1': [{'a': str1, 'b': rl_chain.EmbedAndKeep(str1)},
str2, rl_chain.EmbedAndKeep(str3)]}
context = {'context1': ctx_str_1, 'context2': rl_chain.EmbedAndKeep(ctx_str_2)}
expected = f"""shared |context1 {ctx_str_1} |context2 {ctx_str_2 + ' ' + encoded_ctx_str_2}
0:-0.0:1.0 |a {str1} |b {str1 + ' ' + encoded_str1}
|action1 {str2}
|action1 {str3 + ' ' + encoded_str3} """
selected = pick_best_chain.PickBestSelected(index=0, probability=1.0, score=0.0
)
event = pick_best_chain.PickBestEvent(inputs={}, to_select_from=
named_actions, based_on=context, selected=selected)
vw_ex_str = feature_embedder.format(event)
assert vw_ex_str == expected | @pytest.mark.requires('vowpal_wabbit_next')
def test_pickbest_textembedder_more_namespaces_w_full_label_w_partial_emakeep(
) ->None:
feature_embedder = pick_best_chain.PickBestFeatureEmbedder(auto_embed=
False, model=MockEncoder())
str1 = '0'
str2 = '1'
str3 = '2'
encoded_str1 = rl_chain.stringify_embedding(list(encoded_keyword + str1))
encoded_str3 = rl_chain.stringify_embedding(list(encoded_keyword + str3))
ctx_str_1 = 'context1'
ctx_str_2 = 'context2'
encoded_ctx_str_2 = rl_chain.stringify_embedding(list(encoded_keyword +
ctx_str_2))
named_actions = {'action1': [{'a': str1, 'b': rl_chain.EmbedAndKeep(
str1)}, str2, rl_chain.EmbedAndKeep(str3)]}
context = {'context1': ctx_str_1, 'context2': rl_chain.EmbedAndKeep(
ctx_str_2)}
expected = f"""shared |context1 {ctx_str_1} |context2 {ctx_str_2 + ' ' + encoded_ctx_str_2}
0:-0.0:1.0 |a {str1} |b {str1 + ' ' + encoded_str1}
|action1 {str2}
|action1 {str3 + ' ' + encoded_str3} """
selected = pick_best_chain.PickBestSelected(index=0, probability=1.0,
score=0.0)
event = pick_best_chain.PickBestEvent(inputs={}, to_select_from=
named_actions, based_on=context, selected=selected)
vw_ex_str = feature_embedder.format(event)
assert vw_ex_str == expected | null |
test_get_nfts_valid_contract | max_alchemy_tokens = 100
contract_address = '0x1a92f7381b9f03921564a437210bb9396471050c'
result = BlockchainDocumentLoader(contract_address).load()
print('Tokens returned for valid contract: ', len(result))
assert len(result
) == max_alchemy_tokens, f'Wrong number of NFTs returned. Expected {max_alchemy_tokens}, got {len(result)}' | @pytest.mark.skipif(not alchemyKeySet, reason='Alchemy API key not provided.')
def test_get_nfts_valid_contract() ->None:
max_alchemy_tokens = 100
contract_address = '0x1a92f7381b9f03921564a437210bb9396471050c'
result = BlockchainDocumentLoader(contract_address).load()
print('Tokens returned for valid contract: ', len(result))
assert len(result
) == max_alchemy_tokens, f'Wrong number of NFTs returned. Expected {max_alchemy_tokens}, got {len(result)}' | null |
_format_func | self._validate_func(func)
comp_operator_map = {Comparator.EQ: 'term', Comparator.LT: 'lt', Comparator
.LTE: 'lte', Comparator.GT: 'gt', Comparator.GTE: 'gte', Comparator.
CONTAIN: 'match', Comparator.LIKE: 'fuzzy', Operator.AND: 'must',
Operator.OR: 'should', Operator.NOT: 'must_not'}
return comp_operator_map[func] | def _format_func(self, func: Union[Operator, Comparator]) ->str:
self._validate_func(func)
comp_operator_map = {Comparator.EQ: 'term', Comparator.LT: 'lt',
Comparator.LTE: 'lte', Comparator.GT: 'gt', Comparator.GTE: 'gte',
Comparator.CONTAIN: 'match', Comparator.LIKE: 'fuzzy', Operator.AND:
'must', Operator.OR: 'should', Operator.NOT: 'must_not'}
return comp_operator_map[func] | null |
on_chain_error | if parent_run_id is None:
self.increment() | def on_chain_error(self, error: BaseException, *, run_id: UUID,
parent_run_id: Optional[UUID]=None, **kwargs: Any) ->Any:
if parent_run_id is None:
self.increment() | null |
endpoint_path | return self.client.endpoint_path(project=self.project, location=self.
location, endpoint=self.endpoint_id) | @property
def endpoint_path(self) ->str:
return self.client.endpoint_path(project=self.project, location=self.
location, endpoint=self.endpoint_id) | null |
wait_for_futures | """Wait for all futures to complete."""
wait(self.futures) | def wait_for_futures(self) ->None:
"""Wait for all futures to complete."""
wait(self.futures) | Wait for all futures to complete. |
test__convert_message_to_dict_system | message = SystemMessage(content='foo')
with pytest.raises(TypeError) as e:
_convert_message_to_dict(message)
assert 'Got unknown type' in str(e) | def test__convert_message_to_dict_system() ->None:
message = SystemMessage(content='foo')
with pytest.raises(TypeError) as e:
_convert_message_to_dict(message)
assert 'Got unknown type' in str(e) | null |
import_mlflow | """Import the mlflow python package and raise an error if it is not installed."""
try:
import mlflow
except ImportError:
raise ImportError(
'To use the mlflow callback manager you need to have the `mlflow` python package installed. Please install it with `pip install mlflow>=2.3.0`'
)
return mlflow | def import_mlflow() ->Any:
"""Import the mlflow python package and raise an error if it is not installed."""
try:
import mlflow
except ImportError:
raise ImportError(
'To use the mlflow callback manager you need to have the `mlflow` python package installed. Please install it with `pip install mlflow>=2.3.0`'
)
return mlflow | Import the mlflow python package and raise an error if it is not installed. |
combine_documents | """
Combine a list of documents into a single string that might be passed further down
to a language model.
:param documents: list of documents to combine
:return:
"""
formatter = Formatter()
return '\n\n'.join(formatter.format(document_template, page_content=
document.page_content, metadata=document.metadata) for document in
documents) | def combine_documents(documents: List[Document]) ->str:
"""
Combine a list of documents into a single string that might be passed further down
to a language model.
:param documents: list of documents to combine
:return:
"""
formatter = Formatter()
return '\n\n'.join(formatter.format(document_template, page_content=
document.page_content, metadata=document.metadata) for document in
documents) | Combine a list of documents into a single string that might be passed further down
to a language model.
:param documents: list of documents to combine
:return: |
on_chain_error | """Run when chain errors."""
self.step += 1
self.errors += 1 | def on_chain_error(self, error: BaseException, **kwargs: Any) ->None:
"""Run when chain errors."""
self.step += 1
self.errors += 1 | Run when chain errors. |
step | """Take step."""
response = self.chain.run(**inputs, callbacks=callbacks)
return StepResponse(response=response) | def step(self, inputs: dict, callbacks: Callbacks=None, **kwargs: Any
) ->StepResponse:
"""Take step."""
response = self.chain.run(**inputs, callbacks=callbacks)
return StepResponse(response=response) | Take step. |
from_texts | """
Create and initialize a Bagel instance from list of texts.
Args:
texts (List[str]): List of text content to be added.
cluster_name (str): The name of the BagelDB cluster.
client_settings (Optional[bagel.config.Settings]): Client settings.
cluster_metadata (Optional[Dict]): Metadata of the cluster.
embeddings (Optional[Embeddings]): List of embedding.
metadatas (Optional[List[dict]]): List of metadata.
ids (Optional[List[str]]): List of unique ID. Defaults to None.
client (Optional[bagel.Client]): Bagel client instance.
Returns:
Bagel: Bagel vectorstore.
"""
bagel_cluster = cls(cluster_name=cluster_name, embedding_function=embedding,
client_settings=client_settings, client=client, cluster_metadata=
cluster_metadata, **kwargs)
_ = bagel_cluster.add_texts(texts=texts, embeddings=text_embeddings,
metadatas=metadatas, ids=ids)
return bagel_cluster | @classmethod
def from_texts(cls: Type[Bagel], texts: List[str], embedding: Optional[
Embeddings]=None, metadatas: Optional[List[dict]]=None, ids: Optional[
List[str]]=None, cluster_name: str=_LANGCHAIN_DEFAULT_CLUSTER_NAME,
client_settings: Optional[bagel.config.Settings]=None, cluster_metadata:
Optional[Dict]=None, client: Optional[bagel.Client]=None,
text_embeddings: Optional[List[List[float]]]=None, **kwargs: Any) ->Bagel:
"""
Create and initialize a Bagel instance from list of texts.
Args:
texts (List[str]): List of text content to be added.
cluster_name (str): The name of the BagelDB cluster.
client_settings (Optional[bagel.config.Settings]): Client settings.
cluster_metadata (Optional[Dict]): Metadata of the cluster.
embeddings (Optional[Embeddings]): List of embedding.
metadatas (Optional[List[dict]]): List of metadata.
ids (Optional[List[str]]): List of unique ID. Defaults to None.
client (Optional[bagel.Client]): Bagel client instance.
Returns:
Bagel: Bagel vectorstore.
"""
bagel_cluster = cls(cluster_name=cluster_name, embedding_function=
embedding, client_settings=client_settings, client=client,
cluster_metadata=cluster_metadata, **kwargs)
_ = bagel_cluster.add_texts(texts=texts, embeddings=text_embeddings,
metadatas=metadatas, ids=ids)
return bagel_cluster | Create and initialize a Bagel instance from list of texts.
Args:
texts (List[str]): List of text content to be added.
cluster_name (str): The name of the BagelDB cluster.
client_settings (Optional[bagel.config.Settings]): Client settings.
cluster_metadata (Optional[Dict]): Metadata of the cluster.
embeddings (Optional[Embeddings]): List of embedding.
metadatas (Optional[List[dict]]): List of metadata.
ids (Optional[List[str]]): List of unique ID. Defaults to None.
client (Optional[bagel.Client]): Bagel client instance.
Returns:
Bagel: Bagel vectorstore. |
test_extract_paragraphs | html2text_transformer = Html2TextTransformer()
paragraphs_html = (
'<html><h1>Header</h1><p>First paragraph.</p><p>Second paragraph.</p><h1>Ignore at end</h1></html>'
)
documents = [Document(page_content=paragraphs_html)]
docs_transformed = html2text_transformer.transform_documents(documents)
assert docs_transformed[0].page_content == """# Header
First paragraph.
Second paragraph.
# Ignore at end
""" | @pytest.mark.requires('html2text')
def test_extract_paragraphs() ->None:
html2text_transformer = Html2TextTransformer()
paragraphs_html = (
'<html><h1>Header</h1><p>First paragraph.</p><p>Second paragraph.</p><h1>Ignore at end</h1></html>'
)
documents = [Document(page_content=paragraphs_html)]
docs_transformed = html2text_transformer.transform_documents(documents)
assert docs_transformed[0].page_content == """# Header
First paragraph.
Second paragraph.
# Ignore at end
""" | null |
test_all_imports | assert set(__all__) == set(EXPECTED_ALL) | def test_all_imports() ->None:
assert set(__all__) == set(EXPECTED_ALL) | null |
from_llm | """Initialize from llm using default template.
Args:
retriever: retriever to query documents from
llm: llm for query generation using DEFAULT_QUERY_PROMPT
include_original: Whether to include the original query in the list of
generated queries.
Returns:
MultiQueryRetriever
"""
output_parser = LineListOutputParser()
llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser)
return cls(retriever=retriever, llm_chain=llm_chain, parser_key=parser_key,
include_original=include_original) | @classmethod
def from_llm(cls, retriever: BaseRetriever, llm: BaseLLM, prompt:
PromptTemplate=DEFAULT_QUERY_PROMPT, parser_key: str='lines',
include_original: bool=False) ->'MultiQueryRetriever':
"""Initialize from llm using default template.
Args:
retriever: retriever to query documents from
llm: llm for query generation using DEFAULT_QUERY_PROMPT
include_original: Whether to include the original query in the list of
generated queries.
Returns:
MultiQueryRetriever
"""
output_parser = LineListOutputParser()
llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser)
return cls(retriever=retriever, llm_chain=llm_chain, parser_key=
parser_key, include_original=include_original) | Initialize from llm using default template.
Args:
retriever: retriever to query documents from
llm: llm for query generation using DEFAULT_QUERY_PROMPT
include_original: Whether to include the original query in the list of
generated queries.
Returns:
MultiQueryRetriever |
load_schemas | """
Args:
str_schemas: string of schemas
"""
values = str_schemas.replace('(', '').replace(')', '').split(',')
schemas = []
for i in range(len(values) // 3):
schemas.append(Schema(values[i * 3].strip(), values[i * 3 + 1].strip(),
values[i * 3 + 2].strip()))
return schemas | def load_schemas(str_schemas: str) ->List[Schema]:
"""
Args:
str_schemas: string of schemas
"""
values = str_schemas.replace('(', '').replace(')', '').split(',')
schemas = []
for i in range(len(values) // 3):
schemas.append(Schema(values[i * 3].strip(), values[i * 3 + 1].
strip(), values[i * 3 + 2].strip()))
return schemas | Args:
str_schemas: string of schemas |
validate_environment_override | """Validate that api key and python package exists in environment."""
values['openai_api_key'] = get_from_dict_or_env(values, 'anyscale_api_key',
'ANYSCALE_API_KEY')
values['anyscale_api_key'] = convert_to_secret_str(get_from_dict_or_env(
values, 'anyscale_api_key', 'ANYSCALE_API_KEY'))
values['openai_api_base'] = get_from_dict_or_env(values,
'anyscale_api_base', 'ANYSCALE_API_BASE', default=DEFAULT_API_BASE)
values['openai_proxy'] = get_from_dict_or_env(values, 'anyscale_proxy',
'ANYSCALE_PROXY', default='')
try:
import openai
except ImportError as e:
raise ValueError(
'Could not import openai python package. Please install it with `pip install openai`.'
) from e
try:
if is_openai_v1():
client_params = {'api_key': values['openai_api_key'], 'base_url':
values['openai_api_base']}
values['client'] = openai.OpenAI(**client_params).chat.completions
else:
values['client'] = openai.ChatCompletion
except AttributeError as exc:
raise ValueError(
'`openai` has no `ChatCompletion` attribute, this is likely due to an old version of the openai package. Try upgrading it with `pip install --upgrade openai`.'
) from exc
if 'model_name' not in values.keys():
values['model_name'] = DEFAULT_MODEL
model_name = values['model_name']
available_models = cls.get_available_models(values['openai_api_key'],
values['openai_api_base'])
if model_name not in available_models:
raise ValueError(
f'Model name {model_name} not found in available models: {available_models}.'
)
values['available_models'] = available_models
return values | @root_validator(pre=True)
def validate_environment_override(cls, values: dict) ->dict:
"""Validate that api key and python package exists in environment."""
values['openai_api_key'] = get_from_dict_or_env(values,
'anyscale_api_key', 'ANYSCALE_API_KEY')
values['anyscale_api_key'] = convert_to_secret_str(get_from_dict_or_env
(values, 'anyscale_api_key', 'ANYSCALE_API_KEY'))
values['openai_api_base'] = get_from_dict_or_env(values,
'anyscale_api_base', 'ANYSCALE_API_BASE', default=DEFAULT_API_BASE)
values['openai_proxy'] = get_from_dict_or_env(values, 'anyscale_proxy',
'ANYSCALE_PROXY', default='')
try:
import openai
except ImportError as e:
raise ValueError(
'Could not import openai python package. Please install it with `pip install openai`.'
) from e
try:
if is_openai_v1():
client_params = {'api_key': values['openai_api_key'],
'base_url': values['openai_api_base']}
values['client'] = openai.OpenAI(**client_params).chat.completions
else:
values['client'] = openai.ChatCompletion
except AttributeError as exc:
raise ValueError(
'`openai` has no `ChatCompletion` attribute, this is likely due to an old version of the openai package. Try upgrading it with `pip install --upgrade openai`.'
) from exc
if 'model_name' not in values.keys():
values['model_name'] = DEFAULT_MODEL
model_name = values['model_name']
available_models = cls.get_available_models(values['openai_api_key'],
values['openai_api_base'])
if model_name not in available_models:
raise ValueError(
f'Model name {model_name} not found in available models: {available_models}.'
)
values['available_models'] = available_models
return values | Validate that api key and python package exists in environment. |
on_chain_error | self.on_chain_error_common() | def on_chain_error(self, *args: Any, **kwargs: Any) ->Any:
self.on_chain_error_common() | null |
on_tool_start_common | self.tool_starts += 1
self.starts += 1 | def on_tool_start_common(self) ->None:
self.tool_starts += 1
self.starts += 1 | null |
_stop | """
Stop the iterator and raise a StopIteration exception with the stopped response.
"""
logger.warning('Stopping agent prematurely due to triggering stop condition')
output = self.agent_executor.agent.return_stopped_response(self.
agent_executor.early_stopping_method, self.intermediate_steps, **self.
inputs)
return self._return(output, run_manager=run_manager) | def _stop(self, run_manager: CallbackManagerForChainRun) ->AddableDict:
"""
Stop the iterator and raise a StopIteration exception with the stopped response.
"""
logger.warning(
'Stopping agent prematurely due to triggering stop condition')
output = self.agent_executor.agent.return_stopped_response(self.
agent_executor.early_stopping_method, self.intermediate_steps, **
self.inputs)
return self._return(output, run_manager=run_manager) | Stop the iterator and raise a StopIteration exception with the stopped response. |
test_json_validity_evaluator_evaluate_invalid_json | prediction = '{"name": "John", "age": 30, "city": "New York",}'
result = json_validity_evaluator.evaluate_strings(prediction=prediction)
assert result['score'] == 0
assert result['reasoning'].startswith(
'Expecting property name enclosed in double quotes') | def test_json_validity_evaluator_evaluate_invalid_json(json_validity_evaluator:
JsonValidityEvaluator) ->None:
prediction = '{"name": "John", "age": 30, "city": "New York",}'
result = json_validity_evaluator.evaluate_strings(prediction=prediction)
assert result['score'] == 0
assert result['reasoning'].startswith(
'Expecting property name enclosed in double quotes') | null |
_llm_type | return 'koboldai' | @property
def _llm_type(self) ->str:
return 'koboldai' | null |
is_lc_serializable | """Return whether this model can be serialized by Langchain."""
return False | @classmethod
def is_lc_serializable(cls) ->bool:
"""Return whether this model can be serialized by Langchain."""
return False | Return whether this model can be serialized by Langchain. |
run | """Convenience method for executing chain.
The main difference between this method and `Chain.__call__` is that this
method expects inputs to be passed directly in as positional arguments or
keyword arguments, whereas `Chain.__call__` expects a single input dictionary
with all the inputs
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError('`run` supports only one positional argument.')
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key]
if not kwargs and not args:
raise ValueError(
'`run` supported with either positional arguments or keyword arguments, but none were provided.'
)
else:
raise ValueError(
f'`run` supported with either positional arguments or keyword arguments but not both. Got args: {args} and kwargs: {kwargs}.'
) | def run(self, *args: Any, callbacks: Callbacks=None, tags: Optional[List[
str]]=None, metadata: Optional[Dict[str, Any]]=None, **kwargs: Any) ->Any:
"""Convenience method for executing chain.
The main difference between this method and `Chain.__call__` is that this
method expects inputs to be passed directly in as positional arguments or
keyword arguments, whereas `Chain.__call__` expects a single input dictionary
with all the inputs
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError('`run` supports only one positional argument.')
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata
)[_output_key]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key]
if not kwargs and not args:
raise ValueError(
'`run` supported with either positional arguments or keyword arguments, but none were provided.'
)
else:
raise ValueError(
f'`run` supported with either positional arguments or keyword arguments but not both. Got args: {args} and kwargs: {kwargs}.'
) | Convenience method for executing chain.
The main difference between this method and `Chain.__call__` is that this
method expects inputs to be passed directly in as positional arguments or
keyword arguments, whereas `Chain.__call__` expects a single input dictionary
with all the inputs
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..." |
from_llm | llm_chain = LLMChain(llm=llm, prompt=prompt)
return cls(llm_chain=llm_chain, **kwargs) | @classmethod
def from_llm(cls, llm: BaseLanguageModel, prompt: BasePromptTemplate=PROMPT,
**kwargs: Any) ->LLMMathChain:
llm_chain = LLMChain(llm=llm, prompt=prompt)
return cls(llm_chain=llm_chain, **kwargs) | null |
similarity_search | """Same as `similarity_search_with_relevance_scores` but
doesn't return the scores.
"""
return self.similarity_search_by_vector(self._embeddings.embed_query(query),
k, distance_func, where_str, **kwargs) | def similarity_search(self, query: str, k: int=4, distance_func:
DistanceFunction=DistanceFunction.COSINE_SIM, where_str: Optional[str]=
None, **kwargs: Any) ->List[Document]:
"""Same as `similarity_search_with_relevance_scores` but
doesn't return the scores.
"""
return self.similarity_search_by_vector(self._embeddings.embed_query(
query), k, distance_func, where_str, **kwargs) | Same as `similarity_search_with_relevance_scores` but
doesn't return the scores. |
test_chat_google_palm_generate | """Test Google PaLM Chat API wrapper with generate."""
chat = ChatGooglePalm(n=2, temperature=1.0)
message = HumanMessage(content='Hello')
response = chat.generate([[message], [message]])
assert isinstance(response, LLMResult)
assert len(response.generations) == 2
for generations in response.generations:
assert len(generations) == 2
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content | def test_chat_google_palm_generate() ->None:
"""Test Google PaLM Chat API wrapper with generate."""
chat = ChatGooglePalm(n=2, temperature=1.0)
message = HumanMessage(content='Hello')
response = chat.generate([[message], [message]])
assert isinstance(response, LLMResult)
assert len(response.generations) == 2
for generations in response.generations:
assert len(generations) == 2
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content | Test Google PaLM Chat API wrapper with generate. |
test_basic_functionality | """Test basic functionality of methods exposed by class"""
combined_memory = CombinedMemory(memories=[example_memory[0],
example_memory[1]])
assert combined_memory.memory_variables == ['foo', 'bar']
assert combined_memory.load_memory_variables({}) == {'foo': '', 'bar': ''}
combined_memory.save_context({'input': 'Hello there'}, {'output':
'Hello, how can I help you?'})
assert combined_memory.load_memory_variables({}) == {'foo':
"""Human: Hello there
AI: Hello, how can I help you?""", 'bar':
"""Human: Hello there
AI: Hello, how can I help you?"""}
combined_memory.clear()
assert combined_memory.load_memory_variables({}) == {'foo': '', 'bar': ''} | def test_basic_functionality(example_memory: List[ConversationBufferMemory]
) ->None:
"""Test basic functionality of methods exposed by class"""
combined_memory = CombinedMemory(memories=[example_memory[0],
example_memory[1]])
assert combined_memory.memory_variables == ['foo', 'bar']
assert combined_memory.load_memory_variables({}) == {'foo': '', 'bar': ''}
combined_memory.save_context({'input': 'Hello there'}, {'output':
'Hello, how can I help you?'})
assert combined_memory.load_memory_variables({}) == {'foo':
"""Human: Hello there
AI: Hello, how can I help you?""", 'bar':
"""Human: Hello there
AI: Hello, how can I help you?"""}
combined_memory.clear()
assert combined_memory.load_memory_variables({}) == {'foo': '', 'bar': ''} | Test basic functionality of methods exposed by class |
draw_graphviz | """
Provides better drawing
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> self.draw_graphviz_svg(layout="dot", filename="web.svg")
>>> SVG('web.svg')
"""
from networkx.drawing.nx_agraph import to_agraph
try:
import pygraphviz
except ImportError as e:
if e.name == '_graphviz':
"""
>>> e.msg # pygraphviz throws this error
ImportError: libcgraph.so.6: cannot open shared object file
"""
raise ImportError(
'Could not import graphviz debian package. Please install it with:`sudo apt-get update``sudo apt-get install graphviz graphviz-dev`'
)
else:
raise ImportError(
'Could not import pygraphviz python package. Please install it with:`pip install pygraphviz`.'
)
graph = to_agraph(self._graph)
graph.layout(prog=kwargs.get('prog', 'dot'))
graph.draw(kwargs.get('path', 'graph.svg')) | def draw_graphviz(self, **kwargs: Any) ->None:
"""
Provides better drawing
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> self.draw_graphviz_svg(layout="dot", filename="web.svg")
>>> SVG('web.svg')
"""
from networkx.drawing.nx_agraph import to_agraph
try:
import pygraphviz
except ImportError as e:
if e.name == '_graphviz':
"""
>>> e.msg # pygraphviz throws this error
ImportError: libcgraph.so.6: cannot open shared object file
"""
raise ImportError(
'Could not import graphviz debian package. Please install it with:`sudo apt-get update``sudo apt-get install graphviz graphviz-dev`'
)
else:
raise ImportError(
'Could not import pygraphviz python package. Please install it with:`pip install pygraphviz`.'
)
graph = to_agraph(self._graph)
graph.layout(prog=kwargs.get('prog', 'dot'))
graph.draw(kwargs.get('path', 'graph.svg')) | Provides better drawing
Usage in a jupyter notebook:
>>> from IPython.display import SVG
>>> self.draw_graphviz_svg(layout="dot", filename="web.svg")
>>> SVG('web.svg') |
test_sqlitevss_with_score | """Test end to end construction and search with scores and IDs."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = _sqlite_vss_from_texts(metadatas=metadatas)
output = docsearch.similarity_search_with_score('foo', k=3)
docs = [o[0] for o in output]
distances = [o[1] for o in output]
assert docs == [Document(page_content='foo', metadata={'page': 0}),
Document(page_content='bar', metadata={'page': 1}), Document(
page_content='baz', metadata={'page': 2})]
assert distances[0] < distances[1] < distances[2] | @pytest.mark.requires('sqlite-vss')
def test_sqlitevss_with_score() ->None:
"""Test end to end construction and search with scores and IDs."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = _sqlite_vss_from_texts(metadatas=metadatas)
output = docsearch.similarity_search_with_score('foo', k=3)
docs = [o[0] for o in output]
distances = [o[1] for o in output]
assert docs == [Document(page_content='foo', metadata={'page': 0}),
Document(page_content='bar', metadata={'page': 1}), Document(
page_content='baz', metadata={'page': 2})]
assert distances[0] < distances[1] < distances[2] | Test end to end construction and search with scores and IDs. |
test_tool_with_kwargs | """Test functionality when only return direct is provided."""
@tool(return_direct=True)
def search_api(arg_0: str, arg_1: float=4.3, ping: str='hi') ->str:
"""Search the API for the query."""
return f'arg_0={arg_0}, arg_1={arg_1}, ping={ping}'
assert isinstance(search_api, BaseTool)
result = search_api.run(tool_input={'arg_0': 'foo', 'arg_1': 3.2, 'ping':
'pong'})
assert result == 'arg_0=foo, arg_1=3.2, ping=pong'
result = search_api.run(tool_input={'arg_0': 'foo'})
assert result == 'arg_0=foo, arg_1=4.3, ping=hi'
result = search_api.run('foobar')
assert result == 'arg_0=foobar, arg_1=4.3, ping=hi' | def test_tool_with_kwargs() ->None:
"""Test functionality when only return direct is provided."""
@tool(return_direct=True)
def search_api(arg_0: str, arg_1: float=4.3, ping: str='hi') ->str:
"""Search the API for the query."""
return f'arg_0={arg_0}, arg_1={arg_1}, ping={ping}'
assert isinstance(search_api, BaseTool)
result = search_api.run(tool_input={'arg_0': 'foo', 'arg_1': 3.2,
'ping': 'pong'})
assert result == 'arg_0=foo, arg_1=3.2, ping=pong'
result = search_api.run(tool_input={'arg_0': 'foo'})
assert result == 'arg_0=foo, arg_1=4.3, ping=hi'
result = search_api.run('foobar')
assert result == 'arg_0=foobar, arg_1=4.3, ping=hi' | Test functionality when only return direct is provided. |
get_lc_namespace | """Get the namespace of the langchain object."""
return ['langchain', 'prompts', 'chat'] | @classmethod
def get_lc_namespace(cls) ->List[str]:
"""Get the namespace of the langchain object."""
return ['langchain', 'prompts', 'chat'] | Get the namespace of the langchain object. |
_on_chain_start | """Process the Chain Run upon start.""" | def _on_chain_start(self, run: Run) ->None:
"""Process the Chain Run upon start.""" | Process the Chain Run upon start. |
_get_relevant_documents | try:
if self.is_arxiv_identifier(query):
results = self.arxiv_search(id_list=query.split(), max_results=self
.top_k_results).results()
else:
results = self.arxiv_search(query[:self.ARXIV_MAX_QUERY_LENGTH],
max_results=self.top_k_results).results()
except self.arxiv_exceptions as ex:
return [Document(page_content=f'Arxiv exception: {ex}')]
docs = [Document(page_content=result.summary, metadata={'Published': result
.updated.date(), 'Title': result.title, 'Authors': ', '.join(a.name for
a in result.authors)}) for result in results]
return docs | def _get_relevant_documents(self, query: str, *, run_manager:
CallbackManagerForRetrieverRun) ->List[Document]:
try:
if self.is_arxiv_identifier(query):
results = self.arxiv_search(id_list=query.split(), max_results=
self.top_k_results).results()
else:
results = self.arxiv_search(query[:self.ARXIV_MAX_QUERY_LENGTH],
max_results=self.top_k_results).results()
except self.arxiv_exceptions as ex:
return [Document(page_content=f'Arxiv exception: {ex}')]
docs = [Document(page_content=result.summary, metadata={'Published':
result.updated.date(), 'Title': result.title, 'Authors': ', '.join(
a.name for a in result.authors)}) for result in results]
return docs | null |
__init__ | """Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine) | def __init__(self, engine: Engine, cache_schema: Type[FullMd5LLMCache]=
FullMd5LLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine) | Initialize by creating all tables. |
test_redis_semantic_cache_chat | set_llm_cache(RedisSemanticCache(embedding=FakeEmbeddings(), redis_url=
REDIS_TEST_URL, score_threshold=0.1))
llm = FakeChatModel()
params = llm.dict()
params['stop'] = None
llm_string = str(sorted([(k, v) for k, v in params.items()]))
prompt: List[BaseMessage] = [HumanMessage(content='foo')]
get_llm_cache().update(dumps(prompt), llm_string, [ChatGeneration(message=
AIMessage(content='fizz'))])
output = llm.generate([prompt])
expected_output = LLMResult(generations=[[ChatGeneration(message=AIMessage(
content='fizz'))]], llm_output={})
assert output == expected_output
get_llm_cache().clear(llm_string=llm_string) | def test_redis_semantic_cache_chat() ->None:
set_llm_cache(RedisSemanticCache(embedding=FakeEmbeddings(), redis_url=
REDIS_TEST_URL, score_threshold=0.1))
llm = FakeChatModel()
params = llm.dict()
params['stop'] = None
llm_string = str(sorted([(k, v) for k, v in params.items()]))
prompt: List[BaseMessage] = [HumanMessage(content='foo')]
get_llm_cache().update(dumps(prompt), llm_string, [ChatGeneration(
message=AIMessage(content='fizz'))])
output = llm.generate([prompt])
expected_output = LLMResult(generations=[[ChatGeneration(message=
AIMessage(content='fizz'))]], llm_output={})
assert output == expected_output
get_llm_cache().clear(llm_string=llm_string) | null |
test_chroma_search_filter_with_scores | """Test end to end construction and scored search with metadata filtering."""
texts = ['far', 'bar', 'baz']
metadatas = [{'first_letter': '{}'.format(text[0])} for text in texts]
docsearch = Chroma.from_texts(collection_name='test_collection', texts=
texts, embedding=FakeEmbeddings(), metadatas=metadatas)
output = docsearch.similarity_search_with_score('far', k=1, filter={
'first_letter': 'f'})
assert output == [(Document(page_content='far', metadata={'first_letter':
'f'}), 0.0)]
output = docsearch.similarity_search_with_score('far', k=1, filter={
'first_letter': 'b'})
assert output == [(Document(page_content='bar', metadata={'first_letter':
'b'}), 1.0)] | def test_chroma_search_filter_with_scores() ->None:
"""Test end to end construction and scored search with metadata filtering."""
texts = ['far', 'bar', 'baz']
metadatas = [{'first_letter': '{}'.format(text[0])} for text in texts]
docsearch = Chroma.from_texts(collection_name='test_collection', texts=
texts, embedding=FakeEmbeddings(), metadatas=metadatas)
output = docsearch.similarity_search_with_score('far', k=1, filter={
'first_letter': 'f'})
assert output == [(Document(page_content='far', metadata={
'first_letter': 'f'}), 0.0)]
output = docsearch.similarity_search_with_score('far', k=1, filter={
'first_letter': 'b'})
assert output == [(Document(page_content='bar', metadata={
'first_letter': 'b'}), 1.0)] | Test end to end construction and scored search with metadata filtering. |
__call__ | """Correct the query to make it valid. If
Args:
query: cypher query
"""
return self.correct_query(query) | def __call__(self, query: str) ->str:
"""Correct the query to make it valid. If
Args:
query: cypher query
"""
return self.correct_query(query) | Correct the query to make it valid. If
Args:
query: cypher query |
requires_reference | """Whether this evaluator requires a reference label."""
return False | @property
def requires_reference(self) ->bool:
"""Whether this evaluator requires a reference label."""
return False | Whether this evaluator requires a reference label. |
on_agent_action | """Do nothing."""
pass | def on_agent_action(self, action: AgentAction, **kwargs: Any) ->Any:
"""Do nothing."""
pass | Do nothing. |
__init__ | """
Initialize a new LangSmithRunChatLoader instance.
:param runs: List of LLM run IDs or run objects.
:param client: An instance of LangSmith client, if not provided,
a new client instance will be created.
"""
from langsmith.client import Client
self.runs = runs
self.client = client or Client() | def __init__(self, runs: Iterable[Union[str, Run]], client: Optional[
'Client']=None):
"""
Initialize a new LangSmithRunChatLoader instance.
:param runs: List of LLM run IDs or run objects.
:param client: An instance of LangSmith client, if not provided,
a new client instance will be created.
"""
from langsmith.client import Client
self.runs = runs
self.client = client or Client() | Initialize a new LangSmithRunChatLoader instance.
:param runs: List of LLM run IDs or run objects.
:param client: An instance of LangSmith client, if not provided,
a new client instance will be created. |
test_dashscope_embedding_documents | """Test dashscope embeddings."""
documents = ['foo bar']
embedding = DashScopeEmbeddings(model='text-embedding-v1')
output = embedding.embed_documents(documents)
assert len(output) == 1
assert len(output[0]) == 1536 | def test_dashscope_embedding_documents() ->None:
"""Test dashscope embeddings."""
documents = ['foo bar']
embedding = DashScopeEmbeddings(model='text-embedding-v1')
output = embedding.embed_documents(documents)
assert len(output) == 1
assert len(output[0]) == 1536 | Test dashscope embeddings. |
__init__ | """Create an Astra DB chat message history."""
try:
from astrapy.db import AstraDB as LibAstraDB
except (ImportError, ModuleNotFoundError):
raise ImportError(
'Could not import a recent astrapy python package. Please install it with `pip install --upgrade astrapy`.'
)
if astra_db_client is not None:
if token is not None or api_endpoint is not None:
raise ValueError(
"You cannot pass 'astra_db_client' to AstraDB if passing 'token' and 'api_endpoint'."
)
self.session_id = session_id
self.collection_name = collection_name
self.token = token
self.api_endpoint = api_endpoint
self.namespace = namespace
if astra_db_client is not None:
self.astra_db = astra_db_client
else:
self.astra_db = LibAstraDB(token=self.token, api_endpoint=self.
api_endpoint, namespace=self.namespace)
self.collection = self.astra_db.create_collection(self.collection_name) | def __init__(self, *, session_id: str, collection_name: str=
DEFAULT_COLLECTION_NAME, token: Optional[str]=None, api_endpoint:
Optional[str]=None, astra_db_client: Optional[LibAstraDB]=None,
namespace: Optional[str]=None) ->None:
"""Create an Astra DB chat message history."""
try:
from astrapy.db import AstraDB as LibAstraDB
except (ImportError, ModuleNotFoundError):
raise ImportError(
'Could not import a recent astrapy python package. Please install it with `pip install --upgrade astrapy`.'
)
if astra_db_client is not None:
if token is not None or api_endpoint is not None:
raise ValueError(
"You cannot pass 'astra_db_client' to AstraDB if passing 'token' and 'api_endpoint'."
)
self.session_id = session_id
self.collection_name = collection_name
self.token = token
self.api_endpoint = api_endpoint
self.namespace = namespace
if astra_db_client is not None:
self.astra_db = astra_db_client
else:
self.astra_db = LibAstraDB(token=self.token, api_endpoint=self.
api_endpoint, namespace=self.namespace)
self.collection = self.astra_db.create_collection(self.collection_name) | Create an Astra DB chat message history. |
test_jinachat_extra_kwargs | """Test extra kwargs to chat openai."""
llm = JinaChat(foo=3, max_tokens=10)
assert llm.max_tokens == 10
assert llm.model_kwargs == {'foo': 3}
llm = JinaChat(foo=3, model_kwargs={'bar': 2})
assert llm.model_kwargs == {'foo': 3, 'bar': 2}
with pytest.raises(ValueError):
JinaChat(foo=3, model_kwargs={'foo': 2})
with pytest.raises(ValueError):
JinaChat(model_kwargs={'temperature': 0.2}) | def test_jinachat_extra_kwargs() ->None:
"""Test extra kwargs to chat openai."""
llm = JinaChat(foo=3, max_tokens=10)
assert llm.max_tokens == 10
assert llm.model_kwargs == {'foo': 3}
llm = JinaChat(foo=3, model_kwargs={'bar': 2})
assert llm.model_kwargs == {'foo': 3, 'bar': 2}
with pytest.raises(ValueError):
JinaChat(foo=3, model_kwargs={'foo': 2})
with pytest.raises(ValueError):
JinaChat(model_kwargs={'temperature': 0.2}) | Test extra kwargs to chat openai. |
test_cosine_similarity_score_threshold | expected_idxs = [(0, 0), (2, 2)]
expected_scores = [1.0, 0.93419873]
actual_idxs, actual_scores = cosine_similarity_top_k(X, Y, top_k=None,
score_threshold=0.9)
assert actual_idxs == expected_idxs
assert np.allclose(expected_scores, actual_scores) | def test_cosine_similarity_score_threshold(X: List[List[float]], Y: List[
List[float]]) ->None:
expected_idxs = [(0, 0), (2, 2)]
expected_scores = [1.0, 0.93419873]
actual_idxs, actual_scores = cosine_similarity_top_k(X, Y, top_k=None,
score_threshold=0.9)
assert actual_idxs == expected_idxs
assert np.allclose(expected_scores, actual_scores) | null |
get_lc_namespace | """Get the namespace of the langchain object."""
return ['langchain', 'schema', 'messages'] | @classmethod
def get_lc_namespace(cls) ->List[str]:
"""Get the namespace of the langchain object."""
return ['langchain', 'schema', 'messages'] | Get the namespace of the langchain object. |
_import_azure_cognitive_services_AzureCogsTextAnalyticsHealthTool | from langchain_community.tools.azure_cognitive_services import AzureCogsTextAnalyticsHealthTool
return AzureCogsTextAnalyticsHealthTool | def _import_azure_cognitive_services_AzureCogsTextAnalyticsHealthTool() ->Any:
from langchain_community.tools.azure_cognitive_services import AzureCogsTextAnalyticsHealthTool
return AzureCogsTextAnalyticsHealthTool | null |
_generate | should_stream = stream if stream is not None else self.streaming
if should_stream:
stream_iter = self._stream(messages, stop=stop, run_manager=run_manager,
**kwargs)
return generate_from_stream(stream_iter)
message_dicts, params = self._create_message_dicts(messages, stop)
params = {**params, **kwargs}
response = self.completion_with_retry(messages=message_dicts, run_manager=
run_manager, **params)
return self._create_chat_result(response) | def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]]=
None, run_manager: Optional[CallbackManagerForLLMRun]=None, stream:
Optional[bool]=None, **kwargs: Any) ->ChatResult:
should_stream = stream if stream is not None else self.streaming
if should_stream:
stream_iter = self._stream(messages, stop=stop, run_manager=
run_manager, **kwargs)
return generate_from_stream(stream_iter)
message_dicts, params = self._create_message_dicts(messages, stop)
params = {**params, **kwargs}
response = self.completion_with_retry(messages=message_dicts,
run_manager=run_manager, **params)
return self._create_chat_result(response) | null |
_parse_search_response | documents = []
for doc in response.matching_documents:
metadata = {'title': doc.document.title, 'source': doc.document.
raw_document_path}
documents.append(Document(page_content=doc.search_text_snippet,
metadata=metadata))
return documents | def _parse_search_response(self, response: 'SearchDocumentsPager') ->List[
Document]:
documents = []
for doc in response.matching_documents:
metadata = {'title': doc.document.title, 'source': doc.document.
raw_document_path}
documents.append(Document(page_content=doc.search_text_snippet,
metadata=metadata))
return documents | null |
get_prompt | """Get default prompt for a language model.""" | @abstractmethod
def get_prompt(self, llm: BaseLanguageModel) ->BasePromptTemplate:
"""Get default prompt for a language model.""" | Get default prompt for a language model. |
list | """
List all or search for available templates.
"""
from langchain_cli.utils.github import list_packages
packages = list_packages(contains=contains)
for package in packages:
typer.echo(package) | @package_cli.command()
def list(contains: Annotated[Optional[str], typer.Argument()]=None) ->None:
"""
List all or search for available templates.
"""
from langchain_cli.utils.github import list_packages
packages = list_packages(contains=contains)
for package in packages:
typer.echo(package) | List all or search for available templates. |
get_llm_kwargs | """Returns the kwargs for the LLMChain constructor.
Args:
function: The function to use.
Returns:
The kwargs for the LLMChain constructor.
"""
return {'functions': [function], 'function_call': {'name': function['name']}} | def get_llm_kwargs(function: dict) ->dict:
"""Returns the kwargs for the LLMChain constructor.
Args:
function: The function to use.
Returns:
The kwargs for the LLMChain constructor.
"""
return {'functions': [function], 'function_call': {'name': function[
'name']}} | Returns the kwargs for the LLMChain constructor.
Args:
function: The function to use.
Returns:
The kwargs for the LLMChain constructor. |
__init__ | super().__init__(criteria=criteria, normalize_by=normalize_by, **kwargs) | def __init__(self, criteria: Optional[CRITERIA_TYPE]=None, normalize_by:
Optional[float]=None, **kwargs: Any) ->None:
super().__init__(criteria=criteria, normalize_by=normalize_by, **kwargs) | null |
from_llm | """Load chain from LLM."""
combine_docs_chain_kwargs = combine_docs_chain_kwargs or {}
doc_chain = load_qa_chain(llm, chain_type=chain_type, callbacks=callbacks,
**combine_docs_chain_kwargs)
condense_question_chain = LLMChain(llm=llm, prompt=condense_question_prompt,
callbacks=callbacks)
return cls(vectorstore=vectorstore, combine_docs_chain=doc_chain,
question_generator=condense_question_chain, callbacks=callbacks, **kwargs) | @classmethod
def from_llm(cls, llm: BaseLanguageModel, vectorstore: VectorStore,
condense_question_prompt: BasePromptTemplate=CONDENSE_QUESTION_PROMPT,
chain_type: str='stuff', combine_docs_chain_kwargs: Optional[Dict]=None,
callbacks: Callbacks=None, **kwargs: Any
) ->BaseConversationalRetrievalChain:
"""Load chain from LLM."""
combine_docs_chain_kwargs = combine_docs_chain_kwargs or {}
doc_chain = load_qa_chain(llm, chain_type=chain_type, callbacks=
callbacks, **combine_docs_chain_kwargs)
condense_question_chain = LLMChain(llm=llm, prompt=
condense_question_prompt, callbacks=callbacks)
return cls(vectorstore=vectorstore, combine_docs_chain=doc_chain,
question_generator=condense_question_chain, callbacks=callbacks, **
kwargs) | Load chain from LLM. |
test_get_relevant_documents | retriever.add_texts(['Hai there!', 'Hello world!', 'Foo bar baz!'])
expected = [Document(page_content='Hai there!')]
retriever.k = 1
results = retriever.get_relevant_documents('Hai there!')
assert len(results) == retriever.k
assert results == expected
assert retriever.get_relevant_documents('Hai there!') == expected | def test_get_relevant_documents(retriever: QdrantSparseVectorRetriever) ->None:
retriever.add_texts(['Hai there!', 'Hello world!', 'Foo bar baz!'])
expected = [Document(page_content='Hai there!')]
retriever.k = 1
results = retriever.get_relevant_documents('Hai there!')
assert len(results) == retriever.k
assert results == expected
assert retriever.get_relevant_documents('Hai there!') == expected | null |
test_intervention_chain | """
Test intervention chain correctly transforms
the LLM's text completion into a setting-like object.
"""
intervention_chain = InterventionChain.from_univariate_prompt(llm=self.fake_llm
)
output = intervention_chain('if cindy has ten pets')
expected_output = {'chain_answer': None, 'chain_data': InterventionModel(
entity_settings=[EntitySettingModel(name='cindy', attribute='pet_count',
value=10)]), 'narrative_input': 'if cindy has ten pets'}
assert output == expected_output | def test_intervention_chain(self) ->None:
"""
Test intervention chain correctly transforms
the LLM's text completion into a setting-like object.
"""
intervention_chain = InterventionChain.from_univariate_prompt(llm=self.
fake_llm)
output = intervention_chain('if cindy has ten pets')
expected_output = {'chain_answer': None, 'chain_data':
InterventionModel(entity_settings=[EntitySettingModel(name='cindy',
attribute='pet_count', value=10)]), 'narrative_input':
'if cindy has ten pets'}
assert output == expected_output | Test intervention chain correctly transforms
the LLM's text completion into a setting-like object. |
_import_google_search_tool_GoogleSearchResults | from langchain_community.tools.google_search.tool import GoogleSearchResults
return GoogleSearchResults | def _import_google_search_tool_GoogleSearchResults() ->Any:
from langchain_community.tools.google_search.tool import GoogleSearchResults
return GoogleSearchResults | null |
_call | """Split document into chunks and pass to CombineDocumentsChain."""
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
document = inputs[self.input_key]
docs = self.text_splitter.create_documents([document])
other_keys: Dict = {k: v for k, v in inputs.items() if k != self.input_key}
other_keys[self.combine_docs_chain.input_key] = docs
return self.combine_docs_chain(other_keys, return_only_outputs=True,
callbacks=_run_manager.get_child()) | def _call(self, inputs: Dict[str, str], run_manager: Optional[
CallbackManagerForChainRun]=None) ->Dict[str, str]:
"""Split document into chunks and pass to CombineDocumentsChain."""
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
document = inputs[self.input_key]
docs = self.text_splitter.create_documents([document])
other_keys: Dict = {k: v for k, v in inputs.items() if k != self.input_key}
other_keys[self.combine_docs_chain.input_key] = docs
return self.combine_docs_chain(other_keys, return_only_outputs=True,
callbacks=_run_manager.get_child()) | Split document into chunks and pass to CombineDocumentsChain. |
test_move_file_errs_outside_root_dir | """Test the FileMove tool when a root dir is specified."""
with TemporaryDirectory() as temp_dir:
tool = MoveFileTool(root_dir=temp_dir)
result = tool.run({'source_path': '../source.txt', 'destination_path':
'../destination.txt'})
assert result == INVALID_PATH_TEMPLATE.format(arg_name='source_path',
value='../source.txt') | def test_move_file_errs_outside_root_dir() ->None:
"""Test the FileMove tool when a root dir is specified."""
with TemporaryDirectory() as temp_dir:
tool = MoveFileTool(root_dir=temp_dir)
result = tool.run({'source_path': '../source.txt',
'destination_path': '../destination.txt'})
assert result == INVALID_PATH_TEMPLATE.format(arg_name=
'source_path', value='../source.txt') | Test the FileMove tool when a root dir is specified. |
get_chat_model_table | feat_table = {}
for cm in chat_models.__all__:
feat_table[cm] = {}
cls = getattr(chat_models, cm)
if issubclass(cls, SimpleChatModel):
comparison_cls = SimpleChatModel
else:
comparison_cls = BaseChatModel
for feat in ('_stream', '_astream', '_agenerate'):
feat_table[cm][feat] = getattr(cls, feat) != getattr(comparison_cls,
feat)
final_feats = {k: v for k, v in {**feat_table, **
CHAT_MODEL_FEAT_TABLE_CORRECTION}.items() if k not in CHAT_MODEL_IGNORE}
header = ['model', '_agenerate', '_stream', '_astream']
title = ['Model', 'Invoke', 'Async invoke', 'Stream', 'Async stream']
rows = [title, [':-'] + [':-:'] * (len(title) - 1)]
for llm, feats in sorted(final_feats.items()):
rows += [[llm, '✅'] + [('✅' if feats.get(h) else '❌') for h in header[1:]]]
return '\n'.join(['|'.join(row) for row in rows]) | def get_chat_model_table():
feat_table = {}
for cm in chat_models.__all__:
feat_table[cm] = {}
cls = getattr(chat_models, cm)
if issubclass(cls, SimpleChatModel):
comparison_cls = SimpleChatModel
else:
comparison_cls = BaseChatModel
for feat in ('_stream', '_astream', '_agenerate'):
feat_table[cm][feat] = getattr(cls, feat) != getattr(comparison_cls
, feat)
final_feats = {k: v for k, v in {**feat_table, **
CHAT_MODEL_FEAT_TABLE_CORRECTION}.items() if k not in CHAT_MODEL_IGNORE
}
header = ['model', '_agenerate', '_stream', '_astream']
title = ['Model', 'Invoke', 'Async invoke', 'Stream', 'Async stream']
rows = [title, [':-'] + [':-:'] * (len(title) - 1)]
for llm, feats in sorted(final_feats.items()):
rows += [[llm, '✅'] + [('✅' if feats.get(h) else '❌') for h in
header[1:]]]
return '\n'.join(['|'.join(row) for row in rows]) | null |
get_format_instructions | """Instructions on how the LLM output should be formatted."""
initial = f'For your first output: {self.parsers[0].get_format_instructions()}'
subsequent = '\n'.join(
f'Complete that output fully. Then produce another output, separated by two newline characters: {p.get_format_instructions()}'
for p in self.parsers[1:])
return f"""{initial}
{subsequent}""" | def get_format_instructions(self) ->str:
"""Instructions on how the LLM output should be formatted."""
initial = (
f'For your first output: {self.parsers[0].get_format_instructions()}')
subsequent = '\n'.join(
f'Complete that output fully. Then produce another output, separated by two newline characters: {p.get_format_instructions()}'
for p in self.parsers[1:])
return f'{initial}\n{subsequent}' | Instructions on how the LLM output should be formatted. |
on_llm_end | self.saved_things['generation'] = args[0] | def on_llm_end(self, *args: Any, **kwargs: Any) ->Any:
self.saved_things['generation'] = args[0] | null |
_call | """Call the internal llm chain."""
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
return self.llm_chain(inputs, callbacks=_run_manager.get_child()) | def _call(self, inputs: Dict[str, Any], run_manager: Optional[
CallbackManagerForChainRun]=None) ->Dict[str, str]:
"""Call the internal llm chain."""
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
return self.llm_chain(inputs, callbacks=_run_manager.get_child()) | Call the internal llm chain. |
test_run_kwargs_error | """Test run method with kwargs errors as expected."""
chain = FakeChain(the_input_keys=['foo', 'bar'])
with pytest.raises(ValueError):
chain.run(foo='bar', baz='foo') | def test_run_kwargs_error() ->None:
"""Test run method with kwargs errors as expected."""
chain = FakeChain(the_input_keys=['foo', 'bar'])
with pytest.raises(ValueError):
chain.run(foo='bar', baz='foo') | Test run method with kwargs errors as expected. |