relative imports

[SVyusti]

when uploading custom components from directory to langflow, can we use relative imports of functions and constants in the custom component script

[dosubot[bot]]

Hey @SVyusti! I'm here to help you with any issues or questions you have. Let me know how I can assist you!

Langflow does not support relative imports for custom component scripts. The system is designed to work with absolute imports, and using relative imports might not be supported or could cause issues ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

i have created a directory named custom_components and added python scripts in it. I would like to import function from another component in the same directory, is this possible.
also when i tried this the component was not being built and could not be seen on the langflow interface

[dosubot[bot]]

Yes, it is possible to import a function from another component in the same custom_components directory. However, the component might not be built or visible on the Langflow interface if it is not properly registered or if there are issues with the import statements.

Ensure that your custom_component.py file is correctly implemented and that there are no errors in the code. Additionally, verify that the Langflow interface is correctly configured to recognize and display custom components.

Here is an example of how your __init__.py file should look:

from langflow.interface.custom.base import CustomComponentCreator
from langflow.interface.custom.custom_component import CustomComponent

__all__ = ["CustomComponentCreator", "CustomComponent"]

Make sure your component class inherits from CustomComponent and that all necessary methods are correctly defined. For example:

from langflow import CustomComponent
from langflow.field_typing import Data

class Component(CustomComponent):
    documentation: str = "http://docs.langflow.org/components/custom"

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: Data) -> Data:
        return param

Additionally, ensure that your custom component is included in the config.yaml file:

custom_components:
  CustomComponent:
    documentation: "https://docs.langflow.org/guidelines/custom-component"

And properly imported in the __init__.py file:

from langflow.custom.custom_component import CustomComponent

__all__ = ["CustomComponent"]

By following these steps, you can ensure that your custom component is properly built and visible on the Langflow interface ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

this is my current directory structure

[SVyusti]

directory structure:
custom_components
--document_processor.py
--test.py
--attribution.py
Now, how can I export the custom components to langflow and make imports of 1 component in another component

[dosubot[bot]]

To export your custom components to Langflow and set up imports between components within the same directory, follow these steps:

1. Define Your Custom Components: Ensure each Python file in your custom_components directory defines a class that inherits from CustomComponent.

2. Set Up Imports: Use absolute imports to import functions or classes from one component to another within the custom_components directory.

3. Export the Components: Ensure your components are properly exported and recognized by Langflow by modifying the __init__.py file in the custom_components directory.

Here is an example based on your directory structure:

document_processor.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class DocumentProcessor(CustomComponent):
    display_name = "Document Processor"
    description = "Processes documents."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        return Record(data=param)

test.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record
from custom_components.document_processor import DocumentProcessor  # Absolute import

class TestComponent(CustomComponent):
    display_name = "Test Component"
    description = "A test component that uses DocumentProcessor."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        processor = DocumentProcessor()
        processed_data = processor.build(param)
        return Record(data=processed_data.data)

attribution.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class AttributionComponent(CustomComponent):
    display_name = "Attribution Component"
    description = "Handles attributions."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        return Record(data=param)

__init__.py

from .document_processor import DocumentProcessor
from .test import TestComponent
from .attribution import AttributionComponent

__all__ = ["DocumentProcessor", "TestComponent", "AttributionComponent"]

Registering Components with Langflow

Ensure that Langflow recognizes your custom components by setting the LANGFLOW_COMPONENTS_PATH environment variable or using the --components-path argument when running the Langflow CLI.

export LANGFLOW_COMPONENTS_PATH='["/path/to/custom_components"]'
langflow run

or

langflow run --components-path /path/to/custom_components

By following these steps, your custom components should be properly exported and visible in the Langflow interface, and you can use absolute imports to reference one component from another within the same directory ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[SVyusti]

utils - Error while evaluating custom component code: Module document_processor not found. Please install it and try again.

[dosubot[bot]]

To resolve the "Module document_processor not found" error, ensure that your custom components are properly defined and included in the __init__.py file of the custom_components directory. Here are the steps to follow:

1. Ensure Proper Imports: Use absolute imports within your custom components.

2. Update __init__.py: Make sure all your custom components are imported and listed in the __init__.py file.

Here is an example based on your directory structure:

document_processor.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class DocumentProcessor(CustomComponent):
    display_name = "Document Processor"
    description = "Processes documents."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        return Record(data=param)

test.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record
from custom_components.document_processor import DocumentProcessor  # Absolute import

class TestComponent(CustomComponent):
    display_name = "Test Component"
    description = "A test component that uses DocumentProcessor."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        processor = DocumentProcessor()
        processed_data = processor.build(param)
        return Record(data=processed_data.data)

attribution.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record

class AttributionComponent(CustomComponent):
    display_name = "Attribution Component"
    description = "Handles attributions."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        return Record(data=param)

__init__.py

from .document_processor import DocumentProcessor
from .test import TestComponent
from .attribution import AttributionComponent

__all__ = ["DocumentProcessor", "TestComponent", "AttributionComponent"]

Registering Components with Langflow

Ensure that Langflow recognizes your custom components by setting the LANGFLOW_COMPONENTS_PATH environment variable or using the --components-path argument when running the Langflow CLI.

