method_name
stringlengths 1
78
| method_body
stringlengths 3
9.66k
| full_code
stringlengths 31
10.7k
| docstring
stringlengths 4
4.74k
⌀ |
|---|---|---|---|
_import_interaction_tool
|
from langchain_community.tools.interaction.tool import StdInInquireTool
return StdInInquireTool
|
def _import_interaction_tool() ->Any:
from langchain_community.tools.interaction.tool import StdInInquireTool
return StdInInquireTool
| null |
assign
|
"""Assigns new fields to the dict output of this runnable.
Returns a new runnable."""
from langchain_core.runnables.passthrough import RunnableAssign
return self | RunnableAssign(RunnableParallel(kwargs))
|
def assign(self, **kwargs: Union[Runnable[Dict[str, Any], Any], Callable[[
Dict[str, Any]], Any], Mapping[str, Union[Runnable[Dict[str, Any], Any],
Callable[[Dict[str, Any]], Any]]]]) ->RunnableSerializable[Any, Any]:
"""Assigns new fields to the dict output of this runnable.
Returns a new runnable."""
from langchain_core.runnables.passthrough import RunnableAssign
return self | RunnableAssign(RunnableParallel(kwargs))
|
Assigns new fields to the dict output of this runnable.
Returns a new runnable.
|
test_pandas_output_parser_col_oob
|
try:
parser.parse_folder('row:10')
assert False, 'Should have raised OutputParserException'
except OutputParserException:
assert True
|
def test_pandas_output_parser_col_oob() ->None:
try:
parser.parse_folder('row:10')
assert False, 'Should have raised OutputParserException'
except OutputParserException:
assert True
| null |
test_solve_sudoku_k_too_small
|
"""Test simple question that should not need python."""
tot_chain = ToTChain(llm=fake_llm_sudoku, checker=SudokuChecker(), k=len(
solutions) - 1, c=4, tot_strategy_class=SampleCoTStrategy)
output = tot_chain.run({'problem_description': ''})
assert output != sudoku_solution
|
@pytest.mark.requires('jinja2')
def test_solve_sudoku_k_too_small(fake_llm_sudoku: FakeLLM) ->None:
"""Test simple question that should not need python."""
tot_chain = ToTChain(llm=fake_llm_sudoku, checker=SudokuChecker(), k=
len(solutions) - 1, c=4, tot_strategy_class=SampleCoTStrategy)
output = tot_chain.run({'problem_description': ''})
assert output != sudoku_solution
|
Test simple question that should not need python.
|
set_llm_chain
|
llm_chain = values.get('llm_chain')
llm = values.get('llm')
few_shot_template = values.get('template')
if not llm_chain:
if llm is None or few_shot_template is None:
raise ValueError(
'Both llm and few_shot_template must be provided if llm_chain is not given.'
)
values['llm_chain'] = LLMChain(llm=llm, prompt=few_shot_template)
return values
|
@root_validator(pre=False, skip_on_failure=True)
def set_llm_chain(cls, values: Dict[str, Any]) ->Dict[str, Any]:
llm_chain = values.get('llm_chain')
llm = values.get('llm')
few_shot_template = values.get('template')
if not llm_chain:
if llm is None or few_shot_template is None:
raise ValueError(
'Both llm and few_shot_template must be provided if llm_chain is not given.'
)
values['llm_chain'] = LLMChain(llm=llm, prompt=few_shot_template)
return values
| null |
ignore_chain
|
"""Whether to ignore chain callbacks."""
return self.ignore_chain_
|
@property
def ignore_chain(self) ->bool:
"""Whether to ignore chain callbacks."""
return self.ignore_chain_
|
Whether to ignore chain callbacks.
|
test_chat_ai_endpoints
|
"""Test ChatNVIDIA wrapper."""
chat = ChatNVIDIA(model='llama2_13b', temperature=0.7)
message = HumanMessage(content='Hello')
response = chat([message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
|
def test_chat_ai_endpoints() ->None:
"""Test ChatNVIDIA wrapper."""
chat = ChatNVIDIA(model='llama2_13b', temperature=0.7)
message = HumanMessage(content='Hello')
response = chat([message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
|
Test ChatNVIDIA wrapper.
|
create_review_request
|
"""
Creates a review request on *THE* open pull request
that matches the current active_branch.
Parameters:
reviewer_username(str): The username of the person who is being requested
Returns:
str: A message confirming the creation of the review request
"""
pull_requests = self.github_repo_instance.get_pulls(state='open', sort=
'created')
pr = next((pr for pr in pull_requests if pr.head.ref == self.active_branch),
None)
if pr is None:
return (
f'No open pull request found for the current branch `{self.active_branch}`'
)
try:
pr.create_review_request(reviewers=[reviewer_username])
return (
f'Review request created for user {reviewer_username} on PR #{pr.number}'
)
except Exception as e:
return f'Failed to create a review request with error {e}'
|
def create_review_request(self, reviewer_username: str) ->str:
"""
Creates a review request on *THE* open pull request
that matches the current active_branch.
Parameters:
reviewer_username(str): The username of the person who is being requested
Returns:
str: A message confirming the creation of the review request
"""
pull_requests = self.github_repo_instance.get_pulls(state='open', sort=
'created')
pr = next((pr for pr in pull_requests if pr.head.ref == self.
active_branch), None)
if pr is None:
return (
f'No open pull request found for the current branch `{self.active_branch}`'
)
try:
pr.create_review_request(reviewers=[reviewer_username])
return (
f'Review request created for user {reviewer_username} on PR #{pr.number}'
)
except Exception as e:
return f'Failed to create a review request with error {e}'
|
Creates a review request on *THE* open pull request
that matches the current active_branch.
Parameters:
reviewer_username(str): The username of the person who is being requested
Returns:
str: A message confirming the creation of the review request
|
from_llm_and_tools
|
prompt = AutoGPTPrompt(ai_name=ai_name, ai_role=ai_role, tools=tools,
input_variables=['memory', 'messages', 'goals', 'user_input'],
token_counter=llm.get_num_tokens)
human_feedback_tool = HumanInputRun() if human_in_the_loop else None
chain = LLMChain(llm=llm, prompt=prompt)
return cls(ai_name, memory, chain, output_parser or AutoGPTOutputParser(),
tools, feedback_tool=human_feedback_tool, chat_history_memory=
chat_history_memory)
|
@classmethod
def from_llm_and_tools(cls, ai_name: str, ai_role: str, memory:
VectorStoreRetriever, tools: List[BaseTool], llm: BaseChatModel,
human_in_the_loop: bool=False, output_parser: Optional[
BaseAutoGPTOutputParser]=None, chat_history_memory: Optional[
BaseChatMessageHistory]=None) ->AutoGPT:
prompt = AutoGPTPrompt(ai_name=ai_name, ai_role=ai_role, tools=tools,
input_variables=['memory', 'messages', 'goals', 'user_input'],
token_counter=llm.get_num_tokens)
human_feedback_tool = HumanInputRun() if human_in_the_loop else None
chain = LLMChain(llm=llm, prompt=prompt)
return cls(ai_name, memory, chain, output_parser or AutoGPTOutputParser
(), tools, feedback_tool=human_feedback_tool, chat_history_memory=
chat_history_memory)
| null |
test_query
|
result = self.kuzu_graph.query('MATCH (n:Movie) RETURN n.name ORDER BY n.name')
excepted_result = [{'n.name': 'The Godfather'}, {'n.name':
'The Godfather Coda: The Death of Michael Corleone'}, {'n.name':
'The Godfather: Part II'}]
self.assertEqual(result, excepted_result)
|
def test_query(self) ->None:
result = self.kuzu_graph.query(
'MATCH (n:Movie) RETURN n.name ORDER BY n.name')
excepted_result = [{'n.name': 'The Godfather'}, {'n.name':
'The Godfather Coda: The Death of Michael Corleone'}, {'n.name':
'The Godfather: Part II'}]
self.assertEqual(result, excepted_result)
| null |
build_extra
|
"""Build extra kwargs from additional params that were passed in."""
all_required_field_names = get_pydantic_field_names(cls)
extra = values.get('model_kwargs', {})
for field_name in list(values):
if field_name in extra:
raise ValueError(f'Found {field_name} supplied twice.')
if field_name not in all_required_field_names:
logger.warning(
f"""WARNING! {field_name} is not default parameter.
{field_name} was transferred to model_kwargs.
Please confirm that {field_name} is what you intended."""
)
extra[field_name] = values.pop(field_name)
invalid_model_kwargs = all_required_field_names.intersection(extra.keys())
if invalid_model_kwargs:
raise ValueError(
f'Parameters {invalid_model_kwargs} should be specified explicitly. Instead they were passed in as part of `model_kwargs` parameter.'
)
values['model_kwargs'] = extra
return values
|
@root_validator(pre=True)
def build_extra(cls, values: Dict[str, Any]) ->Dict[str, Any]:
"""Build extra kwargs from additional params that were passed in."""
all_required_field_names = get_pydantic_field_names(cls)
extra = values.get('model_kwargs', {})
for field_name in list(values):
if field_name in extra:
raise ValueError(f'Found {field_name} supplied twice.')
if field_name not in all_required_field_names:
logger.warning(
f"""WARNING! {field_name} is not default parameter.
{field_name} was transferred to model_kwargs.
Please confirm that {field_name} is what you intended."""
)
extra[field_name] = values.pop(field_name)
invalid_model_kwargs = all_required_field_names.intersection(extra.keys())
if invalid_model_kwargs:
raise ValueError(
f'Parameters {invalid_model_kwargs} should be specified explicitly. Instead they were passed in as part of `model_kwargs` parameter.'
)
values['model_kwargs'] = extra
return values
|
Build extra kwargs from additional params that were passed in.
|
test_similarity_search_with_metadata_and_additional
|
"""Test end to end construction and search with metadata and additional."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = Weaviate.from_texts(texts, embedding_openai, metadatas=
metadatas, weaviate_url=weaviate_url)
output = docsearch.similarity_search('foo', k=1, additional=['certainty'])
assert output == [Document(page_content='foo', metadata={'page': 0,
'_additional': {'certainty': 1}})]
|
@pytest.mark.vcr(ignore_localhost=True)
def test_similarity_search_with_metadata_and_additional(self, weaviate_url:
str, embedding_openai: OpenAIEmbeddings) ->None:
"""Test end to end construction and search with metadata and additional."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = Weaviate.from_texts(texts, embedding_openai, metadatas=
metadatas, weaviate_url=weaviate_url)
output = docsearch.similarity_search('foo', k=1, additional=['certainty'])
assert output == [Document(page_content='foo', metadata={'page': 0,
'_additional': {'certainty': 1}})]
|
Test end to end construction and search with metadata and additional.
|
template_is_valid
|
"""Check that prefix, suffix, and input variables are consistent."""
if values['validate_template']:
check_valid_template(values['prefix'] + values['suffix'], values[
'template_format'], values['input_variables'] + list(values[
'partial_variables']))
elif values.get('template_format'):
values['input_variables'] = [var for var in get_template_variables(
values['prefix'] + values['suffix'], values['template_format']) if
var not in values['partial_variables']]
return values
|
@root_validator()
def template_is_valid(cls, values: Dict) ->Dict:
"""Check that prefix, suffix, and input variables are consistent."""
if values['validate_template']:
check_valid_template(values['prefix'] + values['suffix'], values[
'template_format'], values['input_variables'] + list(values[
'partial_variables']))
elif values.get('template_format'):
values['input_variables'] = [var for var in get_template_variables(
values['prefix'] + values['suffix'], values['template_format']) if
var not in values['partial_variables']]
return values
|
Check that prefix, suffix, and input variables are consistent.
|
route
|
"""
Route inputs to a destination chain.
Args:
inputs: inputs to the chain
callbacks: callbacks to use for the chain
Returns:
a Route object
"""
result = self(inputs, callbacks=callbacks)
return Route(result['destination'], result['next_inputs'])
|
def route(self, inputs: Dict[str, Any], callbacks: Callbacks=None) ->Route:
"""
Route inputs to a destination chain.
Args:
inputs: inputs to the chain
callbacks: callbacks to use for the chain
Returns:
a Route object
"""
result = self(inputs, callbacks=callbacks)
return Route(result['destination'], result['next_inputs'])
|
Route inputs to a destination chain.
Args:
inputs: inputs to the chain
callbacks: callbacks to use for the chain
Returns:
a Route object
|
validate_size
|
if 'size' in values:
size = values['size']
model_name = values['model_name']
if size not in SUPPORTED_IMAGE_SIZES[model_name]:
raise RuntimeError(f'size {size} is not supported by {model_name}')
return values
|
@root_validator(pre=True)
def validate_size(cls, values: Dict) ->Dict:
if 'size' in values:
size = values['size']
model_name = values['model_name']
if size not in SUPPORTED_IMAGE_SIZES[model_name]:
raise RuntimeError(f'size {size} is not supported by {model_name}')
return values
| null |
embed_with_retry
|
"""Use tenacity to retry the embedding call."""
retry_decorator = _create_retry_decorator(embeddings)
@retry_decorator
def _embed_with_retry(**kwargs: Any) ->Any:
result = []
i = 0
input_data = kwargs['input']
while i < len(input_data):
kwargs['input'] = input_data[i:i + 25]
resp = embeddings.client.call(**kwargs)
if resp.status_code == 200:
result += resp.output['embeddings']
elif resp.status_code in [400, 401]:
raise ValueError(
f"""status_code: {resp.status_code}
code: {resp.code}
message: {resp.message}"""
)
else:
raise HTTPError(
f"""HTTP error occurred: status_code: {resp.status_code}
code: {resp.code}
message: {resp.message}"""
, response=resp)
i += 25
return result
return _embed_with_retry(**kwargs)
|
def embed_with_retry(embeddings: DashScopeEmbeddings, **kwargs: Any) ->Any:
"""Use tenacity to retry the embedding call."""
retry_decorator = _create_retry_decorator(embeddings)
@retry_decorator
def _embed_with_retry(**kwargs: Any) ->Any:
result = []
i = 0
input_data = kwargs['input']
while i < len(input_data):
kwargs['input'] = input_data[i:i + 25]
resp = embeddings.client.call(**kwargs)
if resp.status_code == 200:
result += resp.output['embeddings']
elif resp.status_code in [400, 401]:
raise ValueError(
f"""status_code: {resp.status_code}
code: {resp.code}
message: {resp.message}"""
)
else:
raise HTTPError(
f"""HTTP error occurred: status_code: {resp.status_code}
code: {resp.code}
message: {resp.message}"""
, response=resp)
i += 25
return result
return _embed_with_retry(**kwargs)
|
Use tenacity to retry the embedding call.
|
list
|
"""Returns a list of all exposed (enabled) actions associated with
current user (associated with the set api_key). Change your exposed
actions here: https://nla.zapier.com/demo/start/
The return list can be empty if no actions exposed. Else will contain
a list of action objects:
[{
"id": str,
"description": str,
"params": Dict[str, str]
}]
`params` will always contain an `instructions` key, the only required
param. All others optional and if provided will override any AI guesses
(see "understanding the AI guessing flow" here:
https://nla.zapier.com/docs/using-the-api#ai-guessing)
"""
session = self._get_session()
try:
response = session.get(self.zapier_nla_api_base + 'exposed/')
response.raise_for_status()
except requests.HTTPError as http_err:
if response.status_code == 401:
if self.zapier_nla_oauth_access_token:
raise requests.HTTPError(
f"An unauthorized response occurred. Check that your access token is correct and doesn't need to be refreshed. Err: {http_err}"
, response=response)
raise requests.HTTPError(
f'An unauthorized response occurred. Check that your api key is correct. Err: {http_err}'
, response=response)
raise http_err
return response.json()['results']
|
def list(self) ->List[Dict]:
"""Returns a list of all exposed (enabled) actions associated with
current user (associated with the set api_key). Change your exposed
actions here: https://nla.zapier.com/demo/start/
The return list can be empty if no actions exposed. Else will contain
a list of action objects:
[{
"id": str,
"description": str,
"params": Dict[str, str]
}]
`params` will always contain an `instructions` key, the only required
param. All others optional and if provided will override any AI guesses
(see "understanding the AI guessing flow" here:
https://nla.zapier.com/docs/using-the-api#ai-guessing)
"""
session = self._get_session()
try:
response = session.get(self.zapier_nla_api_base + 'exposed/')
response.raise_for_status()
except requests.HTTPError as http_err:
if response.status_code == 401:
if self.zapier_nla_oauth_access_token:
raise requests.HTTPError(
f"An unauthorized response occurred. Check that your access token is correct and doesn't need to be refreshed. Err: {http_err}"
, response=response)
raise requests.HTTPError(
f'An unauthorized response occurred. Check that your api key is correct. Err: {http_err}'
, response=response)
raise http_err
return response.json()['results']
|
Returns a list of all exposed (enabled) actions associated with
current user (associated with the set api_key). Change your exposed
actions here: https://nla.zapier.com/demo/start/
The return list can be empty if no actions exposed. Else will contain
a list of action objects:
[{
"id": str,
"description": str,
"params": Dict[str, str]
}]
`params` will always contain an `instructions` key, the only required
param. All others optional and if provided will override any AI guesses
(see "understanding the AI guessing flow" here:
https://nla.zapier.com/docs/using-the-api#ai-guessing)
|
on_llm_end
|
if self.__has_valid_config is False:
return
try:
token_usage = (response.llm_output or {}).get('token_usage', {})
parsed_output: Any = [(_parse_lc_message(generation.message) if hasattr
(generation, 'message') else generation.text) for generation in
response.generations[0]]
if len(parsed_output) == 1:
parsed_output = parsed_output[0]
self.__track_event('llm', 'end', run_id=str(run_id), parent_run_id=str(
parent_run_id) if parent_run_id else None, output=parsed_output,
token_usage={'prompt': token_usage.get('prompt_tokens'),
'completion': token_usage.get('completion_tokens')}, app_id=self.
__app_id)
except Exception as e:
logger.error(f'[LLMonitor] An error occurred in on_llm_end: {e}')
|
def on_llm_end(self, response: LLMResult, *, run_id: UUID, parent_run_id:
Union[UUID, None]=None, **kwargs: Any) ->None:
if self.__has_valid_config is False:
return
try:
token_usage = (response.llm_output or {}).get('token_usage', {})
parsed_output: Any = [(_parse_lc_message(generation.message) if
hasattr(generation, 'message') else generation.text) for
generation in response.generations[0]]
if len(parsed_output) == 1:
parsed_output = parsed_output[0]
self.__track_event('llm', 'end', run_id=str(run_id), parent_run_id=
str(parent_run_id) if parent_run_id else None, output=
parsed_output, token_usage={'prompt': token_usage.get(
'prompt_tokens'), 'completion': token_usage.get(
'completion_tokens')}, app_id=self.__app_id)
except Exception as e:
logger.error(f'[LLMonitor] An error occurred in on_llm_end: {e}')
| null |
get_num_tokens
|
"""Calculate number of tokens."""
if not self.count_tokens:
raise NameError('Please ensure the anthropic package is loaded')
return self.count_tokens(text)
|
def get_num_tokens(self, text: str) ->int:
"""Calculate number of tokens."""
if not self.count_tokens:
raise NameError('Please ensure the anthropic package is loaded')
return self.count_tokens(text)
|
Calculate number of tokens.
|
test_on_llm_end_azure_openai
|
response = LLMResult(generations=[], llm_output={'token_usage': {
'prompt_tokens': 1000, 'completion_tokens': 1000, 'total_tokens': 2000},
'model_name': model_name})
handler.on_llm_end(response)
assert handler.total_cost == expected_cost
|
@pytest.mark.parametrize('model_name,expected_cost', [('gpt-35-turbo',
0.0035), ('gpt-35-turbo-0301', 0.0035), ('gpt-35-turbo-0613', 0.0035),
('gpt-35-turbo-16k-0613', 0.007), ('gpt-35-turbo-16k', 0.007), ('gpt-4',
0.09), ('gpt-4-0314', 0.09), ('gpt-4-0613', 0.09), ('gpt-4-32k', 0.18),
('gpt-4-32k-0314', 0.18), ('gpt-4-32k-0613', 0.18)])
def test_on_llm_end_azure_openai(handler: OpenAICallbackHandler, model_name:
str, expected_cost: float) ->None:
response = LLMResult(generations=[], llm_output={'token_usage': {
'prompt_tokens': 1000, 'completion_tokens': 1000, 'total_tokens':
2000}, 'model_name': model_name})
handler.on_llm_end(response)
assert handler.total_cost == expected_cost
| null |
test_promptlayer_chat_openai_streaming
|
"""Test that streaming correctly invokes on_llm_new_token callback."""
callback_handler = FakeCallbackHandler()
callback_manager = CallbackManager([callback_handler])
chat = PromptLayerChatOpenAI(max_tokens=10, streaming=True, temperature=0,
callback_manager=callback_manager, verbose=True)
message = HumanMessage(content='Hello')
response = chat([message])
assert callback_handler.llm_streams > 0
assert isinstance(response, BaseMessage)
|
def test_promptlayer_chat_openai_streaming() ->None:
"""Test that streaming correctly invokes on_llm_new_token callback."""
callback_handler = FakeCallbackHandler()
callback_manager = CallbackManager([callback_handler])
chat = PromptLayerChatOpenAI(max_tokens=10, streaming=True, temperature
=0, callback_manager=callback_manager, verbose=True)
message = HumanMessage(content='Hello')
response = chat([message])
assert callback_handler.llm_streams > 0
assert isinstance(response, BaseMessage)
|
Test that streaming correctly invokes on_llm_new_token callback.
|
add_texts_with_embeddings
|
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: List of strings to add to the vectorstore.
embs: List of lists of floats with text embeddings for texts.
metadatas: Optional list of metadata associated with the texts.
Returns:
List of ids from adding the texts into the vectorstore.
"""
ids = [uuid.uuid4().hex for _ in texts]
values_dict: Dict[str, List[Any]] = {self.content_field: texts, self.
doc_id_field: ids}
if not metadatas:
metadatas = []
len_diff = len(ids) - len(metadatas)
add_meta = [None for _ in range(0, len_diff)]
metadatas = [(m if m is not None else {}) for m in metadatas + add_meta]
values_dict[self.metadata_field] = metadatas
values_dict[self.text_embedding_field] = embs
self._persist(values_dict)
return ids
|
def add_texts_with_embeddings(self, texts: List[str], embs: List[List[float
]], metadatas: Optional[List[dict]]=None, **kwargs: Any) ->List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: List of strings to add to the vectorstore.
embs: List of lists of floats with text embeddings for texts.
metadatas: Optional list of metadata associated with the texts.
Returns:
List of ids from adding the texts into the vectorstore.
"""
ids = [uuid.uuid4().hex for _ in texts]
values_dict: Dict[str, List[Any]] = {self.content_field: texts, self.
doc_id_field: ids}
if not metadatas:
metadatas = []
len_diff = len(ids) - len(metadatas)
add_meta = [None for _ in range(0, len_diff)]
metadatas = [(m if m is not None else {}) for m in metadatas + add_meta]
values_dict[self.metadata_field] = metadatas
values_dict[self.text_embedding_field] = embs
self._persist(values_dict)
return ids
|
Run more texts through the embeddings and add to the vectorstore.
Args:
texts: List of strings to add to the vectorstore.
embs: List of lists of floats with text embeddings for texts.
metadatas: Optional list of metadata associated with the texts.
Returns:
List of ids from adding the texts into the vectorstore.
|
_identifying_params
|
return {}
|
@property
def _identifying_params(self) ->Dict[str, Any]:
return {}
| null |
similarity_search_by_vector
|
result = self.similarity_search_by_vector_with_relevance_scores(embedding,
k=k, filter=filter, **kwargs)
documents = [doc for doc, _ in result]
return documents
|
def similarity_search_by_vector(self, embedding: List[float], k: int=4,
filter: Optional[Dict[str, Any]]=None, **kwargs: Any) ->List[Document]:
result = self.similarity_search_by_vector_with_relevance_scores(embedding,
k=k, filter=filter, **kwargs)
documents = [doc for doc, _ in result]
return documents
| null |
check_if_answer_reached
|
if self.strip_tokens:
return self.last_tokens_stripped == self.answer_prefix_tokens_stripped
else:
return self.last_tokens == self.answer_prefix_tokens
|
def check_if_answer_reached(self) ->bool:
if self.strip_tokens:
return self.last_tokens_stripped == self.answer_prefix_tokens_stripped
else:
return self.last_tokens == self.answer_prefix_tokens
| null |
_run
|
try:
source_path_ = self.get_relative_path(source_path)
except FileValidationError:
return INVALID_PATH_TEMPLATE.format(arg_name='source_path', value=
source_path)
try:
destination_path_ = self.get_relative_path(destination_path)
except FileValidationError:
return INVALID_PATH_TEMPLATE.format(arg_name='destination_path', value=
destination_path)
try:
shutil.copy2(source_path_, destination_path_, follow_symlinks=False)
return (
f'File copied successfully from {source_path} to {destination_path}.')
except Exception as e:
return 'Error: ' + str(e)
|
def _run(self, source_path: str, destination_path: str, run_manager:
Optional[CallbackManagerForToolRun]=None) ->str:
try:
source_path_ = self.get_relative_path(source_path)
except FileValidationError:
return INVALID_PATH_TEMPLATE.format(arg_name='source_path', value=
source_path)
try:
destination_path_ = self.get_relative_path(destination_path)
except FileValidationError:
return INVALID_PATH_TEMPLATE.format(arg_name='destination_path',
value=destination_path)
try:
shutil.copy2(source_path_, destination_path_, follow_symlinks=False)
return (
f'File copied successfully from {source_path} to {destination_path}.'
)
except Exception as e:
return 'Error: ' + str(e)
| null |
__init__
|
"""
Args:
file_path: The path to the Microsoft Excel file.
mode: The mode to use when partitioning the file. See unstructured docs
for more info. Optional. Defaults to "single".
**unstructured_kwargs: Keyword arguments to pass to unstructured.
"""
validate_unstructured_version(min_unstructured_version='0.6.7')
super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
|
def __init__(self, file_path: str, mode: str='single', **
unstructured_kwargs: Any):
"""
Args:
file_path: The path to the Microsoft Excel file.
mode: The mode to use when partitioning the file. See unstructured docs
for more info. Optional. Defaults to "single".
**unstructured_kwargs: Keyword arguments to pass to unstructured.
"""
validate_unstructured_version(min_unstructured_version='0.6.7')
super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
|
Args:
file_path: The path to the Microsoft Excel file.
mode: The mode to use when partitioning the file. See unstructured docs
for more info. Optional. Defaults to "single".
**unstructured_kwargs: Keyword arguments to pass to unstructured.
|
_import_graphql_tool
|
from langchain_community.tools.graphql.tool import BaseGraphQLTool
return BaseGraphQLTool
|
def _import_graphql_tool() ->Any:
from langchain_community.tools.graphql.tool import BaseGraphQLTool
return BaseGraphQLTool
| null |
_build_query_sql
|
q_emb_str = ','.join(map(str, q_emb))
if where_str:
where_str = f'PREWHERE {where_str}'
else:
where_str = ''
settings_strs = []
if self.config.index_query_params:
for k in self.config.index_query_params:
settings_strs.append(f'SETTING {k}={self.config.index_query_params[k]}'
)
q_str = f"""
SELECT {self.config.column_map['document']},
{self.config.column_map['metadata']}, dist
FROM {self.config.database}.{self.config.table}
{where_str}
ORDER BY L2Distance({self.config.column_map['embedding']}, [{q_emb_str}])
AS dist {self.dist_order}
LIMIT {topk} {' '.join(settings_strs)}
"""
return q_str
|
def _build_query_sql(self, q_emb: List[float], topk: int, where_str:
Optional[str]=None) ->str:
q_emb_str = ','.join(map(str, q_emb))
if where_str:
where_str = f'PREWHERE {where_str}'
else:
where_str = ''
settings_strs = []
if self.config.index_query_params:
for k in self.config.index_query_params:
settings_strs.append(
f'SETTING {k}={self.config.index_query_params[k]}')
q_str = f"""
SELECT {self.config.column_map['document']},
{self.config.column_map['metadata']}, dist
FROM {self.config.database}.{self.config.table}
{where_str}
ORDER BY L2Distance({self.config.column_map['embedding']}, [{q_emb_str}])
AS dist {self.dist_order}
LIMIT {topk} {' '.join(settings_strs)}
"""
return q_str
| null |
test_similarity_search_with_approx_infer_instack
|
"""test end to end with approx retrieval strategy and inference in-stack"""
docsearch = ElasticsearchStore(index_name=index_name, strategy=
ElasticsearchStore.ApproxRetrievalStrategy(query_model_id=
'sentence-transformers__all-minilm-l6-v2'), query_field='text_field',
vector_query_field='vector_query_field.predicted_value', **
elasticsearch_connection)
docsearch.client.ingest.put_pipeline(id='test_pipeline', processors=[{
'inference': {'model_id': 'sentence-transformers__all-minilm-l6-v2',
'field_map': {'query_field': 'text_field'}, 'target_field':
'vector_query_field'}}])
docsearch.client.indices.create(index=index_name, mappings={'properties': {
'text_field': {'type': 'text'}, 'vector_query_field': {'properties': {
'predicted_value': {'type': 'dense_vector', 'dims': 384, 'index': True,
'similarity': 'l2_norm'}}}}}, settings={'index': {'default_pipeline':
'test_pipeline'}})
texts = ['foo', 'bar', 'baz']
for i, text in enumerate(texts):
docsearch.client.create(index=index_name, id=str(i), document={
'text_field': text, 'metadata': {}})
docsearch.client.indices.refresh(index=index_name)
def assert_query(query_body: dict, query: str) ->dict:
assert query_body == {'knn': {'filter': [], 'field':
'vector_query_field.predicted_value', 'k': 1, 'num_candidates': 50,
'query_vector_builder': {'text_embedding': {'model_id':
'sentence-transformers__all-minilm-l6-v2', 'model_text': 'foo'}}}}
return query_body
output = docsearch.similarity_search('foo', k=1, custom_query=assert_query)
assert output == [Document(page_content='foo')]
output = docsearch.similarity_search('bar', k=1)
assert output == [Document(page_content='bar')]
|
@pytest.mark.skipif('sentence-transformers__all-minilm-l6-v2' not in
modelsDeployed, reason=
'Sentence Transformers model not deployed in ML Node, skipping test')
def test_similarity_search_with_approx_infer_instack(self,
elasticsearch_connection: dict, index_name: str) ->None:
"""test end to end with approx retrieval strategy and inference in-stack"""
docsearch = ElasticsearchStore(index_name=index_name, strategy=
ElasticsearchStore.ApproxRetrievalStrategy(query_model_id=
'sentence-transformers__all-minilm-l6-v2'), query_field=
'text_field', vector_query_field=
'vector_query_field.predicted_value', **elasticsearch_connection)
docsearch.client.ingest.put_pipeline(id='test_pipeline', processors=[{
'inference': {'model_id': 'sentence-transformers__all-minilm-l6-v2',
'field_map': {'query_field': 'text_field'}, 'target_field':
'vector_query_field'}}])
docsearch.client.indices.create(index=index_name, mappings={
'properties': {'text_field': {'type': 'text'}, 'vector_query_field':
{'properties': {'predicted_value': {'type': 'dense_vector', 'dims':
384, 'index': True, 'similarity': 'l2_norm'}}}}}, settings={'index':
{'default_pipeline': 'test_pipeline'}})
texts = ['foo', 'bar', 'baz']
for i, text in enumerate(texts):
docsearch.client.create(index=index_name, id=str(i), document={
'text_field': text, 'metadata': {}})
docsearch.client.indices.refresh(index=index_name)
def assert_query(query_body: dict, query: str) ->dict:
assert query_body == {'knn': {'filter': [], 'field':
'vector_query_field.predicted_value', 'k': 1, 'num_candidates':
50, 'query_vector_builder': {'text_embedding': {'model_id':
'sentence-transformers__all-minilm-l6-v2', 'model_text': 'foo'}}}}
return query_body
output = docsearch.similarity_search('foo', k=1, custom_query=assert_query)
assert output == [Document(page_content='foo')]
output = docsearch.similarity_search('bar', k=1)
assert output == [Document(page_content='bar')]
|
test end to end with approx retrieval strategy and inference in-stack
|
extract_between_tags
|
ext_list = re.findall(f'<{tag}\\s?>(.+?)</{tag}\\s?>', string, re.DOTALL)
if strip:
ext_list = [e.strip() for e in ext_list]
if ext_list:
if len(ext_list) != 1:
raise ValueError
return ext_list[0]
|
def extract_between_tags(tag: str, string: str, strip: bool=True) ->str:
ext_list = re.findall(f'<{tag}\\s?>(.+?)</{tag}\\s?>', string, re.DOTALL)
if strip:
ext_list = [e.strip() for e in ext_list]
if ext_list:
if len(ext_list) != 1:
raise ValueError
return ext_list[0]
| null |
test_all_imports
|
assert set(__all__) == set(EXPECTED_ALL)
|
def test_all_imports() ->None:
assert set(__all__) == set(EXPECTED_ALL)
| null |
requires_reference
|
"""Returns whether the evaluator requires reference."""
return True
|
@property
def requires_reference(self) ->bool:
"""Returns whether the evaluator requires reference."""
return True
|
Returns whether the evaluator requires reference.
|
_get_summary
|
try:
response = self.client.get_propertygraph_summary()
except Exception as e:
raise NeptuneQueryException({'message':
'Summary API is not available for this instance of Neptune,ensure the engine version is >=1.2.1.0'
, 'details': str(e)})
try:
summary = response['payload']['graphSummary']
except Exception:
raise NeptuneQueryException({'message':
'Summary API did not return a valid response.', 'details': response
.content.decode()})
else:
return summary
|
def _get_summary(self) ->Dict:
try:
response = self.client.get_propertygraph_summary()
except Exception as e:
raise NeptuneQueryException({'message':
'Summary API is not available for this instance of Neptune,ensure the engine version is >=1.2.1.0'
, 'details': str(e)})
try:
summary = response['payload']['graphSummary']
except Exception:
raise NeptuneQueryException({'message':
'Summary API did not return a valid response.', 'details':
response.content.decode()})
else:
return summary
| null |
_get_elements
|
"""Get elements matching the given CSS selector."""
elements = page.query_selector_all(selector)
results = []
for element in elements:
result = {}
for attribute in attributes:
if attribute == 'innerText':
val: Optional[str] = element.inner_text()
else:
val = element.get_attribute(attribute)
if val is not None and val.strip() != '':
result[attribute] = val
if result:
results.append(result)
return results
|
def _get_elements(page: SyncPage, selector: str, attributes: Sequence[str]
) ->List[dict]:
"""Get elements matching the given CSS selector."""
elements = page.query_selector_all(selector)
results = []
for element in elements:
result = {}
for attribute in attributes:
if attribute == 'innerText':
val: Optional[str] = element.inner_text()
else:
val = element.get_attribute(attribute)
if val is not None and val.strip() != '':
result[attribute] = val
if result:
results.append(result)
return results
|
Get elements matching the given CSS selector.
|
synthetic_data_generator
|
return create_openai_data_generator(output_schema=MedicalBilling, llm=
ChatOpenAI(temperature=1), prompt=prompt_template)
|
@pytest.fixture(scope='function')
def synthetic_data_generator() ->SyntheticDataGenerator:
return create_openai_data_generator(output_schema=MedicalBilling, llm=
ChatOpenAI(temperature=1), prompt=prompt_template)
| null |
get_template_variables
|
"""Get the variables from the template.
Args:
template: The template string.
template_format: The template format. Should be one of "f-string" or "jinja2".
Returns:
The variables from the template.
Raises:
ValueError: If the template format is not supported.
"""
if template_format == 'jinja2':
input_variables = _get_jinja2_variables_from_template(template)
elif template_format == 'f-string':
input_variables = {v for _, v, _, _ in Formatter().parse(template) if v
is not None}
else:
raise ValueError(f'Unsupported template format: {template_format}')
return sorted(input_variables)
|
def get_template_variables(template: str, template_format: str) ->List[str]:
"""Get the variables from the template.
Args:
template: The template string.
template_format: The template format. Should be one of "f-string" or "jinja2".
Returns:
The variables from the template.
Raises:
ValueError: If the template format is not supported.
"""
if template_format == 'jinja2':
input_variables = _get_jinja2_variables_from_template(template)
elif template_format == 'f-string':
input_variables = {v for _, v, _, _ in Formatter().parse(template) if
v is not None}
else:
raise ValueError(f'Unsupported template format: {template_format}')
return sorted(input_variables)
|
Get the variables from the template.
Args:
template: The template string.
template_format: The template format. Should be one of "f-string" or "jinja2".
Returns:
The variables from the template.
Raises:
ValueError: If the template format is not supported.
|
input_keys
|
"""Return the input keys.
:meta private:
"""
return list(set(self.llm_chain.input_keys) - {'agent_scratchpad'})
|
@property
def input_keys(self) ->List[str]:
"""Return the input keys.
:meta private:
"""
return list(set(self.llm_chain.input_keys) - {'agent_scratchpad'})
|
Return the input keys.
:meta private:
|
return_node_list
|
"""
Returns the nodes as a list of Node objects.
Each Node object will have its ID, type, and properties populated.
Returns:
List[Node]: A list of Node objects.
"""
nodes = [Node(id=key[0], type=key[1], properties=self.nodes[key]) for key in
self.nodes]
return nodes
|
def return_node_list(self) ->List[Node]:
"""
Returns the nodes as a list of Node objects.
Each Node object will have its ID, type, and properties populated.
Returns:
List[Node]: A list of Node objects.
"""
nodes = [Node(id=key[0], type=key[1], properties=self.nodes[key]) for
key in self.nodes]
return nodes
|
Returns the nodes as a list of Node objects.
Each Node object will have its ID, type, and properties populated.
Returns:
List[Node]: A list of Node objects.
|
roundtrip
|
"""Parse a file and pretty-print it to output.
The output is formatted as valid Python source code.
Args:
filename: The name of the file to parse.
output: The output stream to write to.
"""
with open(filename, 'rb') as pyfile:
encoding = tokenize.detect_encoding(pyfile.readline)[0]
with open(filename, 'r', encoding=encoding) as pyfile:
source = pyfile.read()
tree = compile(source, filename, 'exec', ast.PyCF_ONLY_AST)
Unparser(tree, output)
|
def roundtrip(filename, output=sys.stdout):
"""Parse a file and pretty-print it to output.
The output is formatted as valid Python source code.
Args:
filename: The name of the file to parse.
output: The output stream to write to.
"""
with open(filename, 'rb') as pyfile:
encoding = tokenize.detect_encoding(pyfile.readline)[0]
with open(filename, 'r', encoding=encoding) as pyfile:
source = pyfile.read()
tree = compile(source, filename, 'exec', ast.PyCF_ONLY_AST)
Unparser(tree, output)
|
Parse a file and pretty-print it to output.
The output is formatted as valid Python source code.
Args:
filename: The name of the file to parse.
output: The output stream to write to.
|
persist
|
"""Persist the collection.
This can be used to explicitly persist the data to disk.
It will also be called automatically when the object is destroyed.
"""
if self._persist_directory is None:
raise ValueError(
'You must specify a persist_directory oncreation to persist the collection.'
)
import chromadb
major, minor, _ = chromadb.__version__.split('.')
if int(major) == 0 and int(minor) < 4:
self._client.persist()
|
def persist(self) ->None:
"""Persist the collection.
This can be used to explicitly persist the data to disk.
It will also be called automatically when the object is destroyed.
"""
if self._persist_directory is None:
raise ValueError(
'You must specify a persist_directory oncreation to persist the collection.'
)
import chromadb
major, minor, _ = chromadb.__version__.split('.')
if int(major) == 0 and int(minor) < 4:
self._client.persist()
|
Persist the collection.
This can be used to explicitly persist the data to disk.
It will also be called automatically when the object is destroyed.
|
_completion_with_retry
|
return _make_request(llm, **_kwargs)
|
@retry_decorator
def _completion_with_retry(**_kwargs: Any) ->Any:
return _make_request(llm, **_kwargs)
| null |
get_lc_namespace
|
"""Get the namespace of the langchain object."""
return ['langchain', 'llms', 'openai']
|
@classmethod
def get_lc_namespace(cls) ->List[str]:
"""Get the namespace of the langchain object."""
return ['langchain', 'llms', 'openai']
|
Get the namespace of the langchain object.
|
similarity_search
|
"""Return Vectara documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
any other querying variable in VectaraQueryConfig
Returns:
List of Documents most similar to the query
"""
docs_and_scores = self.similarity_search_with_score(query, **kwargs)
return [doc for doc, _ in docs_and_scores]
|
def similarity_search(self, query: str, **kwargs: Any) ->List[Document]:
"""Return Vectara documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
any other querying variable in VectaraQueryConfig
Returns:
List of Documents most similar to the query
"""
docs_and_scores = self.similarity_search_with_score(query, **kwargs)
return [doc for doc, _ in docs_and_scores]
|
Return Vectara documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
any other querying variable in VectaraQueryConfig
Returns:
List of Documents most similar to the query
|
mock_now
|
"""Context manager for mocking out datetime.now() in unit tests.
Example:
with mock_now(datetime.datetime(2011, 2, 3, 10, 11)):
assert datetime.datetime.now() == datetime.datetime(2011, 2, 3, 10, 11)
"""
class MockDateTime(datetime.datetime):
"""Mock datetime.datetime.now() with a fixed datetime."""
@classmethod
def now(cls):
return datetime.datetime(dt_value.year, dt_value.month, dt_value.
day, dt_value.hour, dt_value.minute, dt_value.second, dt_value.
microsecond, dt_value.tzinfo)
real_datetime = datetime.datetime
datetime.datetime = MockDateTime
try:
yield datetime.datetime
finally:
datetime.datetime = real_datetime
|
@contextlib.contextmanager
def mock_now(dt_value):
"""Context manager for mocking out datetime.now() in unit tests.
Example:
with mock_now(datetime.datetime(2011, 2, 3, 10, 11)):
assert datetime.datetime.now() == datetime.datetime(2011, 2, 3, 10, 11)
"""
class MockDateTime(datetime.datetime):
"""Mock datetime.datetime.now() with a fixed datetime."""
@classmethod
def now(cls):
return datetime.datetime(dt_value.year, dt_value.month,
dt_value.day, dt_value.hour, dt_value.minute, dt_value.
second, dt_value.microsecond, dt_value.tzinfo)
real_datetime = datetime.datetime
datetime.datetime = MockDateTime
try:
yield datetime.datetime
finally:
datetime.datetime = real_datetime
|
Context manager for mocking out datetime.now() in unit tests.
Example:
with mock_now(datetime.datetime(2011, 2, 3, 10, 11)):
assert datetime.datetime.now() == datetime.datetime(2011, 2, 3, 10, 11)
|
inputs
|
return self._inputs
|
@property
def inputs(self) ->Dict[str, str]:
return self._inputs
| null |
_ddgs_text
|
"""Run query through DuckDuckGo text search and return results."""
from duckduckgo_search import DDGS
with DDGS() as ddgs:
ddgs_gen = ddgs.text(query, region=self.region, safesearch=self.
safesearch, timelimit=self.time, max_results=max_results or self.
max_results, backend=self.backend)
if ddgs_gen:
return [r for r in ddgs_gen]
return []
|
def _ddgs_text(self, query: str, max_results: Optional[int]=None) ->List[Dict
[str, str]]:
"""Run query through DuckDuckGo text search and return results."""
from duckduckgo_search import DDGS
with DDGS() as ddgs:
ddgs_gen = ddgs.text(query, region=self.region, safesearch=self.
safesearch, timelimit=self.time, max_results=max_results or
self.max_results, backend=self.backend)
if ddgs_gen:
return [r for r in ddgs_gen]
return []
|
Run query through DuckDuckGo text search and return results.
|
output_keys
|
_output_keys = [self.output_key]
return _output_keys
|
@property
def output_keys(self) ->List[str]:
_output_keys = [self.output_key]
return _output_keys
| null |
embed_documents
|
"""Compute doc embeddings using a HuggingFace instruct model.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
instruction_pairs = []
for text in texts:
instruction_pairs.append([self.embed_instruction, text])
embeddings = self.client(self.pipeline_ref, instruction_pairs)
return embeddings.tolist()
|
def embed_documents(self, texts: List[str]) ->List[List[float]]:
"""Compute doc embeddings using a HuggingFace instruct model.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
instruction_pairs = []
for text in texts:
instruction_pairs.append([self.embed_instruction, text])
embeddings = self.client(self.pipeline_ref, instruction_pairs)
return embeddings.tolist()
|
Compute doc embeddings using a HuggingFace instruct model.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
|
__init__
|
"""Create a new NebulaGraph wrapper instance."""
try:
import nebula3
import pandas
except ImportError:
raise ValueError(
'Please install NebulaGraph Python client and pandas first: `pip install nebula3-python pandas`'
)
self.username = username
self.password = password
self.address = address
self.port = port
self.space = space
self.session_pool_size = session_pool_size
self.session_pool = self._get_session_pool()
self.schema = ''
try:
self.refresh_schema()
except Exception as e:
raise ValueError(f'Could not refresh schema. Error: {e}')
|
def __init__(self, space: str, username: str='root', password: str='nebula',
address: str='127.0.0.1', port: int=9669, session_pool_size: int=30
) ->None:
"""Create a new NebulaGraph wrapper instance."""
try:
import nebula3
import pandas
except ImportError:
raise ValueError(
'Please install NebulaGraph Python client and pandas first: `pip install nebula3-python pandas`'
)
self.username = username
self.password = password
self.address = address
self.port = port
self.space = space
self.session_pool_size = session_pool_size
self.session_pool = self._get_session_pool()
self.schema = ''
try:
self.refresh_schema()
except Exception as e:
raise ValueError(f'Could not refresh schema. Error: {e}')
|
Create a new NebulaGraph wrapper instance.
|
uppercase_strings
|
return v.upper()
|
@validator('algorithm', 'datatype', 'distance_metric', pre=True, each_item=True
)
def uppercase_strings(cls, v: str) ->str:
return v.upper()
| null |
test_sim_search_by_vector
|
"""Test end to end construction and similarity search by vector."""
in_memory_vec_store = DocArrayInMemorySearch.from_texts(texts=texts,
embedding=FakeEmbeddings(), metric=metric)
embedding = [1.0] * 10
output = in_memory_vec_store.similarity_search_by_vector(embedding, k=1)
assert output == [Document(page_content='bar')]
|
@pytest.mark.parametrize('metric', ['cosine_sim', 'euclidean_dist',
'sqeuclidean_dist'])
def test_sim_search_by_vector(metric: str, texts: List[str]) ->None:
"""Test end to end construction and similarity search by vector."""
in_memory_vec_store = DocArrayInMemorySearch.from_texts(texts=texts,
embedding=FakeEmbeddings(), metric=metric)
embedding = [1.0] * 10
output = in_memory_vec_store.similarity_search_by_vector(embedding, k=1)
assert output == [Document(page_content='bar')]
|
Test end to end construction and similarity search by vector.
|
add_prompts_generations
|
tasks = []
prompts = self.payload[run_id]['prompts']
model_version = self.payload[run_id]['kwargs'].get('invocation_params', {}
).get('model_name')
for prompt, generation in zip(prompts, generations):
tasks.append({'data': {self.value: prompt, 'run_id': run_id},
'predictions': [{'result': [{'from_name': self.from_name, 'to_name':
self.to_name, 'type': 'textarea', 'value': {'text': [g.text for g in
generation]}}], 'model_version': model_version}]})
self.ls_project.import_tasks(tasks)
|
def add_prompts_generations(self, run_id: str, generations: List[List[
Generation]]) ->None:
tasks = []
prompts = self.payload[run_id]['prompts']
model_version = self.payload[run_id]['kwargs'].get('invocation_params', {}
).get('model_name')
for prompt, generation in zip(prompts, generations):
tasks.append({'data': {self.value: prompt, 'run_id': run_id},
'predictions': [{'result': [{'from_name': self.from_name,
'to_name': self.to_name, 'type': 'textarea', 'value': {'text':
[g.text for g in generation]}}], 'model_version': model_version}]})
self.ls_project.import_tasks(tasks)
| null |
_get_length_based
|
return len(re.split('\n| ', text))
|
def _get_length_based(text: str) ->int:
return len(re.split('\n| ', text))
| null |
get_lc_namespace
|
"""Get the namespace of the langchain object."""
return ['langchain', 'schema', 'runnable']
|
@classmethod
def get_lc_namespace(cls) ->List[str]:
"""Get the namespace of the langchain object."""
return ['langchain', 'schema', 'runnable']
|
Get the namespace of the langchain object.
|
arcgis_mocks
|
sys_modules = {'arcgis': MagicMock(), 'arcgis.features.FeatureLayer':
mock_feature_layer, 'arcgis.gis.GIS': mock_gis}
with patch.dict('sys.modules', sys_modules):
yield
|
@pytest.fixture
def arcgis_mocks(mock_feature_layer, mock_gis):
sys_modules = {'arcgis': MagicMock(), 'arcgis.features.FeatureLayer':
mock_feature_layer, 'arcgis.gis.GIS': mock_gis}
with patch.dict('sys.modules', sys_modules):
yield
| null |
format
|
"""Format the prompt template.
Args:
**kwargs: Keyword arguments to use for formatting.
Returns:
Formatted message.
"""
text = self.prompt.format(**kwargs)
return ChatMessage(content=text, role=self.role, additional_kwargs=self.
additional_kwargs)
|
def format(self, **kwargs: Any) ->BaseMessage:
"""Format the prompt template.
Args:
**kwargs: Keyword arguments to use for formatting.
Returns:
Formatted message.
"""
text = self.prompt.format(**kwargs)
return ChatMessage(content=text, role=self.role, additional_kwargs=self
.additional_kwargs)
|
Format the prompt template.
Args:
**kwargs: Keyword arguments to use for formatting.
Returns:
Formatted message.
|
test_structured_args
|
"""Test functionality with structured arguments."""
structured_api = _MockStructuredTool()
assert isinstance(structured_api, BaseTool)
assert structured_api.name == 'structured_api'
expected_result = "1 True {'foo': 'bar'}"
args = {'arg1': 1, 'arg2': True, 'arg3': {'foo': 'bar'}}
assert structured_api.run(args) == expected_result
|
def test_structured_args() ->None:
"""Test functionality with structured arguments."""
structured_api = _MockStructuredTool()
assert isinstance(structured_api, BaseTool)
assert structured_api.name == 'structured_api'
expected_result = "1 True {'foo': 'bar'}"
args = {'arg1': 1, 'arg2': True, 'arg3': {'foo': 'bar'}}
assert structured_api.run(args) == expected_result
|
Test functionality with structured arguments.
|
_log_conversation
|
"""Log the conversation to the context API."""
if len(self.messages) == 0:
return
self.client.log.conversation_upsert(body={'conversation': self.
conversation_model(messages=self.messages, metadata=self.metadata)})
self.messages = []
self.metadata = {}
|
def _log_conversation(self) ->None:
"""Log the conversation to the context API."""
if len(self.messages) == 0:
return
self.client.log.conversation_upsert(body={'conversation': self.
conversation_model(messages=self.messages, metadata=self.metadata)})
self.messages = []
self.metadata = {}
|
Log the conversation to the context API.
|
test_interfaces
|
history = ChatMessageHistory()
history.add_message(SystemMessage(content='system'))
history.add_user_message('human 1')
history.add_ai_message('ai')
history.add_message(HumanMessage(content='human 2'))
assert str(history) == """System: system
Human: human 1
AI: ai
Human: human 2"""
|
def test_interfaces() ->None:
history = ChatMessageHistory()
history.add_message(SystemMessage(content='system'))
history.add_user_message('human 1')
history.add_ai_message('ai')
history.add_message(HumanMessage(content='human 2'))
assert str(history
) == 'System: system\nHuman: human 1\nAI: ai\nHuman: human 2'
| null |
validate_credentials_path
|
"""Validate that credentials_path exists."""
if not v.exists():
raise ValueError(f'credentials_path {v} does not exist')
return v
|
@validator('credentials_path')
def validate_credentials_path(cls, v: Any, **kwargs: Any) ->Any:
"""Validate that credentials_path exists."""
if not v.exists():
raise ValueError(f'credentials_path {v} does not exist')
return v
|
Validate that credentials_path exists.
|
__del__
|
if self.cursor:
self.cursor.close()
if self.connection:
self.connection.close()
|
def __del__(self) ->None:
if self.cursor:
self.cursor.close()
if self.connection:
self.connection.close()
| null |
OutputType
|
return T
|
@property
def OutputType(self) ->Type[T]:
return T
| null |
_type
|
"""Return the output parser type for serialization."""
raise NotImplementedError(
f'_type property is not implemented in class {self.__class__.__name__}. This is required for serialization.'
)
|
@property
def _type(self) ->str:
"""Return the output parser type for serialization."""
raise NotImplementedError(
f'_type property is not implemented in class {self.__class__.__name__}. This is required for serialization.'
)
|
Return the output parser type for serialization.
|
test_tool_usage
|
parser = JSONAgentOutputParser()
_input = """ ```
{
"action": "search",
"action_input": "2+2"
}
```"""
output = parser.invoke(_input)
expected_output = AgentAction(tool='search', tool_input='2+2', log=_input)
assert output == expected_output
|
def test_tool_usage() ->None:
parser = JSONAgentOutputParser()
_input = (
' ```\n{\n "action": "search",\n "action_input": "2+2"\n}\n```')
output = parser.invoke(_input)
expected_output = AgentAction(tool='search', tool_input='2+2', log=_input)
assert output == expected_output
| null |
_generate
|
lmformatenforcer = import_lmformatenforcer()
import lmformatenforcer.integrations.transformers as hf_integration
if 'prefix_allowed_tokens_fn' in self.pipeline._forward_params:
raise ValueError(
'prefix_allowed_tokens_fn param is forbidden with LMFormatEnforcer.')
has_json_schema = self.json_schema is not None
has_regex = self.regex is not None
if has_json_schema == has_regex:
raise ValueError(
'You must specify exactly one of json_schema or a regex, but not both.'
)
if has_json_schema:
parser = lmformatenforcer.JsonSchemaParser(self.json_schema)
else:
parser = lmformatenforcer.RegexParser(self.regex)
prefix_function = hf_integration.build_transformers_prefix_allowed_tokens_fn(
self.pipeline.tokenizer, parser)
self.pipeline._forward_params['prefix_allowed_tokens_fn'] = prefix_function
result = super()._generate(prompts, stop=stop, run_manager=run_manager, **
kwargs)
del self.pipeline._forward_params['prefix_allowed_tokens_fn']
return result
|
def _generate(self, prompts: List[str], stop: Optional[List[str]]=None,
run_manager: Optional[CallbackManagerForLLMRun]=None, **kwargs: Any
) ->LLMResult:
lmformatenforcer = import_lmformatenforcer()
import lmformatenforcer.integrations.transformers as hf_integration
if 'prefix_allowed_tokens_fn' in self.pipeline._forward_params:
raise ValueError(
'prefix_allowed_tokens_fn param is forbidden with LMFormatEnforcer.'
)
has_json_schema = self.json_schema is not None
has_regex = self.regex is not None
if has_json_schema == has_regex:
raise ValueError(
'You must specify exactly one of json_schema or a regex, but not both.'
)
if has_json_schema:
parser = lmformatenforcer.JsonSchemaParser(self.json_schema)
else:
parser = lmformatenforcer.RegexParser(self.regex)
prefix_function = (hf_integration.
build_transformers_prefix_allowed_tokens_fn(self.pipeline.tokenizer,
parser))
self.pipeline._forward_params['prefix_allowed_tokens_fn'] = prefix_function
result = super()._generate(prompts, stop=stop, run_manager=run_manager,
**kwargs)
del self.pipeline._forward_params['prefix_allowed_tokens_fn']
return result
| null |
from_texts
|
"""
Return Neo4jVector initialized from texts and embeddings.
Neo4j credentials are required in the form of `url`, `username`,
and `password` and optional `database` parameters.
"""
embeddings = embedding.embed_documents(list(texts))
return cls.__from(texts, embeddings, embedding, metadatas=metadatas, ids=
ids, distance_strategy=distance_strategy, **kwargs)
|
@classmethod
def from_texts(cls: Type[Neo4jVector], texts: List[str], embedding:
Embeddings, metadatas: Optional[List[dict]]=None, distance_strategy:
DistanceStrategy=DEFAULT_DISTANCE_STRATEGY, ids: Optional[List[str]]=
None, **kwargs: Any) ->Neo4jVector:
"""
Return Neo4jVector initialized from texts and embeddings.
Neo4j credentials are required in the form of `url`, `username`,
and `password` and optional `database` parameters.
"""
embeddings = embedding.embed_documents(list(texts))
return cls.__from(texts, embeddings, embedding, metadatas=metadatas,
ids=ids, distance_strategy=distance_strategy, **kwargs)
|
Return Neo4jVector initialized from texts and embeddings.
Neo4j credentials are required in the form of `url`, `username`,
and `password` and optional `database` parameters.
|
disable_ssl_warnings
|
"""Disable SSL warnings."""
if v:
try:
import urllib3
urllib3.disable_warnings()
except ImportError as e:
print(e)
return v
|
@validator('unsecure')
def disable_ssl_warnings(cls, v: bool) ->bool:
"""Disable SSL warnings."""
if v:
try:
import urllib3
urllib3.disable_warnings()
except ImportError as e:
print(e)
return v
|
Disable SSL warnings.
|
_import_office365_create_draft_message
|
from langchain_community.tools.office365.create_draft_message import O365CreateDraftMessage
return O365CreateDraftMessage
|
def _import_office365_create_draft_message() ->Any:
from langchain_community.tools.office365.create_draft_message import O365CreateDraftMessage
return O365CreateDraftMessage
| null |
drop_tables
|
self.sync_client.drop_table()
|
def drop_tables(self) ->None:
self.sync_client.drop_table()
| null |
web_search
|
results = ddg_search.results(query, num_results)
return [r['link'] for r in results]
|
def web_search(query: str, num_results: int):
results = ddg_search.results(query, num_results)
return [r['link'] for r in results]
| null |
similarity_search
|
"""Perform a similarity search with StarRocks
Args:
query (str): query string
k (int, optional): Top K neighbors to retrieve. Defaults to 4.
where_str (Optional[str], optional): where condition string.
Defaults to None.
NOTE: Please do not let end-user to fill this and always be aware
of SQL injection. When dealing with metadatas, remember to
use `{self.metadata_column}.attribute` instead of `attribute`
alone. The default name for it is `metadata`.
Returns:
List[Document]: List of Documents
"""
return self.similarity_search_by_vector(self.embedding_function.embed_query
(query), k, where_str, **kwargs)
|
def similarity_search(self, query: str, k: int=4, where_str: Optional[str]=
None, **kwargs: Any) ->List[Document]:
"""Perform a similarity search with StarRocks
Args:
query (str): query string
k (int, optional): Top K neighbors to retrieve. Defaults to 4.
where_str (Optional[str], optional): where condition string.
Defaults to None.
NOTE: Please do not let end-user to fill this and always be aware
of SQL injection. When dealing with metadatas, remember to
use `{self.metadata_column}.attribute` instead of `attribute`
alone. The default name for it is `metadata`.
Returns:
List[Document]: List of Documents
"""
return self.similarity_search_by_vector(self.embedding_function.
embed_query(query), k, where_str, **kwargs)
|
Perform a similarity search with StarRocks
Args:
query (str): query string
k (int, optional): Top K neighbors to retrieve. Defaults to 4.
where_str (Optional[str], optional): where condition string.
Defaults to None.
NOTE: Please do not let end-user to fill this and always be aware
of SQL injection. When dealing with metadatas, remember to
use `{self.metadata_column}.attribute` instead of `attribute`
alone. The default name for it is `metadata`.
Returns:
List[Document]: List of Documents
|
from_documents
|
texts = [d.page_content for d in documents]
metadatas = [d.metadata for d in documents]
connection_string = cls.get_connection_string(kwargs)
kwargs['connection_string'] = connection_string
return cls.from_texts(texts=texts, pre_delete_collection=
pre_delete_collection, embedding=embedding, metadatas=metadatas, ids=
ids, collection_name=collection_name, **kwargs)
|
@classmethod
def from_documents(cls: Type[PGEmbedding], documents: List[Document],
embedding: Embeddings, collection_name: str=
_LANGCHAIN_DEFAULT_COLLECTION_NAME, ids: Optional[List[str]]=None,
pre_delete_collection: bool=False, **kwargs: Any) ->PGEmbedding:
texts = [d.page_content for d in documents]
metadatas = [d.metadata for d in documents]
connection_string = cls.get_connection_string(kwargs)
kwargs['connection_string'] = connection_string
return cls.from_texts(texts=texts, pre_delete_collection=
pre_delete_collection, embedding=embedding, metadatas=metadatas,
ids=ids, collection_name=collection_name, **kwargs)
| null |
bulk_similarity_search_with_score
|
"""Return documents from Marqo that are similar to the query as well as
their scores using a batch of queries.
Args:
query (Iterable[Union[str, Dict[str, float]]]): An iterable of queries
to execute in bulk, queries in the list can be strings or dictionaries
of weighted queries.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Tuple[Document, float]]: A list of lists of the matching
documents and their scores for each query
"""
bulk_results = self.marqo_bulk_similarity_search(queries=queries, k=k)
bulk_documents: List[List[Tuple[Document, float]]] = []
for results in bulk_results['result']:
documents = self._construct_documents_from_results_with_score(results)
bulk_documents.append(documents)
return bulk_documents
|
def bulk_similarity_search_with_score(self, queries: Iterable[Union[str,
Dict[str, float]]], k: int=4, **kwargs: Any) ->List[List[Tuple[Document,
float]]]:
"""Return documents from Marqo that are similar to the query as well as
their scores using a batch of queries.
Args:
query (Iterable[Union[str, Dict[str, float]]]): An iterable of queries
to execute in bulk, queries in the list can be strings or dictionaries
of weighted queries.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Tuple[Document, float]]: A list of lists of the matching
documents and their scores for each query
"""
bulk_results = self.marqo_bulk_similarity_search(queries=queries, k=k)
bulk_documents: List[List[Tuple[Document, float]]] = []
for results in bulk_results['result']:
documents = self._construct_documents_from_results_with_score(results)
bulk_documents.append(documents)
return bulk_documents
|
Return documents from Marqo that are similar to the query as well as
their scores using a batch of queries.
Args:
query (Iterable[Union[str, Dict[str, float]]]): An iterable of queries
to execute in bulk, queries in the list can be strings or dictionaries
of weighted queries.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Tuple[Document, float]]: A list of lists of the matching
documents and their scores for each query
|
requires_input
|
return True
|
@property
def requires_input(self) ->bool:
return True
| null |
test_list_directory
|
"""Test the DirectoryListing tool."""
with TemporaryDirectory() as temp_dir:
tool = ListDirectoryTool()
file_1 = Path(temp_dir) / 'file1.txt'
file_2 = Path(temp_dir) / 'file2.txt'
file_1.write_text('File 1 content')
file_2.write_text('File 2 content')
entries = tool.run({'dir_path': temp_dir}).split('\n')
assert set(entries) == {'file1.txt', 'file2.txt'}
|
def test_list_directory() ->None:
"""Test the DirectoryListing tool."""
with TemporaryDirectory() as temp_dir:
tool = ListDirectoryTool()
file_1 = Path(temp_dir) / 'file1.txt'
file_2 = Path(temp_dir) / 'file2.txt'
file_1.write_text('File 1 content')
file_2.write_text('File 2 content')
entries = tool.run({'dir_path': temp_dir}).split('\n')
assert set(entries) == {'file1.txt', 'file2.txt'}
|
Test the DirectoryListing tool.
|
_generate
|
"""Run the LLM on the given prompt and input."""
from vllm import SamplingParams
params = {**self._default_params, **kwargs, 'stop': stop}
sampling_params = SamplingParams(**params)
outputs = self.client.generate(prompts, sampling_params)
generations = []
for output in outputs:
text = output.outputs[0].text
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
|
def _generate(self, prompts: List[str], stop: Optional[List[str]]=None,
run_manager: Optional[CallbackManagerForLLMRun]=None, **kwargs: Any
) ->LLMResult:
"""Run the LLM on the given prompt and input."""
from vllm import SamplingParams
params = {**self._default_params, **kwargs, 'stop': stop}
sampling_params = SamplingParams(**params)
outputs = self.client.generate(prompts, sampling_params)
generations = []
for output in outputs:
text = output.outputs[0].text
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
|
Run the LLM on the given prompt and input.
|
__delete__
|
if instance is not None:
emit_warning()
return super().__delete__(instance)
|
def __delete__(self, instance):
if instance is not None:
emit_warning()
return super().__delete__(instance)
| null |
test_all_imports
|
assert set(__all__) == set(EXPECTED_ALL)
|
def test_all_imports() ->None:
assert set(__all__) == set(EXPECTED_ALL)
| null |
__init__
|
self.dimension = dimension
self.shard = shard
self.replicas = replicas
self.index_type = index_type
self.metric_type = metric_type
self.params = params
|
def __init__(self, dimension: int, shard: int=1, replicas: int=2,
index_type: str='HNSW', metric_type: str='L2', params: Optional[Dict]=None
):
self.dimension = dimension
self.shard = shard
self.replicas = replicas
self.index_type = index_type
self.metric_type = metric_type
self.params = params
| null |
test_on_llm_end_no_cost_invalid_model
|
response = LLMResult(generations=[], llm_output={'token_usage': {
'prompt_tokens': 1000, 'completion_tokens': 1000, 'total_tokens': 2000},
'model_name': model_name})
handler.on_llm_end(response)
assert handler.total_cost == 0
|
@pytest.mark.parametrize('model_name', ['gpt-35-turbo-16k-0301',
'gpt-4-0301', 'gpt-4-32k-0301'])
def test_on_llm_end_no_cost_invalid_model(handler: OpenAICallbackHandler,
model_name: str) ->None:
response = LLMResult(generations=[], llm_output={'token_usage': {
'prompt_tokens': 1000, 'completion_tokens': 1000, 'total_tokens':
2000}, 'model_name': model_name})
handler.on_llm_end(response)
assert handler.total_cost == 0
| null |
test___module_name___embedding_documents
|
"""Test cohere embeddings."""
documents = ['foo bar']
embedding = __ModuleName__Embeddings()
output = embedding.embed_documents(documents)
assert len(output) == 1
assert len(output[0]) > 0
|
def test___module_name___embedding_documents() ->None:
"""Test cohere embeddings."""
documents = ['foo bar']
embedding = __ModuleName__Embeddings()
output = embedding.embed_documents(documents)
assert len(output) == 1
assert len(output[0]) > 0
|
Test cohere embeddings.
|
marqo_similarity_search
|
"""Return documents from Marqo exposing Marqo's output directly
Args:
query (str): The query to search with.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Dict[str, Any]]: This hits from marqo.
"""
results = self._client.index(self._index_name).search(q=query,
searchable_attributes=self._searchable_attributes, limit=k)
return results
|
def marqo_similarity_search(self, query: Union[str, Dict[str, float]], k: int=4
) ->Dict[str, List[Dict[str, str]]]:
"""Return documents from Marqo exposing Marqo's output directly
Args:
query (str): The query to search with.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Dict[str, Any]]: This hits from marqo.
"""
results = self._client.index(self._index_name).search(q=query,
searchable_attributes=self._searchable_attributes, limit=k)
return results
|
Return documents from Marqo exposing Marqo's output directly
Args:
query (str): The query to search with.
k (int, optional): The number of documents to return. Defaults to 4.
Returns:
List[Dict[str, Any]]: This hits from marqo.
|
test_vertex_initialization
|
llm = VertexAI(model_name=model_name) if model_name else VertexAI()
assert llm._llm_type == 'vertexai'
try:
assert llm.model_name == llm.client._model_id
except AttributeError:
assert llm.model_name == llm.client._model_name.split('/')[-1]
|
@pytest.mark.parametrize('model_name', model_names_to_test_with_default)
def test_vertex_initialization(model_name: str) ->None:
llm = VertexAI(model_name=model_name) if model_name else VertexAI()
assert llm._llm_type == 'vertexai'
try:
assert llm.model_name == llm.client._model_id
except AttributeError:
assert llm.model_name == llm.client._model_name.split('/')[-1]
| null |
_import_awslambda
|
from langchain_community.utilities.awslambda import LambdaWrapper
return LambdaWrapper
|
def _import_awslambda() ->Any:
from langchain_community.utilities.awslambda import LambdaWrapper
return LambdaWrapper
| null |
_make_session
|
"""Create a session and close it after use."""
if isinstance(self.session_factory, async_sessionmaker):
raise AssertionError('This method is not supported for async engines.')
session = self.session_factory()
try:
yield session
finally:
session.close()
|
@contextlib.contextmanager
def _make_session(self) ->Generator[Session, None, None]:
"""Create a session and close it after use."""
if isinstance(self.session_factory, async_sessionmaker):
raise AssertionError('This method is not supported for async engines.')
session = self.session_factory()
try:
yield session
finally:
session.close()
|
Create a session and close it after use.
|
validate_environment
|
if isinstance(values.get('model'), str):
values['model'] = _model_default_factory(model_name=values['model'])
return values
|
@root_validator(pre=True)
def validate_environment(cls, values: dict) ->dict:
if isinstance(values.get('model'), str):
values['model'] = _model_default_factory(model_name=values['model'])
return values
| null |
__init__
|
"""Initialize the BibtexLoader.
Args:
file_path: Path to the bibtex file.
parser: The parser to use. If None, a default parser is used.
max_docs: Max number of associated documents to load. Use -1 means
no limit.
max_content_chars: Maximum number of characters to load from the PDF.
load_extra_metadata: Whether to load extra metadata from the PDF.
file_pattern: Regex pattern to match the file name in the bibtex.
"""
self.file_path = file_path
self.parser = parser or BibtexparserWrapper()
self.max_docs = max_docs
self.max_content_chars = max_content_chars
self.load_extra_metadata = load_extra_metadata
self.file_regex = re.compile(file_pattern)
|
def __init__(self, file_path: str, *, parser: Optional[BibtexparserWrapper]
=None, max_docs: Optional[int]=None, max_content_chars: Optional[int]=
4000, load_extra_metadata: bool=False, file_pattern: str='[^:]+\\.pdf'):
"""Initialize the BibtexLoader.
Args:
file_path: Path to the bibtex file.
parser: The parser to use. If None, a default parser is used.
max_docs: Max number of associated documents to load. Use -1 means
no limit.
max_content_chars: Maximum number of characters to load from the PDF.
load_extra_metadata: Whether to load extra metadata from the PDF.
file_pattern: Regex pattern to match the file name in the bibtex.
"""
self.file_path = file_path
self.parser = parser or BibtexparserWrapper()
self.max_docs = max_docs
self.max_content_chars = max_content_chars
self.load_extra_metadata = load_extra_metadata
self.file_regex = re.compile(file_pattern)
|
Initialize the BibtexLoader.
Args:
file_path: Path to the bibtex file.
parser: The parser to use. If None, a default parser is used.
max_docs: Max number of associated documents to load. Use -1 means
no limit.
max_content_chars: Maximum number of characters to load from the PDF.
load_extra_metadata: Whether to load extra metadata from the PDF.
file_pattern: Regex pattern to match the file name in the bibtex.
|
_generate_with_retry
|
resp = llm.client.call(**_kwargs)
return check_response(resp)
|
@retry_decorator
def _generate_with_retry(**_kwargs: Any) ->Any:
resp = llm.client.call(**_kwargs)
return check_response(resp)
| null |
artifact
|
"""To upload the file from given path as artifact."""
with self.mlflow.start_run(run_id=self.run.info.run_id, experiment_id=self.
mlf_expid):
self.mlflow.log_artifact(path)
|
def artifact(self, path: str) ->None:
"""To upload the file from given path as artifact."""
with self.mlflow.start_run(run_id=self.run.info.run_id, experiment_id=
self.mlf_expid):
self.mlflow.log_artifact(path)
|
To upload the file from given path as artifact.
|
_make_request_url
|
return f'{self.arcee_api_url}/{self.arcee_api_version}/{route}'
|
def _make_request_url(self, route: Union[ArceeRoute, str]) ->str:
return f'{self.arcee_api_url}/{self.arcee_api_version}/{route}'
| null |
from_pydantic
|
try:
from guardrails import Guard
except ImportError:
raise ImportError(
'guardrails-ai package not installed. Install it by running `pip install guardrails-ai`.'
)
return cls(guard=Guard.from_pydantic(output_class, '', num_reasks=
num_reasks), api=api, args=args, kwargs=kwargs)
|
@classmethod
def from_pydantic(cls, output_class: Any, num_reasks: int=1, api: Optional[
Callable]=None, *args: Any, **kwargs: Any) ->GuardrailsOutputParser:
try:
from guardrails import Guard
except ImportError:
raise ImportError(
'guardrails-ai package not installed. Install it by running `pip install guardrails-ai`.'
)
return cls(guard=Guard.from_pydantic(output_class, '', num_reasks=
num_reasks), api=api, args=args, kwargs=kwargs)
| null |
__init__
|
"""Initialize callback handler."""
flytekit, renderer = import_flytekit()
self.pandas = import_pandas()
self.textstat = None
try:
self.textstat = import_textstat()
except ImportError:
logger.warning(
'Textstat library is not installed. It may result in the inability to log certain metrics that can be captured with Textstat.'
)
spacy = None
try:
spacy = import_spacy()
except ImportError:
logger.warning(
'Spacy library is not installed. It may result in the inability to log certain metrics that can be captured with Spacy.'
)
super().__init__()
self.nlp = None
if spacy:
try:
self.nlp = spacy.load('en_core_web_sm')
except OSError:
logger.warning(
"FlyteCallbackHandler uses spacy's en_core_web_sm model for certain metrics. To download, run the following command in your terminal: `python -m spacy download en_core_web_sm`"
)
self.table_renderer = renderer.TableRenderer
self.markdown_renderer = renderer.MarkdownRenderer
self.deck = flytekit.Deck('LangChain Metrics', self.markdown_renderer().
to_html('## LangChain Metrics'))
|
def __init__(self) ->None:
"""Initialize callback handler."""
flytekit, renderer = import_flytekit()
self.pandas = import_pandas()
self.textstat = None
try:
self.textstat = import_textstat()
except ImportError:
logger.warning(
'Textstat library is not installed. It may result in the inability to log certain metrics that can be captured with Textstat.'
)
spacy = None
try:
spacy = import_spacy()
except ImportError:
logger.warning(
'Spacy library is not installed. It may result in the inability to log certain metrics that can be captured with Spacy.'
)
super().__init__()
self.nlp = None
if spacy:
try:
self.nlp = spacy.load('en_core_web_sm')
except OSError:
logger.warning(
"FlyteCallbackHandler uses spacy's en_core_web_sm model for certain metrics. To download, run the following command in your terminal: `python -m spacy download en_core_web_sm`"
)
self.table_renderer = renderer.TableRenderer
self.markdown_renderer = renderer.MarkdownRenderer
self.deck = flytekit.Deck('LangChain Metrics', self.markdown_renderer()
.to_html('## LangChain Metrics'))
|
Initialize callback handler.
|
_agent_type
|
raise ValueError
|
@property
def _agent_type(self) ->str:
raise ValueError
| null |
card_list_to_objects
|
"""Helper to convert dict cards into trello weird mix of objects and dictionaries"""
for card in cards:
card['checklists'] = list_to_objects(card.get('checklists'))
card['labels'] = list_to_objects(card.get('labels'))
return list_to_objects(cards)
|
def card_list_to_objects(cards: list) ->list:
"""Helper to convert dict cards into trello weird mix of objects and dictionaries"""
for card in cards:
card['checklists'] = list_to_objects(card.get('checklists'))
card['labels'] = list_to_objects(card.get('labels'))
return list_to_objects(cards)
|
Helper to convert dict cards into trello weird mix of objects and dictionaries
|
test_tencent_vector_db_add_extra
|
"""Test end to end construction and MRR search."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = _tencent_vector_db_from_texts(metadatas=metadatas)
docsearch.add_texts(texts, metadatas)
time.sleep(3)
output = docsearch.similarity_search('foo', k=10)
assert len(output) == 6
|
def test_tencent_vector_db_add_extra() ->None:
"""Test end to end construction and MRR search."""
texts = ['foo', 'bar', 'baz']
metadatas = [{'page': i} for i in range(len(texts))]
docsearch = _tencent_vector_db_from_texts(metadatas=metadatas)
docsearch.add_texts(texts, metadatas)
time.sleep(3)
output = docsearch.similarity_search('foo', k=10)
assert len(output) == 6
|
Test end to end construction and MRR search.
|
test_chat_ai_endpoints_system_message
|
"""Test wrapper with system message."""
chat = ChatNVIDIA(model='llama2_13b', max_tokens=36)
system_message = SystemMessage(content='You are to chat with the user.')
human_message = HumanMessage(content='Hello')
response = chat([system_message, human_message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
|
def test_chat_ai_endpoints_system_message() ->None:
"""Test wrapper with system message."""
chat = ChatNVIDIA(model='llama2_13b', max_tokens=36)
system_message = SystemMessage(content='You are to chat with the user.')
human_message = HumanMessage(content='Hello')
response = chat([system_message, human_message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
|
Test wrapper with system message.
|
_default_params
|
"""Get the default parameters for calling the API."""
defaults = {'model': self.model, 'temperature': self.temperature,
'max_tokens': self.max_tokens, 'top_p': self.top_p, 'random_seed': self
.random_seed, 'safe_mode': self.safe_mode}
filtered = {k: v for k, v in defaults.items() if v is not None}
return filtered
|
@property
def _default_params(self) ->Dict[str, Any]:
"""Get the default parameters for calling the API."""
defaults = {'model': self.model, 'temperature': self.temperature,
'max_tokens': self.max_tokens, 'top_p': self.top_p, 'random_seed':
self.random_seed, 'safe_mode': self.safe_mode}
filtered = {k: v for k, v in defaults.items() if v is not None}
return filtered
|
Get the default parameters for calling the API.
|
from_template
|
"""Create a class from a string template.
Args:
template: a template.
template_format: format of the template.
partial_variables: A dictionary of variables that can be used to partially
fill in the template. For example, if the template is
`"{variable1} {variable2}"`, and `partial_variables` is
`{"variable1": "foo"}`, then the final prompt will be
`"foo {variable2}"`.
**kwargs: keyword arguments to pass to the constructor.
Returns:
A new instance of this class.
"""
prompt = PromptTemplate.from_template(template, template_format=
template_format, partial_variables=partial_variables)
return cls(prompt=prompt, **kwargs)
|
@classmethod
def from_template(cls: Type[MessagePromptTemplateT], template: str,
template_format: str='f-string', partial_variables: Optional[Dict[str,
Any]]=None, **kwargs: Any) ->MessagePromptTemplateT:
"""Create a class from a string template.
Args:
template: a template.
template_format: format of the template.
partial_variables: A dictionary of variables that can be used to partially
fill in the template. For example, if the template is
`"{variable1} {variable2}"`, and `partial_variables` is
`{"variable1": "foo"}`, then the final prompt will be
`"foo {variable2}"`.
**kwargs: keyword arguments to pass to the constructor.
Returns:
A new instance of this class.
"""
prompt = PromptTemplate.from_template(template, template_format=
template_format, partial_variables=partial_variables)
return cls(prompt=prompt, **kwargs)
|
Create a class from a string template.
Args:
template: a template.
template_format: format of the template.
partial_variables: A dictionary of variables that can be used to partially
fill in the template. For example, if the template is
`"{variable1} {variable2}"`, and `partial_variables` is
`{"variable1": "foo"}`, then the final prompt will be
`"foo {variable2}"`.
**kwargs: keyword arguments to pass to the constructor.
Returns:
A new instance of this class.
|
get_schema
|
return db.get_table_info()
|
def get_schema(_):
return db.get_table_info()
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.