method_name
stringlengths
1
78
method_body
stringlengths
3
9.66k
full_code
stringlengths
31
10.7k
docstring
stringlengths
4
4.74k
_YieldFrom
self.write('(') self.write('yield from') if t.value: self.write(' ') self.dispatch(t.value) self.write(')')
def _YieldFrom(self, t): self.write('(') self.write('yield from') if t.value: self.write(' ') self.dispatch(t.value) self.write(')')
null
get_table_info
all_table_names = self.get_usable_table_names() if table_names is not None: missing_tables = set(table_names).difference(all_table_names) if missing_tables: raise ValueError(f'table_names {missing_tables} not found in database') all_table_names = table_names tables = [] for table_name in all_table_names: table_info = self._get_create_table_stmt(table_name) if self._sample_rows_in_table_info: table_info += '\n\n/*' table_info += f'\n{self._get_sample_spark_rows(table_name)}\n' table_info += '*/' tables.append(table_info) final_str = '\n\n'.join(tables) return final_str
def get_table_info(self, table_names: Optional[List[str]]=None) ->str: all_table_names = self.get_usable_table_names() if table_names is not None: missing_tables = set(table_names).difference(all_table_names) if missing_tables: raise ValueError( f'table_names {missing_tables} not found in database') all_table_names = table_names tables = [] for table_name in all_table_names: table_info = self._get_create_table_stmt(table_name) if self._sample_rows_in_table_info: table_info += '\n\n/*' table_info += f'\n{self._get_sample_spark_rows(table_name)}\n' table_info += '*/' tables.append(table_info) final_str = '\n\n'.join(tables) return final_str
null
_body
model_kwargs = self.model_kwargs or {} model_kwargs = {**model_kwargs, **kwargs} return {'input': prompt, **model_kwargs}
def _body(self, prompt: str, kwargs: Any) ->Dict: model_kwargs = self.model_kwargs or {} model_kwargs = {**model_kwargs, **kwargs} return {'input': prompt, **model_kwargs}
null
_Dict
self.write('{') def write_key_value_pair(k, v): self.dispatch(k) self.write(': ') self.dispatch(v) def write_item(item): k, v = item if k is None: self.write('**') self.dispatch(v) else: write_key_value_pair(k, v) interleave(lambda : self.write(', '), write_item, zip(t.keys, t.values)) self.write('}')
def _Dict(self, t): self.write('{') def write_key_value_pair(k, v): self.dispatch(k) self.write(': ') self.dispatch(v) def write_item(item): k, v = item if k is None: self.write('**') self.dispatch(v) else: write_key_value_pair(k, v) interleave(lambda : self.write(', '), write_item, zip(t.keys, t.values)) self.write('}')
null
_parse_response
if len(json_data) == 1: result = self._parse_json(json_data[0]) else: for entry in json_data: if entry.get('provider') == 'eden-ai': result = self._parse_json(entry) return result
def _parse_response(self, json_data: list) ->str: if len(json_data) == 1: result = self._parse_json(json_data[0]) else: for entry in json_data: if entry.get('provider') == 'eden-ai': result = self._parse_json(entry) return result
null
test_all_imports
assert sorted(EXPECTED_ALL) == sorted(__all__)
def test_all_imports() ->None: assert sorted(EXPECTED_ALL) == sorted(__all__)
null
add_texts
"""Run more texts through the embeddings and add to the vectorstore. Args: texts: Iterable of strings to add to the vectorstore. metadatas: Optional list of metadatas associated with the texts. Returns: List of ids from adding the texts into the vectorstore. """ try: from elasticsearch.helpers import BulkIndexError, bulk except ImportError: raise ImportError( 'Could not import elasticsearch python package. Please install it with `pip install elasticsearch`.' ) embeddings = [] create_index_if_not_exists = kwargs.get('create_index_if_not_exists', True) ids = kwargs.get('ids', [str(uuid.uuid4()) for _ in texts]) refresh_indices = kwargs.get('refresh_indices', True) requests = [] if self.embedding is not None: embeddings = self.embedding.embed_documents(list(texts)) dims_length = len(embeddings[0]) if create_index_if_not_exists: self._create_index_if_not_exists(dims_length=dims_length) for i, (text, vector) in enumerate(zip(texts, embeddings)): metadata = metadatas[i] if metadatas else {} requests.append({'_op_type': 'index', '_index': self.index_name, self.query_field: text, self.vector_query_field: vector, 'metadata': metadata, '_id': ids[i]}) else: if create_index_if_not_exists: self._create_index_if_not_exists() for i, text in enumerate(texts): metadata = metadatas[i] if metadatas else {} requests.append({'_op_type': 'index', '_index': self.index_name, self.query_field: text, 'metadata': metadata, '_id': ids[i]}) if len(requests) > 0: try: success, failed = bulk(self.client, requests, stats_only=True, refresh=refresh_indices) logger.debug( f'Added {success} and failed to add {failed} texts to index') logger.debug(f'added texts {ids} to index') return ids except BulkIndexError as e: logger.error(f'Error adding texts: {e}') firstError = e.errors[0].get('index', {}).get('error', {}) logger.error(f"First error reason: {firstError.get('reason')}") raise e else: logger.debug('No texts to add to index') return []
def add_texts(self, texts: Iterable[str], metadatas: Optional[List[Dict[Any, Any]]]=None, **kwargs: Any) ->List[str]: """Run more texts through the embeddings and add to the vectorstore. Args: texts: Iterable of strings to add to the vectorstore. metadatas: Optional list of metadatas associated with the texts. Returns: List of ids from adding the texts into the vectorstore. """ try: from elasticsearch.helpers import BulkIndexError, bulk except ImportError: raise ImportError( 'Could not import elasticsearch python package. Please install it with `pip install elasticsearch`.' ) embeddings = [] create_index_if_not_exists = kwargs.get('create_index_if_not_exists', True) ids = kwargs.get('ids', [str(uuid.uuid4()) for _ in texts]) refresh_indices = kwargs.get('refresh_indices', True) requests = [] if self.embedding is not None: embeddings = self.embedding.embed_documents(list(texts)) dims_length = len(embeddings[0]) if create_index_if_not_exists: self._create_index_if_not_exists(dims_length=dims_length) for i, (text, vector) in enumerate(zip(texts, embeddings)): metadata = metadatas[i] if metadatas else {} requests.append({'_op_type': 'index', '_index': self.index_name, self.query_field: text, self.vector_query_field: vector, 'metadata': metadata, '_id': ids[i]}) else: if create_index_if_not_exists: self._create_index_if_not_exists() for i, text in enumerate(texts): metadata = metadatas[i] if metadatas else {} requests.append({'_op_type': 'index', '_index': self.index_name, self.query_field: text, 'metadata': metadata, '_id': ids[i]}) if len(requests) > 0: try: success, failed = bulk(self.client, requests, stats_only=True, refresh=refresh_indices) logger.debug( f'Added {success} and failed to add {failed} texts to index') logger.debug(f'added texts {ids} to index') return ids except BulkIndexError as e: logger.error(f'Error adding texts: {e}') firstError = e.errors[0].get('index', {}).get('error', {}) logger.error(f"First error reason: {firstError.get('reason')}") raise e else: logger.debug('No texts to add to index') return []
Run more texts through the embeddings and add to the vectorstore. Args: texts: Iterable of strings to add to the vectorstore. metadatas: Optional list of metadatas associated with the texts. Returns: List of ids from adding the texts into the vectorstore.
_import_powerbi_tool_ListPowerBITool
from langchain_community.tools.powerbi.tool import ListPowerBITool return ListPowerBITool
def _import_powerbi_tool_ListPowerBITool() ->Any: from langchain_community.tools.powerbi.tool import ListPowerBITool return ListPowerBITool
null
test_openai_streaming_multiple_prompts_error
"""Test validation for streaming fails if multiple prompts are given.""" with pytest.raises(ValueError): OpenAI(streaming=True).generate(["I'm Pickle Rick", "I'm Pickle Rick"])
def test_openai_streaming_multiple_prompts_error() ->None: """Test validation for streaming fails if multiple prompts are given.""" with pytest.raises(ValueError): OpenAI(streaming=True).generate(["I'm Pickle Rick", "I'm Pickle Rick"])
Test validation for streaming fails if multiple prompts are given.
format_docs
return '\n\n'.join(f"""Source {i}: {doc.page_content}""" for i, doc in enumerate(docs))
def format_docs(docs): return '\n\n'.join(f'Source {i}:\n{doc.page_content}' for i, doc in enumerate(docs))
null
parse_result
if len(result) != 1: raise OutputParserException( f'Expected exactly one result, but got {len(result)}') generation = result[0] if not isinstance(generation, ChatGeneration): raise OutputParserException( 'This output parser can only be used with a chat generation.') message = generation.message if 'function_call' not in message.additional_kwargs: return None try: function_call = message.additional_kwargs['function_call'] except KeyError as exc: if partial: return None else: raise OutputParserException(f'Could not parse function call: {exc}') try: if partial: if self.args_only: return parse_partial_json(function_call['arguments'], strict= self.strict) else: return {**function_call, 'arguments': parse_partial_json( function_call['arguments'], strict=self.strict)} elif self.args_only: try: return json.loads(function_call['arguments'], strict=self.strict) except (json.JSONDecodeError, TypeError) as exc: raise OutputParserException( f'Could not parse function call data: {exc}') else: try: return {**function_call, 'arguments': json.loads(function_call[ 'arguments'], strict=self.strict)} except (json.JSONDecodeError, TypeError) as exc: raise OutputParserException( f'Could not parse function call data: {exc}') except KeyError: return None
def parse_result(self, result: List[Generation], *, partial: bool=False) ->Any: if len(result) != 1: raise OutputParserException( f'Expected exactly one result, but got {len(result)}') generation = result[0] if not isinstance(generation, ChatGeneration): raise OutputParserException( 'This output parser can only be used with a chat generation.') message = generation.message if 'function_call' not in message.additional_kwargs: return None try: function_call = message.additional_kwargs['function_call'] except KeyError as exc: if partial: return None else: raise OutputParserException(f'Could not parse function call: {exc}' ) try: if partial: if self.args_only: return parse_partial_json(function_call['arguments'], strict=self.strict) else: return {**function_call, 'arguments': parse_partial_json( function_call['arguments'], strict=self.strict)} elif self.args_only: try: return json.loads(function_call['arguments'], strict=self. strict) except (json.JSONDecodeError, TypeError) as exc: raise OutputParserException( f'Could not parse function call data: {exc}') else: try: return {**function_call, 'arguments': json.loads( function_call['arguments'], strict=self.strict)} except (json.JSONDecodeError, TypeError) as exc: raise OutputParserException( f'Could not parse function call data: {exc}') except KeyError: return None
null
lazy_parse
"""Lazily parse the blob.""" import fitz with blob.as_bytes_io() as file_path: if blob.data is None: doc = fitz.open(file_path) else: doc = fitz.open(stream=file_path, filetype='pdf') yield from [Document(page_content=page.get_text(**self.text_kwargs) + self._extract_images_from_page(doc, page), metadata=dict({'source': blob.source, 'file_path': blob.source, 'page': page.number, 'total_pages': len(doc)}, **{k: doc.metadata[k] for k in doc. metadata if type(doc.metadata[k]) in [str, int]})) for page in doc]
def lazy_parse(self, blob: Blob) ->Iterator[Document]: """Lazily parse the blob.""" import fitz with blob.as_bytes_io() as file_path: if blob.data is None: doc = fitz.open(file_path) else: doc = fitz.open(stream=file_path, filetype='pdf') yield from [Document(page_content=page.get_text(**self.text_kwargs) + self._extract_images_from_page(doc, page), metadata=dict({ 'source': blob.source, 'file_path': blob.source, 'page': page. number, 'total_pages': len(doc)}, **{k: doc.metadata[k] for k in doc.metadata if type(doc.metadata[k]) in [str, int]})) for page in doc]
Lazily parse the blob.
test_openai_llm_output_contains_model_name
"""Test llm_output contains model_name.""" llm = OpenAI(max_tokens=10) llm_result = llm.generate(['Hello, how are you?']) assert llm_result.llm_output is not None assert llm_result.llm_output['model_name'] == llm.model_name
def test_openai_llm_output_contains_model_name() ->None: """Test llm_output contains model_name.""" llm = OpenAI(max_tokens=10) llm_result = llm.generate(['Hello, how are you?']) assert llm_result.llm_output is not None assert llm_result.llm_output['model_name'] == llm.model_name
Test llm_output contains model_name.
_headers
return {'Authorization': f'bearer {self.deepinfra_api_token}', 'Content-Type': 'application/json'}
def _headers(self) ->Dict: return {'Authorization': f'bearer {self.deepinfra_api_token}', 'Content-Type': 'application/json'}
null
_call
"""Call out to Aviary Args: prompt: The prompt to pass into the model. Returns: The string generated by the model. Example: .. code-block:: python response = aviary("Tell me a joke.") """ kwargs = {'use_prompt_format': self.use_prompt_format} if self.version: kwargs['version'] = self.version output = get_completions(model=self.model, prompt=prompt, **kwargs) text = cast(str, output['generated_text']) if stop: text = enforce_stop_tokens(text, stop) return text
def _call(self, prompt: str, stop: Optional[List[str]]=None, run_manager: Optional[CallbackManagerForLLMRun]=None, **kwargs: Any) ->str: """Call out to Aviary Args: prompt: The prompt to pass into the model. Returns: The string generated by the model. Example: .. code-block:: python response = aviary("Tell me a joke.") """ kwargs = {'use_prompt_format': self.use_prompt_format} if self.version: kwargs['version'] = self.version output = get_completions(model=self.model, prompt=prompt, **kwargs) text = cast(str, output['generated_text']) if stop: text = enforce_stop_tokens(text, stop) return text
Call out to Aviary Args: prompt: The prompt to pass into the model. Returns: The string generated by the model. Example: .. code-block:: python response = aviary("Tell me a joke.")
__init__
"""Initialize the sentence_transformer.""" super().__init__(**kwargs) try: import sentence_transformers except ImportError as exc: raise ImportError( 'Could not import sentence_transformers python package. Please install it with `pip install sentence-transformers`.' ) from exc self.client = sentence_transformers.SentenceTransformer(self.model_name, cache_folder=self.cache_folder, **self.model_kwargs)
def __init__(self, **kwargs: Any): """Initialize the sentence_transformer.""" super().__init__(**kwargs) try: import sentence_transformers except ImportError as exc: raise ImportError( 'Could not import sentence_transformers python package. Please install it with `pip install sentence-transformers`.' ) from exc self.client = sentence_transformers.SentenceTransformer(self.model_name, cache_folder=self.cache_folder, **self.model_kwargs)
Initialize the sentence_transformer.
test_loading_few_shot_prompt_example_prompt
"""Test loading few shot when the example prompt is in its own file.""" with change_directory(EXAMPLE_DIR): prompt = load_prompt('few_shot_prompt_example_prompt.json') expected_prompt = FewShotPromptTemplate(input_variables=['adjective'], prefix='Write antonyms for the following words.', example_prompt= PromptTemplate(input_variables=['input', 'output'], template= """Input: {input} Output: {output}"""), examples=[{'input': 'happy', 'output': 'sad'}, {'input': 'tall', 'output': 'short'}], suffix= """Input: {adjective} Output:""") assert prompt == expected_prompt
def test_loading_few_shot_prompt_example_prompt() ->None: """Test loading few shot when the example prompt is in its own file.""" with change_directory(EXAMPLE_DIR): prompt = load_prompt('few_shot_prompt_example_prompt.json') expected_prompt = FewShotPromptTemplate(input_variables=[ 'adjective'], prefix='Write antonyms for the following words.', example_prompt=PromptTemplate(input_variables=['input', 'output'], template="""Input: {input} Output: {output}"""), examples=[{'input': 'happy', 'output': 'sad'}, {'input': 'tall', 'output': 'short'}], suffix="""Input: {adjective} Output:""") assert prompt == expected_prompt
Test loading few shot when the example prompt is in its own file.
test_pgvector_with_filter_distant_match
"""Test end to end construction and search.""" texts = ['foo', 'bar', 'baz'] metadatas = [{'page': str(i)} for i in range(len(texts))] docsearch = PGVector.from_texts(texts=texts, collection_name= 'test_collection_filter', embedding=FakeEmbeddingsWithAdaDimension(), metadatas=metadatas, connection_string=CONNECTION_STRING, pre_delete_collection=True) output = docsearch.similarity_search_with_score('foo', k=1, filter={'page': '2'}) assert output == [(Document(page_content='baz', metadata={'page': '2'}), 0.0013003906671379406)]
def test_pgvector_with_filter_distant_match() ->None: """Test end to end construction and search.""" texts = ['foo', 'bar', 'baz'] metadatas = [{'page': str(i)} for i in range(len(texts))] docsearch = PGVector.from_texts(texts=texts, collection_name= 'test_collection_filter', embedding=FakeEmbeddingsWithAdaDimension( ), metadatas=metadatas, connection_string=CONNECTION_STRING, pre_delete_collection=True) output = docsearch.similarity_search_with_score('foo', k=1, filter={ 'page': '2'}) assert output == [(Document(page_content='baz', metadata={'page': '2'}), 0.0013003906671379406)]
Test end to end construction and search.
_validate_outputs
super()._validate_outputs(outputs) if not isinstance(outputs['next_inputs'], dict): raise ValueError
def _validate_outputs(self, outputs: Dict[str, Any]) ->None: super()._validate_outputs(outputs) if not isinstance(outputs['next_inputs'], dict): raise ValueError
null
test_func_call_oldstyle
act = json.dumps([{'action_name': 'foo', 'action': {'__arg1': '42'}}]) msg = AIMessage(content='LLM thoughts.', additional_kwargs={'function_call': {'name': 'foo', 'arguments': f'{{"actions": {act}}}'}}) result = _parse_ai_message(msg) assert isinstance(result, list) assert len(result) == 1 action = result[0] assert isinstance(action, _FunctionsAgentAction) assert action.tool == 'foo' assert action.tool_input == '42' assert action.log == """ Invoking: `foo` with `42` responded: LLM thoughts. """ assert action.message_log == [msg]
def test_func_call_oldstyle(self) ->None: act = json.dumps([{'action_name': 'foo', 'action': {'__arg1': '42'}}]) msg = AIMessage(content='LLM thoughts.', additional_kwargs={ 'function_call': {'name': 'foo', 'arguments': f'{{"actions": {act}}}'}} ) result = _parse_ai_message(msg) assert isinstance(result, list) assert len(result) == 1 action = result[0] assert isinstance(action, _FunctionsAgentAction) assert action.tool == 'foo' assert action.tool_input == '42' assert action.log == '\nInvoking: `foo` with `42`\nresponded: LLM thoughts.\n\n' assert action.message_log == [msg]
null
_async_retry_decorator
import openai async_retrying = AsyncRetrying(reraise=True, stop=stop_after_attempt( embeddings.max_retries), wait=wait_exponential(multiplier=1, min= embeddings.retry_min_seconds, max=embeddings.retry_max_seconds), retry= retry_if_exception_type(openai.error.Timeout) | retry_if_exception_type (openai.error.APIError) | retry_if_exception_type(openai.error. APIConnectionError) | retry_if_exception_type(openai.error. RateLimitError) | retry_if_exception_type(openai.error. ServiceUnavailableError), before_sleep=before_sleep_log(logger, logging .WARNING)) def wrap(func: Callable) ->Callable: async def wrapped_f(*args: Any, **kwargs: Any) ->Callable: async for _ in async_retrying: return await func(*args, **kwargs) raise AssertionError('this is unreachable') return wrapped_f return wrap
def _async_retry_decorator(embeddings: OpenAIEmbeddings) ->Any: import openai async_retrying = AsyncRetrying(reraise=True, stop=stop_after_attempt( embeddings.max_retries), wait=wait_exponential(multiplier=1, min= embeddings.retry_min_seconds, max=embeddings.retry_max_seconds), retry=retry_if_exception_type(openai.error.Timeout) | retry_if_exception_type(openai.error.APIError) | retry_if_exception_type(openai.error.APIConnectionError) | retry_if_exception_type(openai.error.RateLimitError) | retry_if_exception_type(openai.error.ServiceUnavailableError), before_sleep=before_sleep_log(logger, logging.WARNING)) def wrap(func: Callable) ->Callable: async def wrapped_f(*args: Any, **kwargs: Any) ->Callable: async for _ in async_retrying: return await func(*args, **kwargs) raise AssertionError('this is unreachable') return wrapped_f return wrap
null
test_graph_sequence
fake_llm = FakeListLLM(responses=['a']) prompt = PromptTemplate.from_template('Hello, {name}!') list_parser = CommaSeparatedListOutputParser() sequence = prompt | fake_llm | list_parser graph = sequence.get_graph() assert graph.draw_ascii() == snapshot
def test_graph_sequence(snapshot: SnapshotAssertion) ->None: fake_llm = FakeListLLM(responses=['a']) prompt = PromptTemplate.from_template('Hello, {name}!') list_parser = CommaSeparatedListOutputParser() sequence = prompt | fake_llm | list_parser graph = sequence.get_graph() assert graph.draw_ascii() == snapshot
null
__iter__
yield from self._children
def __iter__(self) ->Iterator[Iterator[T]]: yield from self._children
null
__deepcopy__
"""Return a deep copy of the callback handler.""" return self
def __deepcopy__(self, memo: Any) ->'OpenAICallbackHandler': """Return a deep copy of the callback handler.""" return self
Return a deep copy of the callback handler.
on_chain_end
self.on_chain_end_common()
def on_chain_end(self, *args: Any, **kwargs: Any) ->Any: self.on_chain_end_common()
null
validate_chains
"""Validate that the correct inputs exist for all chains.""" chains = values['chains'] input_variables = values['input_variables'] memory_keys = list() if 'memory' in values and values['memory'] is not None: """Validate that prompt input variables are consistent.""" memory_keys = values['memory'].memory_variables if set(input_variables).intersection(set(memory_keys)): overlapping_keys = set(input_variables) & set(memory_keys) raise ValueError( f"The input key(s) {''.join(overlapping_keys)} are found in the Memory keys ({memory_keys}) - please use input and memory keys that don't overlap." ) known_variables = set(input_variables + memory_keys) for chain in chains: missing_vars = set(chain.input_keys).difference(known_variables) if chain.memory: missing_vars = missing_vars.difference(chain.memory.memory_variables) if missing_vars: raise ValueError( f'Missing required input keys: {missing_vars}, only had {known_variables}' ) overlapping_keys = known_variables.intersection(chain.output_keys) if overlapping_keys: raise ValueError( f'Chain returned keys that already exist: {overlapping_keys}') known_variables |= set(chain.output_keys) if 'output_variables' not in values: if values.get('return_all', False): output_keys = known_variables.difference(input_variables) else: output_keys = chains[-1].output_keys values['output_variables'] = output_keys else: missing_vars = set(values['output_variables']).difference(known_variables) if missing_vars: raise ValueError( f'Expected output variables that were not found: {missing_vars}.') return values
@root_validator(pre=True) def validate_chains(cls, values: Dict) ->Dict: """Validate that the correct inputs exist for all chains.""" chains = values['chains'] input_variables = values['input_variables'] memory_keys = list() if 'memory' in values and values['memory'] is not None: """Validate that prompt input variables are consistent.""" memory_keys = values['memory'].memory_variables if set(input_variables).intersection(set(memory_keys)): overlapping_keys = set(input_variables) & set(memory_keys) raise ValueError( f"The input key(s) {''.join(overlapping_keys)} are found in the Memory keys ({memory_keys}) - please use input and memory keys that don't overlap." ) known_variables = set(input_variables + memory_keys) for chain in chains: missing_vars = set(chain.input_keys).difference(known_variables) if chain.memory: missing_vars = missing_vars.difference(chain.memory. memory_variables) if missing_vars: raise ValueError( f'Missing required input keys: {missing_vars}, only had {known_variables}' ) overlapping_keys = known_variables.intersection(chain.output_keys) if overlapping_keys: raise ValueError( f'Chain returned keys that already exist: {overlapping_keys}') known_variables |= set(chain.output_keys) if 'output_variables' not in values: if values.get('return_all', False): output_keys = known_variables.difference(input_variables) else: output_keys = chains[-1].output_keys values['output_variables'] = output_keys else: missing_vars = set(values['output_variables']).difference( known_variables) if missing_vars: raise ValueError( f'Expected output variables that were not found: {missing_vars}.' ) return values
Validate that the correct inputs exist for all chains.
is_lc_serializable
return False
@classmethod def is_lc_serializable(cls) ->bool: return False
null
embed_documents
"""Embed search docs.""" return [i.embedding for i in self._client.embeddings.create(input=texts, model=self.model).data]
def embed_documents(self, texts: List[str]) ->List[List[float]]: """Embed search docs.""" return [i.embedding for i in self._client.embeddings.create(input=texts, model=self.model).data]
Embed search docs.
_run
script = strip_markdown_code(python_code) resp = requests.post('https://exec.bearly.ai/v1/interpreter', data=json. dumps({'fileContents': script, 'inputFiles': self.make_input_files(), 'outputDir': 'output/', 'outputAsLinks': True}), headers={ 'Authorization': self.api_key}).json() return {'stdout': base64.b64decode(resp['stdoutBasesixtyfour']).decode() if resp['stdoutBasesixtyfour'] else '', 'stderr': base64.b64decode(resp[ 'stderrBasesixtyfour']).decode() if resp['stderrBasesixtyfour'] else '', 'fileLinks': resp['fileLinks'], 'exitCode': resp['exitCode']}
def _run(self, python_code: str) ->dict: script = strip_markdown_code(python_code) resp = requests.post('https://exec.bearly.ai/v1/interpreter', data=json .dumps({'fileContents': script, 'inputFiles': self.make_input_files (), 'outputDir': 'output/', 'outputAsLinks': True}), headers={ 'Authorization': self.api_key}).json() return {'stdout': base64.b64decode(resp['stdoutBasesixtyfour']).decode( ) if resp['stdoutBasesixtyfour'] else '', 'stderr': base64. b64decode(resp['stderrBasesixtyfour']).decode() if resp[ 'stderrBasesixtyfour'] else '', 'fileLinks': resp['fileLinks'], 'exitCode': resp['exitCode']}
null
run
"""Run query through Google Trends with Serpapi""" serpapi_api_key = cast(SecretStr, self.serp_api_key) params = {'engine': 'google_jobs', 'api_key': serpapi_api_key. get_secret_value(), 'q': query} total_results = [] client = self.serp_search_engine(params) total_results = client.get_dict()['jobs_results'] res_str = '' for i in range(1): job = total_results[i] res_str += '\n_______________________________________________' + f""" Job Title: {job['title']} """ + f"Company Name: {job['company_name']}\n" + f"Location: {job['location']}\n" + f"Description: {job['description']}" + """ _______________________________________________ """ return res_str + '\n'
def run(self, query: str) ->str: """Run query through Google Trends with Serpapi""" serpapi_api_key = cast(SecretStr, self.serp_api_key) params = {'engine': 'google_jobs', 'api_key': serpapi_api_key. get_secret_value(), 'q': query} total_results = [] client = self.serp_search_engine(params) total_results = client.get_dict()['jobs_results'] res_str = '' for i in range(1): job = total_results[i] res_str += '\n_______________________________________________' + f""" Job Title: {job['title']} """ + f"Company Name: {job['company_name']}\n" + f"Location: {job['location']}\n" + f"Description: {job['description']}" + """ _______________________________________________ """ return res_str + '\n'
Run query through Google Trends with Serpapi
test_extract_sub_links_exclude
html = ( '<a href="https://foobar.com">one</a><a href="http://baz.net">two</a><a href="//foobar.com/hello">three</a><a href="/how/are/you/doing">four</a><a href="alexis.html"</a>' ) expected = sorted(['http://baz.net', 'https://foobar.com', 'https://foobar.com/hello', 'https://foobar.com/hello/alexis.html']) actual = sorted(extract_sub_links(html, 'https://foobar.com/hello/bill.html', base_url='https://foobar.com', prevent_outside=False, exclude_prefixes=('https://foobar.com/how', 'http://baz.org'))) assert actual == expected
def test_extract_sub_links_exclude() ->None: html = ( '<a href="https://foobar.com">one</a><a href="http://baz.net">two</a><a href="//foobar.com/hello">three</a><a href="/how/are/you/doing">four</a><a href="alexis.html"</a>' ) expected = sorted(['http://baz.net', 'https://foobar.com', 'https://foobar.com/hello', 'https://foobar.com/hello/alexis.html']) actual = sorted(extract_sub_links(html, 'https://foobar.com/hello/bill.html', base_url='https://foobar.com', prevent_outside=False, exclude_prefixes=('https://foobar.com/how', 'http://baz.org'))) assert actual == expected
null
__query_cluster
"""Query the BagelDB cluster based on the provided parameters.""" try: import bagel except ImportError: raise ImportError('Please install bagel `pip install betabageldb`.') return self._cluster.find(query_texts=query_texts, query_embeddings= query_embeddings, n_results=n_results, where=where, **kwargs)
@xor_args(('query_texts', 'query_embeddings')) def __query_cluster(self, query_texts: Optional[List[str]]=None, query_embeddings: Optional[List[List[float]]]=None, n_results: int=4, where: Optional[Dict[str, str]]=None, **kwargs: Any) ->List[Document]: """Query the BagelDB cluster based on the provided parameters.""" try: import bagel except ImportError: raise ImportError('Please install bagel `pip install betabageldb`.') return self._cluster.find(query_texts=query_texts, query_embeddings= query_embeddings, n_results=n_results, where=where, **kwargs)
Query the BagelDB cluster based on the provided parameters.
get_lc_namespace
"""Get the namespace of the langchain object.""" return ['langchain', 'chat_models', 'openai']
@classmethod def get_lc_namespace(cls) ->List[str]: """Get the namespace of the langchain object.""" return ['langchain', 'chat_models', 'openai']
Get the namespace of the langchain object.
_load_sql_database_chain
from langchain_experimental.sql import SQLDatabaseChain if 'database' in kwargs: database = kwargs.pop('database') else: raise ValueError('`database` must be present.') if 'llm_chain' in config: llm_chain_config = config.pop('llm_chain') chain = load_chain_from_config(llm_chain_config) return SQLDatabaseChain(llm_chain=chain, database=database, **config) if 'llm' in config: llm_config = config.pop('llm') llm = load_llm_from_config(llm_config) elif 'llm_path' in config: llm = load_llm(config.pop('llm_path')) else: raise ValueError('One of `llm` or `llm_path` must be present.') if 'prompt' in config: prompt_config = config.pop('prompt') prompt = load_prompt_from_config(prompt_config) else: prompt = None return SQLDatabaseChain.from_llm(llm, database, prompt=prompt, **config)
def _load_sql_database_chain(config: dict, **kwargs: Any) ->Any: from langchain_experimental.sql import SQLDatabaseChain if 'database' in kwargs: database = kwargs.pop('database') else: raise ValueError('`database` must be present.') if 'llm_chain' in config: llm_chain_config = config.pop('llm_chain') chain = load_chain_from_config(llm_chain_config) return SQLDatabaseChain(llm_chain=chain, database=database, **config) if 'llm' in config: llm_config = config.pop('llm') llm = load_llm_from_config(llm_config) elif 'llm_path' in config: llm = load_llm(config.pop('llm_path')) else: raise ValueError('One of `llm` or `llm_path` must be present.') if 'prompt' in config: prompt_config = config.pop('prompt') prompt = load_prompt_from_config(prompt_config) else: prompt = None return SQLDatabaseChain.from_llm(llm, database, prompt=prompt, **config)
null
test_pickbest_textembedder_w_full_label_no_emb
feature_embedder = pick_best_chain.PickBestFeatureEmbedder(auto_embed=False, model=MockEncoder()) named_actions = {'action1': ['0', '1', '2']} expected = """shared |context context 0:-0.0:1.0 |action1 0 |action1 1 |action1 2 """ 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': '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_w_full_label_no_emb() ->None: feature_embedder = pick_best_chain.PickBestFeatureEmbedder(auto_embed= False, model=MockEncoder()) named_actions = {'action1': ['0', '1', '2']} expected = ( 'shared |context context \n0:-0.0:1.0 |action1 0 \n|action1 1 \n|action1 2 ' ) 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': 'context'}, selected=selected) vw_ex_str = feature_embedder.format(event) assert vw_ex_str == expected
null
__init__
confluence_kwargs = confluence_kwargs or {} errors = ConfluenceLoader.validate_init_args(url=url, api_key=api_key, username=username, session=session, oauth2=oauth2, token=token) if errors: raise ValueError(f'Error(s) while validating input: {errors}') try: from atlassian import Confluence except ImportError: raise ImportError( '`atlassian` package not found, please run `pip install atlassian-python-api`' ) self.base_url = url self.number_of_retries = number_of_retries self.min_retry_seconds = min_retry_seconds self.max_retry_seconds = max_retry_seconds if session: self.confluence = Confluence(url=url, session=session, **confluence_kwargs) elif oauth2: self.confluence = Confluence(url=url, oauth2=oauth2, cloud=cloud, ** confluence_kwargs) elif token: self.confluence = Confluence(url=url, token=token, cloud=cloud, ** confluence_kwargs) else: self.confluence = Confluence(url=url, username=username, password= api_key, cloud=cloud, **confluence_kwargs)
def __init__(self, url: str, api_key: Optional[str]=None, username: Optional[str]=None, session: Optional[requests.Session]=None, oauth2: Optional[dict]=None, token: Optional[str]=None, cloud: Optional[bool]= True, number_of_retries: Optional[int]=3, min_retry_seconds: Optional[ int]=2, max_retry_seconds: Optional[int]=10, confluence_kwargs: Optional[dict]=None): confluence_kwargs = confluence_kwargs or {} errors = ConfluenceLoader.validate_init_args(url=url, api_key=api_key, username=username, session=session, oauth2=oauth2, token=token) if errors: raise ValueError(f'Error(s) while validating input: {errors}') try: from atlassian import Confluence except ImportError: raise ImportError( '`atlassian` package not found, please run `pip install atlassian-python-api`' ) self.base_url = url self.number_of_retries = number_of_retries self.min_retry_seconds = min_retry_seconds self.max_retry_seconds = max_retry_seconds if session: self.confluence = Confluence(url=url, session=session, ** confluence_kwargs) elif oauth2: self.confluence = Confluence(url=url, oauth2=oauth2, cloud=cloud, **confluence_kwargs) elif token: self.confluence = Confluence(url=url, token=token, cloud=cloud, ** confluence_kwargs) else: self.confluence = Confluence(url=url, username=username, password= api_key, cloud=cloud, **confluence_kwargs)
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.
__getattr__
"""Raise an error on import since is deprecated.""" raise ImportError( 'This module has been moved to langchain-experimental. For more details: https://github.com/langchain-ai/langchain/discussions/11352.To access this code, install it with `pip install langchain-experimental`.`from langchain_experimental.llm_bash.base import LLMBashChain`' )
def __getattr__(name: str='') ->None: """Raise an error on import since is deprecated.""" raise ImportError( 'This module has been moved to langchain-experimental. For more details: https://github.com/langchain-ai/langchain/discussions/11352.To access this code, install it with `pip install langchain-experimental`.`from langchain_experimental.llm_bash.base import LLMBashChain`' )
Raise an error on import since is deprecated.
_format_chat_history
buffer = [] for human, ai in chat_history: buffer.append(HumanMessage(content=human)) buffer.append(AIMessage(content=ai)) return buffer
def _format_chat_history(chat_history: List[Tuple[str, str]]): buffer = [] for human, ai in chat_history: buffer.append(HumanMessage(content=human)) buffer.append(AIMessage(content=ai)) return buffer
null
_llm_type
"""Return the type of chat model.""" return 'zhipuai'
@property def _llm_type(self) ->str: """Return the type of chat model.""" return 'zhipuai'
Return the type of chat model.
test_callback_manager_configure_context_vars
"""Test callback manager configuration.""" monkeypatch.setenv('LANGCHAIN_TRACING_V2', 'true') monkeypatch.setenv('LANGCHAIN_TRACING', 'false') with patch.object(LangChainTracer, '_update_run_single'): with patch.object(LangChainTracer, '_persist_run_single'): with trace_as_chain_group('test') as group_manager: assert len(group_manager.handlers) == 1 tracer = group_manager.handlers[0] assert isinstance(tracer, LangChainTracer) with get_openai_callback() as cb: assert cb.successful_requests == 0 assert cb.total_tokens == 0 mngr = CallbackManager.configure(group_manager) assert mngr.handlers == [tracer, cb] assert group_manager.handlers == [tracer] response = LLMResult(generations=[], llm_output={ 'token_usage': {'prompt_tokens': 2, 'completion_tokens': 1, 'total_tokens': 3}, 'model_name': BaseOpenAI. __fields__['model_name'].default}) mngr.on_llm_start({}, ['prompt'])[0].on_llm_end(response) assert cb.successful_requests == 1 assert cb.total_tokens == 3 assert cb.prompt_tokens == 2 assert cb.completion_tokens == 1 assert cb.total_cost > 0 with get_openai_callback() as cb: assert cb.successful_requests == 0 assert cb.total_tokens == 0 mngr = CallbackManager.configure(group_manager) assert mngr.handlers == [tracer, cb] assert group_manager.handlers == [tracer] response = LLMResult(generations=[], llm_output={ 'token_usage': {'prompt_tokens': 2, 'completion_tokens': 1, 'total_tokens': 3}, 'model_name': BaseOpenAI. __fields__['model_name'].default}) mngr.on_llm_start({}, ['prompt'])[0].on_llm_end(response) assert cb.successful_requests == 1 assert cb.total_tokens == 3 assert cb.prompt_tokens == 2 assert cb.completion_tokens == 1 assert cb.total_cost > 0 wait_for_all_tracers() assert LangChainTracer._persist_run_single.call_count == 1
def test_callback_manager_configure_context_vars(monkeypatch: pytest. MonkeyPatch) ->None: """Test callback manager configuration.""" monkeypatch.setenv('LANGCHAIN_TRACING_V2', 'true') monkeypatch.setenv('LANGCHAIN_TRACING', 'false') with patch.object(LangChainTracer, '_update_run_single'): with patch.object(LangChainTracer, '_persist_run_single'): with trace_as_chain_group('test') as group_manager: assert len(group_manager.handlers) == 1 tracer = group_manager.handlers[0] assert isinstance(tracer, LangChainTracer) with get_openai_callback() as cb: assert cb.successful_requests == 0 assert cb.total_tokens == 0 mngr = CallbackManager.configure(group_manager) assert mngr.handlers == [tracer, cb] assert group_manager.handlers == [tracer] response = LLMResult(generations=[], llm_output={ 'token_usage': {'prompt_tokens': 2, 'completion_tokens': 1, 'total_tokens': 3}, 'model_name': BaseOpenAI.__fields__['model_name']. default}) mngr.on_llm_start({}, ['prompt'])[0].on_llm_end(response) assert cb.successful_requests == 1 assert cb.total_tokens == 3 assert cb.prompt_tokens == 2 assert cb.completion_tokens == 1 assert cb.total_cost > 0 with get_openai_callback() as cb: assert cb.successful_requests == 0 assert cb.total_tokens == 0 mngr = CallbackManager.configure(group_manager) assert mngr.handlers == [tracer, cb] assert group_manager.handlers == [tracer] response = LLMResult(generations=[], llm_output={ 'token_usage': {'prompt_tokens': 2, 'completion_tokens': 1, 'total_tokens': 3}, 'model_name': BaseOpenAI.__fields__['model_name']. default}) mngr.on_llm_start({}, ['prompt'])[0].on_llm_end(response) assert cb.successful_requests == 1 assert cb.total_tokens == 3 assert cb.prompt_tokens == 2 assert cb.completion_tokens == 1 assert cb.total_cost > 0 wait_for_all_tracers() assert LangChainTracer._persist_run_single.call_count == 1
Test callback manager configuration.
_import_stochasticai
from langchain_community.llms.stochasticai import StochasticAI return StochasticAI
def _import_stochasticai() ->Any: from langchain_community.llms.stochasticai import StochasticAI return StochasticAI
null
_get_channel
try: import grpc except ImportError: raise ValueError( 'Could not import grpcio python package. Please install it with `pip install grpcio`.' ) return grpc.secure_channel(self.target, self.grpc_credentials, options=self .grpc_options) if self.grpc_use_secure else grpc.insecure_channel(self. target, options=self.grpc_options)
def _get_channel(self) ->Any: try: import grpc except ImportError: raise ValueError( 'Could not import grpcio python package. Please install it with `pip install grpcio`.' ) return grpc.secure_channel(self.target, self.grpc_credentials, options= self.grpc_options) if self.grpc_use_secure else grpc.insecure_channel( self.target, options=self.grpc_options)
null
test_python_code_splitter
splitter = RecursiveCharacterTextSplitter.from_language(Language.PYTHON, chunk_size=CHUNK_SIZE, chunk_overlap=0) code = """ def hello_world(): print("Hello, World!") # Call the function hello_world() """ chunks = splitter.split_text(code) assert chunks == ['def', 'hello_world():', 'print("Hello,', 'World!")', '# Call the', 'function', 'hello_world()']
def test_python_code_splitter() ->None: splitter = RecursiveCharacterTextSplitter.from_language(Language.PYTHON, chunk_size=CHUNK_SIZE, chunk_overlap=0) code = """ def hello_world(): print("Hello, World!") # Call the function hello_world() """ chunks = splitter.split_text(code) assert chunks == ['def', 'hello_world():', 'print("Hello,', 'World!")', '# Call the', 'function', 'hello_world()']
null
_on_tool_error
"""Process the Tool Run upon error."""
def _on_tool_error(self, run: Run) ->None: """Process the Tool Run upon error."""
Process the Tool Run upon error.
elasticsearch_connection
from elasticsearch import Elasticsearch es_url = os.environ.get('ES_URL', 'http://localhost:9200') es_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 es_cloud_id: es = Elasticsearch(cloud_id=es_cloud_id, basic_auth=(es_username, es_password)) yield {'es_cloud_id': es_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')
@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') es_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 es_cloud_id: es = Elasticsearch(cloud_id=es_cloud_id, basic_auth=(es_username, es_password)) yield {'es_cloud_id': es_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')
null
_get_tool_classes
results = [] for tool_class_name in tools_all: if tool_class_name in _DEPRECATED_TOOLS: continue tool_class = getattr(langchain_community.tools, tool_class_name) if isinstance(tool_class, type) and issubclass(tool_class, BaseTool): if tool_class in _EXCLUDE: continue if skip_tools_without_default_names and tool_class.__fields__['name' ].default in [None, '']: continue results.append(tool_class) return results
def _get_tool_classes(skip_tools_without_default_names: bool) ->List[Type[ BaseTool]]: results = [] for tool_class_name in tools_all: if tool_class_name in _DEPRECATED_TOOLS: continue tool_class = getattr(langchain_community.tools, tool_class_name) if isinstance(tool_class, type) and issubclass(tool_class, BaseTool): if tool_class in _EXCLUDE: continue if skip_tools_without_default_names and tool_class.__fields__[ 'name'].default in [None, '']: continue results.append(tool_class) return results
null
with_listeners
""" Bind lifecycle listeners to a Runnable, returning a new Runnable. on_start: Called before the runnable starts running, with the Run object. on_end: Called after the runnable finishes running, with the Run object. on_error: Called if the runnable throws an error, with the Run object. The Run object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run. """ from langchain_core.tracers.root_listeners import RootListenersTracer return RunnableBinding(bound=self, config_factories=[lambda config: { 'callbacks': [RootListenersTracer(config=config, on_start=on_start, on_end=on_end, on_error=on_error)]}])
def with_listeners(self, *, on_start: Optional[Listener]=None, on_end: Optional[Listener]=None, on_error: Optional[Listener]=None) ->Runnable[ Input, Output]: """ Bind lifecycle listeners to a Runnable, returning a new Runnable. on_start: Called before the runnable starts running, with the Run object. on_end: Called after the runnable finishes running, with the Run object. on_error: Called if the runnable throws an error, with the Run object. The Run object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run. """ from langchain_core.tracers.root_listeners import RootListenersTracer return RunnableBinding(bound=self, config_factories=[lambda config: { 'callbacks': [RootListenersTracer(config=config, on_start=on_start, on_end=on_end, on_error=on_error)]}])
Bind lifecycle listeners to a Runnable, returning a new Runnable. on_start: Called before the runnable starts running, with the Run object. on_end: Called after the runnable finishes running, with the Run object. on_error: Called if the runnable throws an error, with the Run object. The Run object contains information about the run, including its id, type, input, output, error, start_time, end_time, and any tags or metadata added to the run.
gen_indexes
for i in range(next(length_iter)): yield i
def gen_indexes(length_iter: Iterator[int]) ->Iterator[int]: for i in range(next(length_iter)): yield i
null
test_all_imports
assert set(__all__) == set(EXPECTED_ALL)
def test_all_imports() ->None: assert set(__all__) == set(EXPECTED_ALL)
null
get_tools
"""Get the tools in the toolkit.""" return [QuerySparkSQLTool(db=self.db), InfoSparkSQLTool(db=self.db), ListSparkSQLTool(db=self.db), QueryCheckerTool(db=self.db, llm=self.llm)]
def get_tools(self) ->List[BaseTool]: """Get the tools in the toolkit.""" return [QuerySparkSQLTool(db=self.db), InfoSparkSQLTool(db=self.db), ListSparkSQLTool(db=self.db), QueryCheckerTool(db=self.db, llm=self .llm)]
Get the tools in the toolkit.
_llm_type
"""Return type of llm.""" return 'vllm'
@property def _llm_type(self) ->str: """Return type of llm.""" return 'vllm'
Return type of llm.
transform_input
return {'inputs': prompt, 'parameters': model_kwargs}
@classmethod def transform_input(cls, prompt: str, model_kwargs: Dict[str, Any]) ->Dict[ str, Any]: return {'inputs': prompt, 'parameters': model_kwargs}
null
__init__
"""Initialize Alibaba Cloud MaxCompute document loader. Args: query: SQL query to execute. api_wrapper: MaxCompute API wrapper. page_content_columns: The columns to write into the `page_content` of the Document. If unspecified, all columns will be written to `page_content`. metadata_columns: The columns to write into the `metadata` of the Document. If unspecified, all columns not added to `page_content` will be written. """ self.query = query self.api_wrapper = api_wrapper self.page_content_columns = page_content_columns self.metadata_columns = metadata_columns
def __init__(self, query: str, api_wrapper: MaxComputeAPIWrapper, *, page_content_columns: Optional[Sequence[str]]=None, metadata_columns: Optional[Sequence[str]]=None): """Initialize Alibaba Cloud MaxCompute document loader. Args: query: SQL query to execute. api_wrapper: MaxCompute API wrapper. page_content_columns: The columns to write into the `page_content` of the Document. If unspecified, all columns will be written to `page_content`. metadata_columns: The columns to write into the `metadata` of the Document. If unspecified, all columns not added to `page_content` will be written. """ self.query = query self.api_wrapper = api_wrapper self.page_content_columns = page_content_columns self.metadata_columns = metadata_columns
Initialize Alibaba Cloud MaxCompute document loader. Args: query: SQL query to execute. api_wrapper: MaxCompute API wrapper. page_content_columns: The columns to write into the `page_content` of the Document. If unspecified, all columns will be written to `page_content`. metadata_columns: The columns to write into the `metadata` of the Document. If unspecified, all columns not added to `page_content` will be written.
__init__
self.loads: Set[str] = set() self.stores: Set[str] = set()
def __init__(self) ->None: self.loads: Set[str] = set() self.stores: Set[str] = set()
null
save
"""Saves the data to the persist_path"""
@abstractmethod def save(self, data: Any) ->None: """Saves the data to the persist_path"""
Saves the data to the persist_path
_run
"""Use the PubMed tool.""" return self.api_wrapper.run(query)
def _run(self, query: str, run_manager: Optional[CallbackManagerForToolRun] =None) ->str: """Use the PubMed tool.""" return self.api_wrapper.run(query)
Use the PubMed tool.
list_files_in_bot_branch
""" Fetches all files in the active branch of the repo, the branch the bot uses to make changes. Returns: str: A plaintext list containing the the filepaths in the branch. """ files: List[str] = [] try: contents = self.github_repo_instance.get_contents('', ref=self. active_branch) for content in contents: if content.type == 'dir': files.extend(self.get_files_from_directory(content.path)) else: files.append(content.path) if files: files_str = '\n'.join(files) return ( f'Found {len(files)} files in branch `{self.active_branch}`:\n{files_str}' ) else: return f'No files found in branch: `{self.active_branch}`' except Exception as e: return f'Error: {e}'
def list_files_in_bot_branch(self) ->str: """ Fetches all files in the active branch of the repo, the branch the bot uses to make changes. Returns: str: A plaintext list containing the the filepaths in the branch. """ files: List[str] = [] try: contents = self.github_repo_instance.get_contents('', ref=self. active_branch) for content in contents: if content.type == 'dir': files.extend(self.get_files_from_directory(content.path)) else: files.append(content.path) if files: files_str = '\n'.join(files) return ( f'Found {len(files)} files in branch `{self.active_branch}`:\n{files_str}' ) else: return f'No files found in branch: `{self.active_branch}`' except Exception as e: return f'Error: {e}'
Fetches all files in the active branch of the repo, the branch the bot uses to make changes. Returns: str: A plaintext list containing the the filepaths in the branch.
_run
"""Use the tool.""" if self.sync_browser is None: raise ValueError(f'Synchronous browser not provided to {self.name}') page = get_current_page(self.sync_browser) return str(page.url)
def _run(self, run_manager: Optional[CallbackManagerForToolRun]=None) ->str: """Use the tool.""" if self.sync_browser is None: raise ValueError(f'Synchronous browser not provided to {self.name}') page = get_current_page(self.sync_browser) return str(page.url)
Use the tool.
get
"""Return docs according ids. Args: ids: The ids of the embedding vectors. Returns: Documents which satisfy the input conditions. """ results: Dict[str, Document] = {} if ids is None or ids.__len__() == 0: return results if self.flag: query_data = {'query': {'ids': ids}} docs_detail = self.vearch.mget_by_ids(self.using_db_name, self. using_table_name, query_data) for record in docs_detail: if record['found'] is False: continue content = '' meta_info = {} for field in record['_source']: if field == 'text': content = record['_source'][field] continue elif field == 'metadata': meta_info['source'] = record['_source'][field] continue results[record['_id']] = Document(page_content=content, metadata= meta_info) else: for id in ids: docs_detail = self.vearch.get_doc_by_id(id) if docs_detail == {}: continue content = '' meta_info = {} for field in docs_detail: if field == 'text': content = docs_detail[field] continue elif field == 'metadata': meta_info['source'] = docs_detail[field] continue results[docs_detail['_id']] = Document(page_content=content, metadata=meta_info) return results
def get(self, ids: Optional[List[str]]=None, **kwargs: Any) ->Dict[str, Document]: """Return docs according ids. Args: ids: The ids of the embedding vectors. Returns: Documents which satisfy the input conditions. """ results: Dict[str, Document] = {} if ids is None or ids.__len__() == 0: return results if self.flag: query_data = {'query': {'ids': ids}} docs_detail = self.vearch.mget_by_ids(self.using_db_name, self. using_table_name, query_data) for record in docs_detail: if record['found'] is False: continue content = '' meta_info = {} for field in record['_source']: if field == 'text': content = record['_source'][field] continue elif field == 'metadata': meta_info['source'] = record['_source'][field] continue results[record['_id']] = Document(page_content=content, metadata=meta_info) else: for id in ids: docs_detail = self.vearch.get_doc_by_id(id) if docs_detail == {}: continue content = '' meta_info = {} for field in docs_detail: if field == 'text': content = docs_detail[field] continue elif field == 'metadata': meta_info['source'] = docs_detail[field] continue results[docs_detail['_id']] = Document(page_content=content, metadata=meta_info) return results
Return docs according ids. Args: ids: The ids of the embedding vectors. Returns: Documents which satisfy the input conditions.
get_collection
return self.CollectionStore.get_by_name(session, self.collection_name)
def get_collection(self, session: Session) ->Any: return self.CollectionStore.get_by_name(session, self.collection_name)
null
test_default_call
"""Test default model call.""" chat = ChatZhipuAI() response = chat(messages=[HumanMessage(content='Hello')]) assert isinstance(response, BaseMessage) assert isinstance(response.content, str)
def test_default_call() ->None: """Test default model call.""" chat = ChatZhipuAI() response = chat(messages=[HumanMessage(content='Hello')]) assert isinstance(response, BaseMessage) assert isinstance(response.content, str)
Test default model call.
_mathpix_headers
return {'app_id': self.mathpix_api_id, 'app_key': self.mathpix_api_key}
@property def _mathpix_headers(self) ->Dict[str, str]: return {'app_id': self.mathpix_api_id, 'app_key': self.mathpix_api_key}
null
test_handles_empty_input_list
output = format_to_openai_tool_messages([]) assert output == []
def test_handles_empty_input_list() ->None: output = format_to_openai_tool_messages([]) assert output == []
null
_invocation_params
"""Get the parameters used to invoke the model.""" jinachat_creds: Dict[str, Any] = {'api_key': self.jinachat_api_key and self .jinachat_api_key.get_secret_value(), 'api_base': 'https://api.chat.jina.ai/v1', 'model': 'jinachat'} return {**jinachat_creds, **self._default_params}
@property def _invocation_params(self) ->Mapping[str, Any]: """Get the parameters used to invoke the model.""" jinachat_creds: Dict[str, Any] = {'api_key': self.jinachat_api_key and self.jinachat_api_key.get_secret_value(), 'api_base': 'https://api.chat.jina.ai/v1', 'model': 'jinachat'} return {**jinachat_creds, **self._default_params}
Get the parameters used to invoke the model.
memory_variables
"""Will always return list of memory variables. :meta private: """ return ['entities', self.chat_history_key]
@property def memory_variables(self) ->List[str]: """Will always return list of memory variables. :meta private: """ return ['entities', self.chat_history_key]
Will always return list of memory variables. :meta private:
count_matching_files
"""Count files that match the pattern without loading them.""" num = 0 for _ in self._yield_paths(): num += 1 return num
def count_matching_files(self) ->int: """Count files that match the pattern without loading them.""" num = 0 for _ in self._yield_paths(): num += 1 return num
Count files that match the pattern without loading them.
similarity_search
"""Perform a similarity search with ClickHouse 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 ClickHouse 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 ClickHouse 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
_run
"""Use the tool.""" available_tool_names_str = ', '.join([tool for tool in available_tool_names]) return f'{requested_tool_name} is not a valid tool, try one of [{available_tool_names_str}].'
def _run(self, requested_tool_name: str, available_tool_names: List[str], run_manager: Optional[CallbackManagerForToolRun]=None) ->str: """Use the tool.""" available_tool_names_str = ', '.join([tool for tool in available_tool_names]) return ( f'{requested_tool_name} is not a valid tool, try one of [{available_tool_names_str}].' )
Use the tool.
_call
headers: Dict = {'Authorization': cast(SecretStr, self.cerebriumai_api_key) .get_secret_value(), 'Content-Type': 'application/json'} params = self.model_kwargs or {} payload = {'prompt': prompt, **params, **kwargs} response = requests.post(self.endpoint_url, json=payload, headers=headers) if response.status_code == 200: data = response.json() text = data['result'] if stop is not None: text = enforce_stop_tokens(text, stop) return text else: response.raise_for_status() return ''
def _call(self, prompt: str, stop: Optional[List[str]]=None, run_manager: Optional[CallbackManagerForLLMRun]=None, **kwargs: Any) ->str: headers: Dict = {'Authorization': cast(SecretStr, self. cerebriumai_api_key).get_secret_value(), 'Content-Type': 'application/json'} params = self.model_kwargs or {} payload = {'prompt': prompt, **params, **kwargs} response = requests.post(self.endpoint_url, json=payload, headers=headers) if response.status_code == 200: data = response.json() text = data['result'] if stop is not None: text = enforce_stop_tokens(text, stop) return text else: response.raise_for_status() return ''
null
_get_relevant_documents
query_dict = {'query': {'match': {'content': query}}} res = self.client.search(index=self.index_name, body=query_dict) docs = [] for r in res['hits']['hits']: docs.append(Document(page_content=r['_source']['content'])) return docs
def _get_relevant_documents(self, query: str, *, run_manager: CallbackManagerForRetrieverRun) ->List[Document]: query_dict = {'query': {'match': {'content': query}}} res = self.client.search(index=self.index_name, body=query_dict) docs = [] for r in res['hits']['hits']: docs.append(Document(page_content=r['_source']['content'])) return docs
null
get_default_host
"""Gets the default Databricks workspace hostname. Raises an error if the hostname cannot be automatically determined. """ host = os.getenv('DATABRICKS_HOST') if not host: try: host = get_repl_context().browserHostName if not host: raise ValueError("context doesn't contain browserHostName.") except Exception as e: raise ValueError( f"host was not set and cannot be automatically inferred. Set environment variable 'DATABRICKS_HOST'. Received error: {e}" ) host = host.lstrip('https://').lstrip('http://').rstrip('/') return host
def get_default_host() ->str: """Gets the default Databricks workspace hostname. Raises an error if the hostname cannot be automatically determined. """ host = os.getenv('DATABRICKS_HOST') if not host: try: host = get_repl_context().browserHostName if not host: raise ValueError("context doesn't contain browserHostName.") except Exception as e: raise ValueError( f"host was not set and cannot be automatically inferred. Set environment variable 'DATABRICKS_HOST'. Received error: {e}" ) host = host.lstrip('https://').lstrip('http://').rstrip('/') return host
Gets the default Databricks workspace hostname. Raises an error if the hostname cannot be automatically determined.
__set_name__
nonlocal _name if _name == '<lambda>': _name = set_name
def __set_name__(self, owner, set_name): nonlocal _name if _name == '<lambda>': _name = set_name
null
_run
"""Use the tool.""" if self.sync_browser is None: raise ValueError(f'Synchronous browser not provided to {self.name}') page = get_current_page(self.sync_browser) results = _get_elements(page, selector, attributes) return json.dumps(results, ensure_ascii=False)
def _run(self, selector: str, attributes: Sequence[str]=['innerText'], run_manager: Optional[CallbackManagerForToolRun]=None) ->str: """Use the tool.""" if self.sync_browser is None: raise ValueError(f'Synchronous browser not provided to {self.name}') page = get_current_page(self.sync_browser) results = _get_elements(page, selector, attributes) return json.dumps(results, ensure_ascii=False)
Use the tool.
_import_file_management_MoveFileTool
from langchain_community.tools.file_management import MoveFileTool return MoveFileTool
def _import_file_management_MoveFileTool() ->Any: from langchain_community.tools.file_management import MoveFileTool return MoveFileTool
null
resize_base64_image
""" Resize an image encoded as a Base64 string. :param base64_string: A Base64 encoded string of the image to be resized. :param size: A tuple representing the new size (width, height) for the image. :return: A Base64 encoded string of the resized image. """ img_data = base64.b64decode(base64_string) img = Image.open(io.BytesIO(img_data)) resized_img = img.resize(size, Image.LANCZOS) buffered = io.BytesIO() resized_img.save(buffered, format=img.format) return base64.b64encode(buffered.getvalue()).decode('utf-8')
def resize_base64_image(base64_string, size=(128, 128)): """ Resize an image encoded as a Base64 string. :param base64_string: A Base64 encoded string of the image to be resized. :param size: A tuple representing the new size (width, height) for the image. :return: A Base64 encoded string of the resized image. """ img_data = base64.b64decode(base64_string) img = Image.open(io.BytesIO(img_data)) resized_img = img.resize(size, Image.LANCZOS) buffered = io.BytesIO() resized_img.save(buffered, format=img.format) return base64.b64encode(buffered.getvalue()).decode('utf-8')
Resize an image encoded as a Base64 string. :param base64_string: A Base64 encoded string of the image to be resized. :param size: A tuple representing the new size (width, height) for the image. :return: A Base64 encoded string of the resized image.
_import_python
from langchain_community.utilities.python import PythonREPL return PythonREPL
def _import_python() ->Any: from langchain_community.utilities.python import PythonREPL return PythonREPL
null
test_multiline_output_parsing
_test_convo_output( """ Thought: Do I need to use a tool? Yes Action: evaluate_code Action Input: Evaluate Code with the following Python content: ```python print("Hello fifty shades of gray mans!"[::-1]) ``` """ , 'evaluate_code', """ Evaluate Code with the following Python content: ```python print("Hello fifty shades of gray mans!"[::-1]) ```""" .lstrip())
def test_multiline_output_parsing() ->None: _test_convo_output( """ Thought: Do I need to use a tool? Yes Action: evaluate_code Action Input: Evaluate Code with the following Python content: ```python print("Hello fifty shades of gray mans!"[::-1]) ``` """ , 'evaluate_code', """ Evaluate Code with the following Python content: ```python print("Hello fifty shades of gray mans!"[::-1]) ```""" .lstrip())
null
save_context
"""Save context from this conversation to buffer.""" documents = self._form_documents(inputs, outputs) self.retriever.add_documents(documents)
def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) ->None: """Save context from this conversation to buffer.""" documents = self._form_documents(inputs, outputs) self.retriever.add_documents(documents)
Save context from this conversation to buffer.
_llm_type
return 'yandex_gpt'
@property def _llm_type(self) ->str: return 'yandex_gpt'
null
similarity_search
""" Return Jaguar documents most similar to query, along with scores. Args: query: Text to look up documents similar to. k: Number of Documents to return. Defaults to 5. where: the where clause in select similarity. For example a where can be "rating > 3.0 and (state = 'NV' or state = 'CA')" Returns: List of Documents most similar to the query """ docs_and_scores = self.similarity_search_with_score(query, k=k, where=where, metadatas=metadatas, **kwargs) return [doc for doc, _ in docs_and_scores]
def similarity_search(self, query: str, k: int=3, where: Optional[str]=None, metadatas: Optional[List[str]]=None, **kwargs: Any) ->List[Document]: """ Return Jaguar documents most similar to query, along with scores. Args: query: Text to look up documents similar to. k: Number of Documents to return. Defaults to 5. where: the where clause in select similarity. For example a where can be "rating > 3.0 and (state = 'NV' or state = 'CA')" Returns: List of Documents most similar to the query """ docs_and_scores = self.similarity_search_with_score(query, k=k, where= where, metadatas=metadatas, **kwargs) return [doc for doc, _ in docs_and_scores]
Return Jaguar documents most similar to query, along with scores. Args: query: Text to look up documents similar to. k: Number of Documents to return. Defaults to 5. where: the where clause in select similarity. For example a where can be "rating > 3.0 and (state = 'NV' or state = 'CA')" Returns: List of Documents most similar to the query
worker
old_stdout = sys.stdout sys.stdout = mystdout = StringIO() try: exec(command, globals, locals) sys.stdout = old_stdout queue.put(mystdout.getvalue()) except Exception as e: sys.stdout = old_stdout queue.put(repr(e))
@classmethod def worker(cls, command: str, globals: Optional[Dict], locals: Optional[ Dict], queue: multiprocessing.Queue) ->None: old_stdout = sys.stdout sys.stdout = mystdout = StringIO() try: exec(command, globals, locals) sys.stdout = old_stdout queue.put(mystdout.getvalue()) except Exception as e: sys.stdout = old_stdout queue.put(repr(e))
null
structured_tool_input
"""Return the arguments directly.""" return f'{arg1} {arg2} {arg3}'
@tool def structured_tool_input(arg1: int, arg2: bool, arg3: Optional[dict]=None ) ->str: """Return the arguments directly.""" return f'{arg1} {arg2} {arg3}'
Return the arguments directly.
test_neo4jvector_relevance_score
"""Test to make sure the relevance score is scaled to 0-1.""" metadatas = [{'page': str(i)} for i in range(len(texts))] docsearch = Neo4jVector.from_texts(texts=texts, embedding= FakeEmbeddingsWithOsDimension(), metadatas=metadatas, url=url, username =username, password=password, pre_delete_collection=True) output = docsearch.similarity_search_with_relevance_scores('foo', k=3) assert output == [(Document(page_content='foo', metadata={'page': '0'}), 1.0), (Document(page_content='bar', metadata={'page': '1'}), 0.9998376369476318), (Document(page_content='baz', metadata={'page': '2'}), 0.9993523359298706)] drop_vector_indexes(docsearch)
def test_neo4jvector_relevance_score() ->None: """Test to make sure the relevance score is scaled to 0-1.""" metadatas = [{'page': str(i)} for i in range(len(texts))] docsearch = Neo4jVector.from_texts(texts=texts, embedding= FakeEmbeddingsWithOsDimension(), metadatas=metadatas, url=url, username=username, password=password, pre_delete_collection=True) output = docsearch.similarity_search_with_relevance_scores('foo', k=3) assert output == [(Document(page_content='foo', metadata={'page': '0'}), 1.0), (Document(page_content='bar', metadata={'page': '1'}), 0.9998376369476318), (Document(page_content='baz', metadata={'page': '2'}), 0.9993523359298706)] drop_vector_indexes(docsearch)
Test to make sure the relevance score is scaled to 0-1.
add_texts
"""Add the given texts to the store (insert behavior).""" raise NotImplementedError()
def add_texts(self, texts: Iterable[str], metadatas: Optional[List[Dict[Any, Any]]]=None, **kwargs: Any) ->List[str]: """Add the given texts to the store (insert behavior).""" raise NotImplementedError()
Add the given texts to the store (insert behavior).
_identifying_params
"""Get the identifying parameters.""" return {'model_id': self.model_id, 'model_kwargs': self.model_kwargs, 'pipeline_kwargs': self.pipeline_kwargs}
@property def _identifying_params(self) ->Mapping[str, Any]: """Get the identifying parameters.""" return {'model_id': self.model_id, 'model_kwargs': self.model_kwargs, 'pipeline_kwargs': self.pipeline_kwargs}
Get the identifying parameters.
create_ernie_fn_chain
"""[Legacy] Create an LLM chain that uses Ernie functions. Args: functions: A sequence of either dictionaries, pydantic.BaseModels classes, or Python functions. If dictionaries are passed in, they are assumed to already be a valid Ernie functions. If only a single function is passed in, then it will be enforced that the model use that function. pydantic.BaseModels and Python functions should have docstrings describing what the function does. For best results, pydantic.BaseModels should have descriptions of the parameters and Python functions should have Google Python style args descriptions in the docstring. Additionally, Python functions should only use primitive types (str, int, float, bool) or pydantic.BaseModels for arguments. llm: Language model to use, assumed to support the Ernie function-calling API. prompt: BasePromptTemplate to pass to the model. output_key: The key to use when returning the output in LLMChain.__call__. output_parser: BaseLLMOutputParser to use for parsing model outputs. By default will be inferred from the function types. If pydantic.BaseModels are passed in, then the OutputParser will try to parse outputs using those. Otherwise model outputs will simply be parsed as JSON. If multiple functions are passed in and they are not pydantic.BaseModels, the chain output will include both the name of the function that was returned and the arguments to pass to the function. Returns: An LLMChain that will pass in the given functions to the model when run. Example: .. code-block:: python from typing import Optional from langchain.chains.ernie_functions import create_ernie_fn_chain from langchain_community.chat_models import ErnieBotChat from langchain.prompts import ChatPromptTemplate from langchain.pydantic_v1 import BaseModel, Field class RecordPerson(BaseModel): ""\"Record some identifying information about a person.""\" name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") class RecordDog(BaseModel): ""\"Record some identifying information about a dog.""\" name: str = Field(..., description="The dog's name") color: str = Field(..., description="The dog's color") fav_food: Optional[str] = Field(None, description="The dog's favorite food") llm = ErnieBotChat(model_name="ERNIE-Bot-4") prompt = ChatPromptTemplate.from_messages( [ ("user", "Make calls to the relevant function to record the entities in the following input: {input}"), ("assistant", "OK!"), ("user", "Tip: Make sure to answer in the correct format"), ] ) chain = create_ernie_fn_chain([RecordPerson, RecordDog], llm, prompt) chain.run("Harry was a chubby brown beagle who loved chicken") # -> RecordDog(name="Harry", color="brown", fav_food="chicken") """ if not functions: raise ValueError('Need to pass in at least one function. Received zero.') ernie_functions = [convert_to_ernie_function(f) for f in functions] output_parser = output_parser or get_ernie_output_parser(functions) llm_kwargs: Dict[str, Any] = {'functions': ernie_functions} if len(ernie_functions) == 1: llm_kwargs['function_call'] = {'name': ernie_functions[0]['name']} llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser, llm_kwargs=llm_kwargs, output_key=output_key, **kwargs) return llm_chain
def create_ernie_fn_chain(functions: Sequence[Union[Dict[str, Any], Type[ BaseModel], Callable]], llm: BaseLanguageModel, prompt: BasePromptTemplate, *, output_key: str='function', output_parser: Optional[BaseLLMOutputParser]=None, **kwargs: Any) ->LLMChain: """[Legacy] Create an LLM chain that uses Ernie functions. Args: functions: A sequence of either dictionaries, pydantic.BaseModels classes, or Python functions. If dictionaries are passed in, they are assumed to already be a valid Ernie functions. If only a single function is passed in, then it will be enforced that the model use that function. pydantic.BaseModels and Python functions should have docstrings describing what the function does. For best results, pydantic.BaseModels should have descriptions of the parameters and Python functions should have Google Python style args descriptions in the docstring. Additionally, Python functions should only use primitive types (str, int, float, bool) or pydantic.BaseModels for arguments. llm: Language model to use, assumed to support the Ernie function-calling API. prompt: BasePromptTemplate to pass to the model. output_key: The key to use when returning the output in LLMChain.__call__. output_parser: BaseLLMOutputParser to use for parsing model outputs. By default will be inferred from the function types. If pydantic.BaseModels are passed in, then the OutputParser will try to parse outputs using those. Otherwise model outputs will simply be parsed as JSON. If multiple functions are passed in and they are not pydantic.BaseModels, the chain output will include both the name of the function that was returned and the arguments to pass to the function. Returns: An LLMChain that will pass in the given functions to the model when run. Example: .. code-block:: python from typing import Optional from langchain.chains.ernie_functions import create_ernie_fn_chain from langchain_community.chat_models import ErnieBotChat from langchain.prompts import ChatPromptTemplate from langchain.pydantic_v1 import BaseModel, Field class RecordPerson(BaseModel): ""\"Record some identifying information about a person.""\" name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") class RecordDog(BaseModel): ""\"Record some identifying information about a dog.""\" name: str = Field(..., description="The dog's name") color: str = Field(..., description="The dog's color") fav_food: Optional[str] = Field(None, description="The dog's favorite food") llm = ErnieBotChat(model_name="ERNIE-Bot-4") prompt = ChatPromptTemplate.from_messages( [ ("user", "Make calls to the relevant function to record the entities in the following input: {input}"), ("assistant", "OK!"), ("user", "Tip: Make sure to answer in the correct format"), ] ) chain = create_ernie_fn_chain([RecordPerson, RecordDog], llm, prompt) chain.run("Harry was a chubby brown beagle who loved chicken") # -> RecordDog(name="Harry", color="brown", fav_food="chicken") """ if not functions: raise ValueError( 'Need to pass in at least one function. Received zero.') ernie_functions = [convert_to_ernie_function(f) for f in functions] output_parser = output_parser or get_ernie_output_parser(functions) llm_kwargs: Dict[str, Any] = {'functions': ernie_functions} if len(ernie_functions) == 1: llm_kwargs['function_call'] = {'name': ernie_functions[0]['name']} llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser= output_parser, llm_kwargs=llm_kwargs, output_key=output_key, **kwargs) return llm_chain
[Legacy] Create an LLM chain that uses Ernie functions. Args: functions: A sequence of either dictionaries, pydantic.BaseModels classes, or Python functions. If dictionaries are passed in, they are assumed to already be a valid Ernie functions. If only a single function is passed in, then it will be enforced that the model use that function. pydantic.BaseModels and Python functions should have docstrings describing what the function does. For best results, pydantic.BaseModels should have descriptions of the parameters and Python functions should have Google Python style args descriptions in the docstring. Additionally, Python functions should only use primitive types (str, int, float, bool) or pydantic.BaseModels for arguments. llm: Language model to use, assumed to support the Ernie function-calling API. prompt: BasePromptTemplate to pass to the model. output_key: The key to use when returning the output in LLMChain.__call__. output_parser: BaseLLMOutputParser to use for parsing model outputs. By default will be inferred from the function types. If pydantic.BaseModels are passed in, then the OutputParser will try to parse outputs using those. Otherwise model outputs will simply be parsed as JSON. If multiple functions are passed in and they are not pydantic.BaseModels, the chain output will include both the name of the function that was returned and the arguments to pass to the function. Returns: An LLMChain that will pass in the given functions to the model when run. Example: .. code-block:: python from typing import Optional from langchain.chains.ernie_functions import create_ernie_fn_chain from langchain_community.chat_models import ErnieBotChat from langchain.prompts import ChatPromptTemplate from langchain.pydantic_v1 import BaseModel, Field class RecordPerson(BaseModel): """Record some identifying information about a person.""" name: str = Field(..., description="The person's name") age: int = Field(..., description="The person's age") fav_food: Optional[str] = Field(None, description="The person's favorite food") class RecordDog(BaseModel): """Record some identifying information about a dog.""" name: str = Field(..., description="The dog's name") color: str = Field(..., description="The dog's color") fav_food: Optional[str] = Field(None, description="The dog's favorite food") llm = ErnieBotChat(model_name="ERNIE-Bot-4") prompt = ChatPromptTemplate.from_messages( [ ("user", "Make calls to the relevant function to record the entities in the following input: {input}"), ("assistant", "OK!"), ("user", "Tip: Make sure to answer in the correct format"), ] ) chain = create_ernie_fn_chain([RecordPerson, RecordDog], llm, prompt) chain.run("Harry was a chubby brown beagle who loved chicken") # -> RecordDog(name="Harry", color="brown", fav_food="chicken")
on_agent_finish
if self._current_thought is not None: self._current_thought.complete(self._thought_labeler. get_final_agent_thought_label()) self._current_thought = None
def on_agent_finish(self, finish: AgentFinish, color: Optional[str]=None, **kwargs: Any) ->None: if self._current_thought is not None: self._current_thought.complete(self._thought_labeler. get_final_agent_thought_label()) self._current_thought = None
null
_wait_until
"""Sleeps until meth() evaluates to true. Passes kwargs into meth. """ start = datetime.now() while not method(**method_params): curr = datetime.now() if (curr - start).total_seconds() * 1000 > timeout: raise TimeoutError(f'{method} timed out at {timeout} ms') sleep(RocksetChatMessageHistory.SLEEP_INTERVAL_MS / 1000)
def _wait_until(self, method: Callable, timeout: int, **method_params: Any ) ->None: """Sleeps until meth() evaluates to true. Passes kwargs into meth. """ start = datetime.now() while not method(**method_params): curr = datetime.now() if (curr - start).total_seconds() * 1000 > timeout: raise TimeoutError(f'{method} timed out at {timeout} ms') sleep(RocksetChatMessageHistory.SLEEP_INTERVAL_MS / 1000)
Sleeps until meth() evaluates to true. Passes kwargs into meth.
test_parse_api_operations
"""Test the APIOperation class.""" for spec_name, spec, path, method in http_paths_and_methods(): try: APIOperation.from_openapi_spec(spec, path, method) except Exception as e: raise AssertionError(f'Error processing {spec_name}: {e} ') from e
@pytest.mark.requires('openapi_pydantic') def test_parse_api_operations() ->None: """Test the APIOperation class.""" for spec_name, spec, path, method in http_paths_and_methods(): try: APIOperation.from_openapi_spec(spec, path, method) except Exception as e: raise AssertionError(f'Error processing {spec_name}: {e} ') from e
Test the APIOperation class.
memory_variables
"""The string keys this memory class will add to chain inputs."""
@property @abstractmethod def memory_variables(self) ->List[str]: """The string keys this memory class will add to chain inputs."""
The string keys this memory class will add to chain inputs.
test_chat_openai_system_message
"""Test ChatOpenAI wrapper with system message.""" chat = ChatOpenAI(max_tokens=10) 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_openai_system_message() ->None: """Test ChatOpenAI wrapper with system message.""" chat = ChatOpenAI(max_tokens=10) 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 ChatOpenAI wrapper with system message.
test_get_code_lines_simple_nested_ticks
"""Test that backticks w/o a newline are ignored.""" text = """ Unrelated text ```bash echo hello echo "```bash is in this string```" ``` """ code_lines = output_parser.parse_folder(text) assert code_lines == ['echo hello', 'echo "```bash is in this string```"']
def test_get_code_lines_simple_nested_ticks(output_parser: BashOutputParser ) ->None: """Test that backticks w/o a newline are ignored.""" text = ( '\nUnrelated text\n```bash\necho hello\necho "```bash is in this string```"\n```\n' ) code_lines = output_parser.parse_folder(text) assert code_lines == ['echo hello', 'echo "```bash is in this string```"']
Test that backticks w/o a newline are ignored.
test_partial_init_string
"""Test prompt can be initialized with partial variables.""" template = 'This is a {foo} test.' prompt = PromptTemplate(input_variables=[], template=template, partial_variables={'foo': 1}) assert prompt.template == template assert prompt.input_variables == [] result = prompt.format() assert result == 'This is a 1 test.'
def test_partial_init_string() ->None: """Test prompt can be initialized with partial variables.""" template = 'This is a {foo} test.' prompt = PromptTemplate(input_variables=[], template=template, partial_variables={'foo': 1}) assert prompt.template == template assert prompt.input_variables == [] result = prompt.format() assert result == 'This is a 1 test.'
Test prompt can be initialized with partial variables.
from_texts
"""Return DashVector VectorStore initialized from texts and embeddings. This is the quick way to get started with dashvector vector store. Example: .. code-block:: python from langchain_community.vectorstores import DashVector from langchain_community.embeddings import OpenAIEmbeddings import dashvector embeddings = OpenAIEmbeddings() dashvector = DashVector.from_documents( docs, embeddings, dashvector_api_key="{DASHVECTOR_API_KEY}" ) """ try: import dashvector except ImportError: raise ValueError( 'Could not import dashvector python package. Please install it with `pip install dashvector`.' ) dashvector_api_key = dashvector_api_key or get_from_env('dashvector_api_key', 'DASHVECTOR_API_KEY') dashvector_endpoint = dashvector_endpoint or get_from_env('dashvector_endpoint' , 'DASHVECTOR_ENDPOINT', default='dashvector.cn-hangzhou.aliyuncs.com') dashvector_client = dashvector.Client(api_key=dashvector_api_key, endpoint= dashvector_endpoint) dashvector_client.delete(collection_name) collection = dashvector_client.get(collection_name) if not collection: dim = len(embedding.embed_query(texts[0])) resp = dashvector_client.create(collection_name, dimension=dim) if resp: collection = dashvector_client.get(collection_name) else: raise ValueError(f'Fail to create collection. Error: {resp.message}.') dashvector_vector_db = cls(collection, embedding, text_field) dashvector_vector_db.add_texts(texts, metadatas, ids, batch_size) return dashvector_vector_db
@classmethod def from_texts(cls, texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]]=None, dashvector_api_key: Optional[str]=None, dashvector_endpoint: Optional[str]=None, collection_name: str= 'langchain', text_field: str='text', batch_size: int=25, ids: Optional[ List[str]]=None, **kwargs: Any) ->DashVector: """Return DashVector VectorStore initialized from texts and embeddings. This is the quick way to get started with dashvector vector store. Example: .. code-block:: python from langchain_community.vectorstores import DashVector from langchain_community.embeddings import OpenAIEmbeddings import dashvector embeddings = OpenAIEmbeddings() dashvector = DashVector.from_documents( docs, embeddings, dashvector_api_key="{DASHVECTOR_API_KEY}" ) """ try: import dashvector except ImportError: raise ValueError( 'Could not import dashvector python package. Please install it with `pip install dashvector`.' ) dashvector_api_key = dashvector_api_key or get_from_env( 'dashvector_api_key', 'DASHVECTOR_API_KEY') dashvector_endpoint = dashvector_endpoint or get_from_env( 'dashvector_endpoint', 'DASHVECTOR_ENDPOINT', default= 'dashvector.cn-hangzhou.aliyuncs.com') dashvector_client = dashvector.Client(api_key=dashvector_api_key, endpoint=dashvector_endpoint) dashvector_client.delete(collection_name) collection = dashvector_client.get(collection_name) if not collection: dim = len(embedding.embed_query(texts[0])) resp = dashvector_client.create(collection_name, dimension=dim) if resp: collection = dashvector_client.get(collection_name) else: raise ValueError( f'Fail to create collection. Error: {resp.message}.') dashvector_vector_db = cls(collection, embedding, text_field) dashvector_vector_db.add_texts(texts, metadatas, ids, batch_size) return dashvector_vector_db
Return DashVector VectorStore initialized from texts and embeddings. This is the quick way to get started with dashvector vector store. Example: .. code-block:: python from langchain_community.vectorstores import DashVector from langchain_community.embeddings import OpenAIEmbeddings import dashvector embeddings = OpenAIEmbeddings() dashvector = DashVector.from_documents( docs, embeddings, dashvector_api_key="{DASHVECTOR_API_KEY}" )
_get_internal_distance_strategy
"""Return the internal distance strategy.""" if self.distance_strategy == DistanceStrategy.EUCLIDEAN_DISTANCE: return 'euclidean' elif self.distance_strategy == DistanceStrategy.MAX_INNER_PRODUCT: raise ValueError('Max inner product is not supported by SemaDB') elif self.distance_strategy == DistanceStrategy.DOT_PRODUCT: return 'dot' elif self.distance_strategy == DistanceStrategy.JACCARD: raise ValueError('Max inner product is not supported by SemaDB') elif self.distance_strategy == DistanceStrategy.COSINE: return 'cosine' else: raise ValueError(f'Unknown distance strategy {self.distance_strategy}')
def _get_internal_distance_strategy(self) ->str: """Return the internal distance strategy.""" if self.distance_strategy == DistanceStrategy.EUCLIDEAN_DISTANCE: return 'euclidean' elif self.distance_strategy == DistanceStrategy.MAX_INNER_PRODUCT: raise ValueError('Max inner product is not supported by SemaDB') elif self.distance_strategy == DistanceStrategy.DOT_PRODUCT: return 'dot' elif self.distance_strategy == DistanceStrategy.JACCARD: raise ValueError('Max inner product is not supported by SemaDB') elif self.distance_strategy == DistanceStrategy.COSINE: return 'cosine' else: raise ValueError(f'Unknown distance strategy {self.distance_strategy}')
Return the internal distance strategy.
test_misannotated_base_tool_raises_error
"""Test that a BaseTool with the incorrect typehint raises an exception.""" with pytest.raises(SchemaAnnotationError): class _MisAnnotatedTool(BaseTool): name: str = 'structured_api' args_schema: BaseModel = _MockSchema description: str = 'A Structured Tool' def _run(self, arg1: int, arg2: bool, arg3: Optional[dict]=None) ->str: return f'{arg1} {arg2} {arg3}' async def _arun(self, arg1: int, arg2: bool, arg3: Optional[dict]=None ) ->str: raise NotImplementedError
def test_misannotated_base_tool_raises_error() ->None: """Test that a BaseTool with the incorrect typehint raises an exception.""" with pytest.raises(SchemaAnnotationError): class _MisAnnotatedTool(BaseTool): name: str = 'structured_api' args_schema: BaseModel = _MockSchema description: str = 'A Structured Tool' def _run(self, arg1: int, arg2: bool, arg3: Optional[dict]=None ) ->str: return f'{arg1} {arg2} {arg3}' async def _arun(self, arg1: int, arg2: bool, arg3: Optional[ dict]=None) ->str: raise NotImplementedError
Test that a BaseTool with the incorrect typehint raises an exception.
_get_input_messages
from langchain_core.messages import BaseMessage if isinstance(input_val, str): from langchain_core.messages import HumanMessage return [HumanMessage(content=input_val)] elif isinstance(input_val, BaseMessage): return [input_val] elif isinstance(input_val, (list, tuple)): return list(input_val) else: raise ValueError( f'Expected str, BaseMessage, List[BaseMessage], or Tuple[BaseMessage]. Got {input_val}.' )
def _get_input_messages(self, input_val: Union[str, BaseMessage, Sequence[ BaseMessage]]) ->List[BaseMessage]: from langchain_core.messages import BaseMessage if isinstance(input_val, str): from langchain_core.messages import HumanMessage return [HumanMessage(content=input_val)] elif isinstance(input_val, BaseMessage): return [input_val] elif isinstance(input_val, (list, tuple)): return list(input_val) else: raise ValueError( f'Expected str, BaseMessage, List[BaseMessage], or Tuple[BaseMessage]. Got {input_val}.' )
null
_select_relevance_score_fn
""" The underlying API calls already returns a "score proper", i.e. one in [0, 1] where higher means more *similar*, so here the final score transformation is not reversing the interval: """ return self._dont_flip_the_cos_score
def _select_relevance_score_fn(self) ->Callable[[float], float]: """ The underlying API calls already returns a "score proper", i.e. one in [0, 1] where higher means more *similar*, so here the final score transformation is not reversing the interval: """ return self._dont_flip_the_cos_score
The underlying API calls already returns a "score proper", i.e. one in [0, 1] where higher means more *similar*, so here the final score transformation is not reversing the interval:
generate_img_summaries
""" Generate summaries for images :param img_base64_list: Base64 encoded images :return: List of image summaries and processed images """ image_summaries = [] processed_images = [] prompt = 'Give a detailed summary of the image.' for i, base64_image in enumerate(img_base64_list): try: image_summaries.append(image_summarize(base64_image, prompt)) processed_images.append(base64_image) except Exception as e: print(f'Error with image {i + 1}: {e}') return image_summaries, processed_images
def generate_img_summaries(img_base64_list): """ Generate summaries for images :param img_base64_list: Base64 encoded images :return: List of image summaries and processed images """ image_summaries = [] processed_images = [] prompt = 'Give a detailed summary of the image.' for i, base64_image in enumerate(img_base64_list): try: image_summaries.append(image_summarize(base64_image, prompt)) processed_images.append(base64_image) except Exception as e: print(f'Error with image {i + 1}: {e}') return image_summaries, processed_images
Generate summaries for images :param img_base64_list: Base64 encoded images :return: List of image summaries and processed images