export LANGFLOW_COMPONENTS_PATH='["/path/to/custom_components"]'
langflow run

or

langflow run --components-path /path/to/custom_components

By following these steps, your custom components should be properly recognized and imported by Langflow ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[SVyusti]

absolute import is also not working

[dosubot[bot]]

To resolve the issue with absolute imports not working, ensure the following steps are correctly implemented:

1. Directory Structure: Verify that your directory structure is correct and that custom_components is a Python package (i.e., it contains an __init__.py file).

2. Environment Variable: Set the LANGFLOW_COMPONENTS_PATH environment variable to the path of your custom_components directory:

   export LANGFLOW_COMPONENTS_PATH='["/path/to/custom_components"]'
   langflow run

3. CLI Argument: Alternatively, specify the path to your custom components using the --components-path argument when running the Langflow CLI:

   langflow run --components-path /path/to/custom_components

4. Absolute Imports: Ensure you are using absolute imports correctly. For example, if your directory structure is:

   custom_components/
   ├── __init__.py
   ├── document_processor.py
   ├── test.py
   └── attribution.py
   

   Your import statements should look like this:

   test.py

   from custom_components.document_processor import DocumentProcessor

5. Component Code: Ensure your custom component code follows the required structure. For example:

   document_processor.py

   from langflow.interface.custom.custom_component import CustomComponent
   from langflow.schema import Document
   
   class DocumentProcessor(CustomComponent):
       display_name = "Document Processor"
       description = "This component processes a document"
   
       def build_config(self) -> dict:
           return {"param": {"display_name": "Parameter"}}
   
       def build(self, param: str) -> Document:
           return Document(page_content=param)

6. Initialization: Ensure that the __init__.py file in the custom_components directory imports all custom components:

   __init__.py

   from .document_processor import DocumentProcessor
   from .test import TestComponent
   from .attribution import AttributionComponent
   
   __all__ = ["DocumentProcessor", "TestComponent", "AttributionComponent"]

By following these steps, Langflow should recognize and import your custom components correctly. If issues persist, double-check the paths and ensure there are no typos or misconfigurations ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[SVyusti]

DocumentProcessor and AttributionComponent is being created, TestComponent is not being built

[dosubot[bot]]

To resolve the issue where TestComponent is not being built, despite DocumentProcessor and AttributionComponent being created successfully, follow these steps:

1. Ensure Correct Environment Variable: Verify that the LANGFLOW_COMPONENTS_PATH environment variable is correctly set and points to the directory containing your custom components.

2. Check Path Existence: Ensure the path specified in LANGFLOW_COMPONENTS_PATH exists and contains the TestComponent.

3. Validate Component Code: Ensure that the TestComponent class is correctly defined and follows the required structure.

Here is a checklist to help you troubleshoot:

Verify Environment Variable and Path

Run the following Python snippet to check if the environment variable and path are correctly set:

import os
from pathlib import Path

langflow_component_path = os.getenv("LANGFLOW_COMPONENTS_PATH")
if langflow_component_path:
    if Path(langflow_component_path).exists():
        print(f"Path exists: {langflow_component_path}")
    else:
        print(f"Path does not exist: {langflow_component_path}")
else:
    print("LANGFLOW_COMPONENTS_PATH is not set")

Example Component Code

Ensure your TestComponent is defined correctly:

test.py

from langflow.interface.custom.custom_component import CustomComponent
from langflow.schema import Record
from custom_components.document_processor import DocumentProcessor  # Absolute import

class TestComponent(CustomComponent):
    display_name = "Test Component"
    description = "A test component that uses DocumentProcessor."

    def build_config(self):
        return {"param": {"display_name": "Parameter"}}

    def build(self, param: str) -> Record:
        processor = DocumentProcessor()
        processed_data = processor.build(param)
        return Record(data=processed_data.data)

Ensure Proper Initialization

Make sure your __init__.py file in the custom_components directory includes all components:

__init__.py

from .document_processor import DocumentProcessor
from .test import TestComponent
from .attribution import AttributionComponent

__all__ = ["DocumentProcessor", "TestComponent", "AttributionComponent"]

Check Logs for Errors

Langflow logs specific error messages when it fails to build a custom component. Check the logs for any errors related to TestComponent. The logs can be found in the console or log file, depending on your logger configuration.

By following these steps, you should be able to identify and resolve the issue preventing TestComponent from being built ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

can I import functions from an already existing directory which is in the same virtual environment as langflow?

[dosubot[bot]]

Yes, you can import functions from an already existing directory in the same virtual environment as Langflow. To properly configure Langflow to recognize and import these custom components, follow these steps:

1. Create a Folder Structure: Ensure your custom components are organized in a directory structure similar to the one described below:

   .
   └── custom_components
       ├── document_processor.py
       └── ...
   └── agents
       └── ...
   └── my_agents <-- Other category
       └── ...
   

