The multiline option is added to the input_variables field in the add_new_variables_to_template function. This allows the field to accept multiline input, which can be useful in certain scenarios where multiple lines of text need to be entered.
The input_types in the add_new_variables_to_template function were incorrect. They were set to ["BaseLoader", "BaseOutputParser"] instead of ["Document", "BaseOutputParser"]. This fix ensures that the correct input types are used for the template field.
🔀 chore(main.py): add trailing commas to dictionary entries for improved readability
The multiline string in the value of the `my_user_python_function` key was not properly formatted. The double quotes were changed to triple quotes to match the Python docstring convention. Trailing commas were added to the dictionary entries for improved readability and maintainability.
The code now checks if the variable is already in the list before appending it to the custom_fields. Additionally, when removing old variables from the template, the code now also removes the variable from the custom_fields associated with the given name. This ensures that the custom_fields and template stay in sync with the input_variables.
The custom_fields attribute in the FrontendNode class now has a default value of defaultdict(list) instead of an empty list. This change ensures that custom_fields is always a defaultdict, which prevents potential errors when accessing or modifying the custom_fields attribute.
The 'name' field is added to the ValidatePromptRequest model to enhance data validation. This field will allow for more specific identification and validation of prompt names in the API.
✨ feat(validate.py): refactor post_validate_prompt function to improve code readability and maintainability
The parameter 'prompt' in the 'post_validate_prompt' function has been renamed to 'prompt_request' to improve clarity and avoid confusion with the 'prompt' variable used within the function. The function has also been refactored to improve code readability and maintainability by extracting logic into separate helper functions. The helper functions 'get_old_custom_fields', 'add_new_variables_to_template', 'remove_old_variables_from_template', and 'update_input_variables_field' have been added to handle specific tasks within the 'post_validate_prompt' function. This refactoring improves the overall structure and organization of the code.
🔖 chore(config.yaml): update documentation links for vectorstores and output parsers
Added documentation links for the following new modules:
- MongoDBChatMessageHistory
- ChatMessagePromptTemplate
- HumanMessagePromptTemplate
- SystemMessagePromptTemplate
- ChatPromptTemplate
Updated documentation links for the following existing modules:
- MongoDBAtlasVectorSearch
Also, added documentation links for the following output parsers:
- StructuredOutputParser
- ResponseSchema
The documentation links were added or updated to provide easy access to relevant documentation for each module and output parser.
The VERTEX_TYPE_MAP dictionary in constants.py has been refactored to use explicit import paths for each vertex type. This improves the readability and maintainability of the code by making it clear where each vertex type is coming from.
🔀 refactor(base.py): move FieldFormatters class to the top of the file for better organization
The import statement in the base.py file has been updated to import the field_formatters module instead of importing specific modules. This change improves maintainability and readability by reducing the number of import statements and consolidating them into a single import. Additionally, the FieldFormatters class has been moved to the top of the file for better organization and readability.
🐛 fix(base.py): remove "object" from CLASSES_TO_REMOVE list to prevent unnecessary removal
In validate.py, the input_types in the template_field for the "prompt" variable is updated to ["Document", "BaseOutputParser"] to accurately reflect the expected input types.
In base.py, the "object" class is removed from the CLASSES_TO_REMOVE list to prevent unnecessary removal of the "object" class from the FrontendNode class inheritance.
🐛 fix(GenericNode/index.tsx): remove unused imports and unused variable to improve code cleanliness
The extra blank line in the `types.py` file has been removed to improve the readability of the code. In the `GenericNode/index.tsx` file, unused imports and an unused variable have been removed to clean up the code and improve maintainability.
🔧 fix(documentloaders.py): add_extra_base_classes method to set base_classes and output_types for DocumentLoaderFrontNode
🔧 fix(textsplitters.py): add_extra_base_classes method to set base_classes and output_types for TextSplittersFrontendNode
🔧 fix(vectorstores.py): change field_type to "Document" for documents field in VectorStoreFrontendNode
🔧 fix(index.ts): add output_types field to APIClassType interface
The changes were made to add support for specifying output types in the FrontendNode class and its subclasses. This allows for more flexibility in defining the behavior and capabilities of the frontend nodes in the application.
📝 docs(chat.py): explain the need for building the root node before the rest of the graph
The root node in the graph was not being built before the rest of the graph, which caused issues when certain nodes required parameters that were not connected to them. By adding the missing build step for the root node, we ensure that all necessary connections and parameters are properly set up before building the rest of the graph. This improves the overall functionality and reliability of the chat module.
Added the documentation link for the PyPDFDirectoryLoader in the config.yaml file. This allows users to access the documentation on how to use the PyPDFDirectoryLoader for loading PDF documents.
The logger.debug() statements are added to provide more visibility into the process of creating the database and tables. This can be helpful for debugging and troubleshooting purposes.
The change is made to improve the logging of exceptions. Using logger.exception instead of logger.error allows the logger to log the full traceback of the exception, providing more detailed information for debugging purposes.
🔧 refactor(documentloaders.py): remove redundant code for adding fields in DocumentLoaderFrontNode class
The code in the DocumentLoaderFrontNode class has been refactored to extract the logic for building directory loader fields into a separate function called build_directory_loader_fields(). This improves code readability and maintainability by separating concerns and reducing duplication. The redundant code for adding fields in the DocumentLoaderFrontNode class has also been removed.
The default value of the "Persist" extra field in the VectorStoreFrontendNode class has been changed from True to False. This change was made to align the default value with the desired behavior of the application.
The output_key field is now only added to the template if the template type is not VectorStoreRetrieverMemory. This ensures that the output_key field is not added unnecessarily for templates of this type.
The `logger.exception(exc)` line has been added to log the exception that occurred. This will help with error handling and debugging by providing more information about the exception that caused the error.
The code now checks if the "retriever" key exists in the params dictionary and if the value has an "as_retriever" method. If it does, the value is replaced with the result of calling the "as_retriever" method. This change ensures that the "retriever" parameter is always an instance of the retriever object, preventing potential attribute errors later in the code.
The logic for updating memory keys in the `run.py` file has been refactored to use a loop and a try-except block. Instead of individually assigning values to `input_key`, `output_key`, and `memory_key`, the keys and attributes are now stored in lists. The loop iterates over the lists and attempts to set the attribute values using `setattr()`. If an attribute does not exist, a `ValueError` is caught and a debug log message is printed. This refactoring improves code readability and maintainability.
The code now checks if the langchain_object.prompt has a template attribute before adding it to the input_keys_response. This prevents potential errors if the template attribute is not present in the prompt object.
The `process_base_classes` method is added to the `FrontendNode` class. This method removes unwanted base classes specified in the `CLASSES_TO_REMOVE` list from the `base_classes` list. This ensures that only the desired base classes are included in the `base_classes` list. The method is then called in the `to_dict` method to ensure that the processed `base_classes` list is used when converting the `FrontendNode` instance to a dictionary.
This pull request addresses a bug related to WebSocket functionality
that was causing an empty error to be displayed. The bug resulted in
incorrect error-handling behavior within the WebSocket implementation,
leading to confusion and difficulties in identifying and resolving
issues.
By addressing this bug and improving the WebSocket error handling
mechanism, this pull request significantly enhances the overall
stability and reliability of the application.
The missing return statement caused the function to not return any value when the node_type is not "VertexAI". Adding the return statement ensures that the function returns the instantiated class object with the provided parameters in all cases.
🔧 fix(loading.py): remove empty lines
The type error for the service_account import in llm.py is ignored to prevent a linting error. In loading.py, empty lines were removed for code cleanliness.
The condition to check for the presence of "handle_keys" has been fixed to correctly check for its existence in the format_kwargs dictionary instead of the params dictionary. This ensures that the "handle_keys" list is properly populated when necessary.
The code was missing a condition to check if the variable is an instance of BaseOutputParser and has the "get_format_instructions" attribute. This condition is necessary to properly handle the variable and avoid potential errors.
The ChatVertexAI integration is temporarily commented out due to a bug that causes an AttributeError. This bug needs to be resolved before the integration can be activated again.
🔀 chore(custom_lists.py): add ChatVertexAI to the import statements for better modularity and extensibility
🔀 chore(custom_lists.py): add ChatVertexAI to the llm_type_to_cls_dict for better compatibility and flexibility
🔀 chore(llms.py): change required field for credentials to be optional for better user experience
🔀 chore(llms.py): add advanced and show fields for specific fields related to VertexAI for better configurability
The import statements in `custom_lists.py` have been reformatted to improve readability and maintainability. The `ChatVertexAI` class has been added to the import statements to enhance modularity and extensibility.
The `ChatVertexAI` class has been added to the `llm_type_to_cls_dict` dictionary in `custom_lists.py` to improve compatibility and flexibility.
In `llms.py`, the `required` field for the `credentials` field has been changed to be optional for a better user experience.
The `advanced` and `show` fields have been added to specific fields related to VertexAI in `llms.py` to provide better configurability.
The logic to find the matched_type in the Edge class has been simplified by removing unnecessary nested loops and using a single generator expression. This improves the readability and efficiency of the code.
🔧 chore(loading.py): call initialize_vertexai function when node_type is "VertexAI"
The `llm.py` file now includes a new function `initialize_vertexai` that initializes the VertexAI credentials if a `credentials` parameter is provided. This allows for the usage of VertexAI credentials in the application. In `loading.py`, the `initialize_vertexai` function is called when the `node_type` is "VertexAI", ensuring that the VertexAI credentials are properly initialized for that specific node type.
The condition for showing fields in the VertexAI class has been simplified to exclude specific field names. This improves readability and maintainability of the code.
📝 chore(llms.py): improve field configuration for VertexAI template and modify field type for "credentials"
The `add_extra_fields` method is modified to add an additional field called "credentials" for the VertexAI template. The field is of type "file" and is required. It allows the user to upload a JSON file as credentials. The `format_openai_field` method is also updated to handle the new "credentials" field.
The display_name field is added to the TemplateField object in the post_validate_prompt function. This field allows for a more user-friendly display of the variable name in the UI.
🐛 fix(process.py): handle missing inputs in process_graph_cached function
The function `build_langchain_object_with_caching` has been renamed to `build_sorted_vertices_with_caching` to provide a more descriptive name that accurately reflects its purpose. Additionally, the `process_graph_cached` function now handles cases where the `inputs` parameter is missing or empty by populating it with values from the `artifacts` dictionary. This ensures that all required inputs are properly set before running the graph.
Both caching mechanisms improve the performance of building the langchain object and sorted vertices, reducing redundant computations and improving overall efficiency.
The `build_langchain_object_with_caching` function now uses the `memoize_dict` decorator to cache the result of building the langchain object from the data graph. This improves performance by avoiding redundant computations when the same data graph is used multiple times.
The `stream_build` function now logs the exception that occurred during the flow building process using the `logger.exception` method. This improves error handling and provides more detailed information about the error in the logs.
The Edge class constructor now takes an additional parameter 'edge' which is a dictionary containing additional information about the edge. This information is used to set the source_handle, target_handle, and target_param attributes of the Edge class. This change allows for more flexibility and extensibility when working with edges in the graph.
🔧 refactor(base.py): add edge parameter to Edge class constructor to pass additional edge information
The unused imports have been removed to improve code cleanliness. The code in the _build_params method has been simplified by removing unnecessary conditions and loops. Default values are now added for string and prompt type parameters to ensure that they have a value even if not explicitly set.
🔧 fix(base.py): remove unused imports and simplify code in _build_params method
🐛 fix(interface/initialize/loading.py): handle BaseOutputParser instances in instantiate_prompt
The `optional_inputs` list in the `Vertex` class is now extended with the `input_types` from the `template_dicts` dictionary. This ensures that the `optional_inputs` list contains all the input types that are not required. In the `instantiate_prompt` function, if the `variable` is an instance of `BaseOutputParser` and has a `get_format_instructions` method, the `format_kwargs` dictionary is updated with the result of calling `get_format_instructions()`. This allows handling `BaseOutputParser` instances correctly in the `instantiate_prompt` function.
🐛 fix(base.py): add optional 'name' parameter to the format method in FieldFormatter
In loading.py, the error message when failing to build a connection to the database is now formatted in a more readable way. This improves the clarity of the error message and makes it easier to identify the cause of the issue.
In base.py, the format method in FieldFormatter now accepts an optional 'name' parameter. This allows for more flexibility when formatting the field and provides the ability to include the field name in the formatting process if needed.
The code now checks if the "handle_keys" key is present in the params dictionary. If it is not present, it creates an empty list and adds the input_variable to it. This ensures that the "handle_keys" list is always present and the input_variable is correctly added to it.
