How to import code from local modules into customcomponent file?

[arose26]

In creating custom components I wish to separate different helper functions of the code into files outside the CustomComponent derived class file. However, when I try to import another module into a customcomponent file, I get the error saying that the code cannot be found. This happens whether the module is in a subdirectory (e.g. helpers/codemodule.py) or just in the same directory as the component itself. What is the practice for separating code in a CustomComponent? The documentation is lacking on this.

[dosubot[bot]]

Based on your description, it seems like you're having trouble with Python's import system. Here are some best practices and steps to troubleshoot the issue:

1. Modularity: It's good practice to keep your code modular by separating distinct functionalities into different files. This makes the code easier to manage, test, and reuse.

2. Naming Conventions: Use clear and descriptive names for your files and functions. This helps other developers understand the purpose of each file and function at a glance.

3. Directory Structure: Organize your files in a logical directory structure. Common practices include having separate directories for models, services, utils, and interfaces.

4. Relative Imports: When importing modules from the same directory or a subdirectory, use relative imports to avoid issues with the Python path. For example, if you have a utility function in utils.py that you want to import into custom_component.py, you can use:

   from .utils import your_utility_function

   If the file is in a subdirectory, for example, a directory named helpers:

   from .helpers.utils import your_utility_function

5. Avoid Circular Imports: Circular imports occur when two or more modules depend on each other. This can lead to errors and is generally considered bad practice. To avoid this, you can use import statements within functions or use a more modular design.

6. Use __init__.py Files: In each directory, include an __init__.py file (which can be empty) to ensure the directory is treated as a Python package. This is necessary for relative imports to work correctly.

7. Error Handling for Imports: When organizing code across multiple files, it's possible to encounter import errors due to incorrect paths or circular dependencies. Ensure that your import statements are correct and consider using try-except blocks to handle optional dependencies gracefully.

To resolve the issue of importing modules indicating that the code cannot be found, ensure that:

• Your directory structure is correctly set up as a package with __init__.py files.
• You are using the correct relative import syntax based on the location of the files you are trying to import.
• There are no circular import issues.
• The Python interpreter is running with the correct working directory. If your script is deep in a package, you might need to adjust the way you run it or the way imports are done to ensure Python can find the modules.

Unfortunately, I wasn't able to find the exact directory structure of the CustomComponent implementation in the langflow codebase. If you could provide more details about the structure of your project and the exact error message you're encountering, I might be able to provide more specific advice.

I hope this helps! If you have any more questions, feel free to ask.

Sources

• src/backend/langflow/interface/custom/custom_component/custom_component.py

#### About Dosu

This response is meant to be useful and save you time. It is **not meant to be a precise solution**, but rather a starting point for your own research. Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant. If you want to continue the conversation, start your reply with @dosu-bot.

[arose26]

The import syntax works from a regular python file, but not from inside a CustomComponent. This is a problem specific to creating custom components. The error I get back is the following: \site-packages\\langflow\\utils\\validate.py", line 204, in prepare_global_scope\n raise ModuleNotFoundError(f"Module {node.module} not found. Please install it and try again.") from e\nModuleNotFoundError: Module helpers.custom_helpers not found. Please install it and try again.\n'}

[YamonBot]

I couldn't understand your question well, but I hope this helps. Try declaring the module you want to import at the beginning of the build method of the custom component. In LangFlow, it seems to operate with the feeling of copying the code of the build method and building it anew.

  build(self, ...  ){
     from yourmodule import yourclass

     module = yurclass() 

  }

[YamonBot]

Ah, you're talking about the new module of Langflow. My response was useless.

[arose26]

What I ended up doing was put my module of helper functions into the site-packages folder and now I can import it. I'm not sure if this is the right practice but for now it works.

[ogabrielluiz]

Hey all

I don't think this is a good practice but I think we can improve on that implementation.

Generally, we add the path to the PYTHONPATH for this to work, but we don't do that in Langflow.

We could add that in a patch now and it should help you with that.

I think adding your LANGFLOW_COMPONENTS_PATH to the sys.path.

Now, if you want to make it so a different folder becomes accessible, then we need to think of other ways of doing that. What do you think?

[YamonBot]

As a suggestion for the beta version of the LangFlow project, how about introducing a plugin concept? I've been trying my best to understand the structure of LangFlow, but due to my limited capabilities, it's challenging to follow everything and thus difficult to rashly extend concepts like LangFlow's manager or service. Notably, the "helper" concept, which extends beyond the basic functions of LangChain to allow for user-customized expansions, resembles the plugin systems seen in platforms like Figma or AUTO GPT.

Given that LangFlow already has a LangFlow Store implemented, it would be beneficial to add a system that differentiates and shares custom components and separate plugin components. Through this approach, users could select specific functionalities, such as timers and webhooks, according to their needs and install the necessary packages or modules, similar to NPM, at the directory level. This would not only reduce the overall size of the project but also make it more suitable for on-premise use.

To summarize, the proposal involves the addition of a plugin concept that is managed at the directory level, distinct from how custom components are currently placed in the src folder. Instead, a dedicated plugin folder would be established at the project root level, which the system would reference (with paths potentially provided via environment variables).

This configuration isn't meant to complicate matters but to enable the system to accommodate functionalities like webhooks, timers, trigger calls, or integration with services like Selenium Hub at the flow's granular levels by system-level package inclusion. If implemented, this could allow for more nuanced control and customization within the flow, enhancing the platform's flexibility and capability to cater to specific user needs or project requirements.

[YamonBot]

I believe LangFlow should actively benchmark against n8n, which incorporates a similar concept under the name "addons".