2. Create Custom Components: Create a Python script for each custom component. Each script should contain a single class that inherits from CustomComponent and includes a build method. Optionally, you can also include a build_config method to customize the component fields. Here is an example:

   from langflow import CustomComponent
   from langflow.field_typing import Data
   from langchain.schema import Document
   
   class DocumentProcessor(CustomComponent):
       display_name = "Document Processor"
       description = "This component processes a document"
       documentation = "http://docs.langflow.org/components/custom"
   
       def build_config(self) -> dict:
           options = ["Uppercase", "Lowercase", "Titlecase"]
           return {
               "function": {"options": options, "value": options[0], "display_name": "Function"},
               "document": {"display_name": "Document"}
           }
   
       def build(self, document: Data, function: str) -> Data:
           if isinstance(document, list):
               document = document[0]
           page_content = document.page_content
           if function == "Uppercase":
               page_content = page_content.upper()
           elif function == "Lowercase":
               page_content = page_content.lower()
           elif function == "Titlecase":
               page_content = page_content.title()
           self.repr_value = f"Result of {function} function: {page_content}"
           return Document(page_content=page_content)

3. Set the Environment Variable: Set the LANGFLOW_COMPONENTS_PATH environment variable to the path of your custom components directory. This can be done using the following command:

   export LANGFLOW_COMPONENTS_PATH='["/path/to/components"]'

4. Run Langflow CLI: Start Langflow using the CLI:

   langflow run

Alternatively, you can specify the path to your custom components using the --components-path argument when running the Langflow CLI:

langflow run --components-path /path/to/components

Langflow will attempt to load all the components found in the specified directory. If a component fails to load due to errors in the component's code, Langflow will print an error message to the console but will continue loading the rest of the components.

Once your custom components have been loaded successfully, they will appear in Langflow's sidebar. From there, you can add them to your Langflow canvas for use. Always ensure your code is error-free before attempting to load components.

To further assist with managing and validating your custom components, Langflow provides utility functions such as build_and_validate_all_files, build_valid_menu, and build_invalid_menu to help organize and debug your components. These functions can be found in the utils.py file of the directory_reader module. They help in building a list of valid and invalid components, logging errors, and merging component dictionaries. Here are some relevant functions:

def build_and_validate_all_files(reader: DirectoryReader, file_list):
    """Build and validate all files"""
    data = reader.build_component_menu_list(file_list)

    valid_components = reader.filter_loaded_components(data=data, with_errors=False)
    invalid_components = reader.filter_loaded_components(data=data, with_errors=True)

    return valid_components, invalid_components

def build_valid_menu(valid_components):
    """Build the valid menu."""
    valid_menu = {}
    for menu_item in valid_components["menu"]:
        menu_name = menu_item["name"]
        valid_menu[menu_name] = build_menu_items(menu_item)
    return valid_menu

def build_invalid_menu(invalid_components):
    """Build the invalid menu."""
    if not invalid_components.get("menu"):
        return {}

    invalid_menu = {}
    for menu_item in invalid_components["menu"]:
        menu_name = menu_item["name"]
        invalid_menu[menu_name] = build_invalid_menu_items(menu_item)
    return invalid_menu

These functions will help you manage and validate your custom components effectively ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[SVyusti]

create 2 files in local directory, one a python script and one a custom_component. Is it possible to import the python function in the custom_component and export it to langflow?

[dosubot[bot]]

Yes, it is possible to import a function from a Python script into a custom component and then export it to Langflow. Here are the steps to achieve this:

1. Create the Python Script: Define your function in a Python script.

   # my_functions.py
   def my_custom_function(x):
       return x * 2

2. Create the Custom Component: Import and use the function in your custom component.

   # custom_component.py
   from langflow.interface.custom.custom_component import CustomComponent
   from langflow.schema import Record
   from my_functions import my_custom_function  # Import the function
   
   class MyCustomComponent(CustomComponent):
       display_name = "My Custom Component"
       description = "A custom component that uses my_custom_function."
   
       def build_config(self):
           return {"param": {"display_name": "Parameter"}}
   
       def build(self, param: int) -> Record:
           result = my_custom_function(param)
           return Record(data=result)

3. Set Up the Directory Structure: Ensure your directory structure is correct and includes an __init__.py file to make it a package.

   custom_components/
   ├── __init__.py
   ├── my_functions.py
   └── custom_component.py
   

4. Update __init__.py: Ensure your __init__.py file imports the custom component.

   # __init__.py
   from .custom_component import MyCustomComponent
   
   __all__ = ["MyCustomComponent"]

5. Set the Environment Variable: Set the LANGFLOW_COMPONENTS_PATH environment variable to the path of your custom_components directory.

   export LANGFLOW_COMPONENTS_PATH='["/path/to/custom_components"]'
   langflow run

6. Run Langflow: Start Langflow using the CLI:

   langflow run

By following these steps, your custom component should be properly exported and visible in the Langflow interface, and you can use the function from the Python script within your custom component ^[1].

To continue talking to Dosu, mention @dosu.

[Cristhianzl]

Hi! 👋

We are using other channels as our official means of communication with users. We apologize for the delayed response.
For faster assistance, please direct your questions to our Discord channel or open a GitHub issue, as we are much more active on these platforms.

Langflow Discord Server

Thank you for your understanding.

Best regards,
The Langflow Team