create our own tool.

[SVyusti]

can we use the PythonFunction tool of LangFlow and create our own PythonFunction from our local directory and export it to langflow?
the pythonfunction could be called by other components

[dosubot[bot]]

Yes, you can create your own PythonFunction from your local directory and export it to LangFlow so that it can be called by other components. The PythonFunctionComponent class allows you to define a Python function and integrate it into LangFlow.

Here is a relevant code snippet:

from typing import Callable
from langflow.custom import CustomComponent
from langflow.custom.utils import get_function
from langflow.field_typing import Code

class PythonFunctionComponent(CustomComponent):
    display_name = "Python Function"
    description = "Define a Python function."
    icon = "Python"

    def build_config(self):
        return {
            "function_code": {
                "display_name": "Code",
                "info": "The code for the function.",
                "show": True,
            },
        }

    def build(self, function_code: Code) -> Callable:
        self.status = function_code
        func = get_function(function_code)
        return func

Additionally, LangFlow provides a more detailed implementation for creating custom Python functions using the Function and PythonFunctionTool classes. Here is an example:

from typing import Callable, Optional
from langflow.interface.importing.utils import get_function
from pydantic.v1 import BaseModel, validator
from langflow.utils import validate
from langchain.agents.tools import Tool

class Function(BaseModel):
    code: str
    function: Optional[Callable] = None
    imports: Optional[str] = None

    def __init__(self, **data):
        super().__init__(**data)

    @validator("code")
    def validate_func(cls, v):
        try:
            validate.eval_function(v)
        except Exception as e:
            raise e
        return v

    def get_function(self):
        function_name = validate.extract_function_name(self.code)
        return validate.create_function(self.code, function_name)

class PythonFunctionTool(Function, Tool):
    name: str = "Custom Tool"
    description: str
    code: str

    def ___init__(self, name: str, description: str, code: str):
        self.name = name
        self.description = description
        self.code = code
        self.func = get_function(self.code)
        super().__init__(name=name, description=description, func=self.func)

class PythonFunction(Function):
    code: str

This implementation allows you to define a Python function by providing the function code, which can then be validated and used by other components in LangFlow ^[1][2].

To continue talking to Dosu, mention @dosu.

[SVyusti]

what are langflow.field_types

[dosubot[bot]]

langflow.field_typing is a module in LangFlow that defines constants and type aliases used for creating custom Python functions. It includes a variety of types from LangChain and additional custom types, ensuring compatibility and integration with LangChain components.

Here's how it is structured and used:

1. Type Aliases and Classes: The module defines several type aliases and classes to represent different types of data structures and components.

   from typing import Callable, Dict, Text, Union
   
   from langchain.agents.agent import AgentExecutor
   from langchain.chains.base import Chain
   from langchain.document_loaders.base import BaseLoader
   from langchain.llms.base import BaseLLM
   from langchain.memory.chat_memory import BaseChatMemory
   from langchain.prompts import BasePromptTemplate, ChatPromptTemplate, PromptTemplate
   from langchain.schema import BaseOutputParser, BaseRetriever, Document
   from langchain.schema.embeddings import Embeddings
   from langchain.schema.language_model import BaseLanguageModel
   from langchain.schema.memory import BaseMemory
   from langchain.text_splitter import TextSplitter
   from langchain.tools import Tool
   from langchain_community.vectorstores import VectorStore
   
   # Type alias for more complex dicts
   NestedDict = Dict[str, Union[str, Dict]]
   
   class Object:
       pass
   
   class Data:
       pass
   
   class Prompt:
       pass
   
   class Code:
       pass

2. LangChain Base Types: The module includes a dictionary of LangChain base types, which are essential for defining the structure and behavior of custom components.

   LANGCHAIN_BASE_TYPES = {
       "Chain": Chain,
       "AgentExecutor": AgentExecutor,
       "Tool": Tool,
       "BaseLLM": BaseLLM,
       "BaseLanguageModel": BaseLanguageModel,
       "PromptTemplate": PromptTemplate,
       "ChatPromptTemplate": ChatPromptTemplate,
       "BasePromptTemplate": BasePromptTemplate,
       "BaseLoader": BaseLoader,
       "Document": Document,
       "TextSplitter": TextSplitter,
       "VectorStore": VectorStore,
       "Embeddings": Embeddings,
       "BaseRetriever": BaseRetriever,
       "BaseOutputParser": BaseOutputParser,
       "BaseMemory": BaseMemory,
       "BaseChatMemory": BaseChatMemory,
   }

3. Custom Component Supported Types: The module also defines a dictionary that combines LangChain base types with additional custom types and Python base types, which can be used in custom functions.

   CUSTOM_COMPONENT_SUPPORTED_TYPES = {
       **LANGCHAIN_BASE_TYPES,
       "NestedDict": NestedDict,
       "Data": Data,
       "Text": Text,
       "Object": Object,
       "Callable": Callable,
       "Prompt": Prompt,
   }

In the context of creating custom Python functions for LangFlow, langflow.field_typing provides a standardized set of types that can be used to define the inputs and outputs of these functions, ensuring compatibility and integration with LangChain components ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[SVyusti]

can we create a tool which is a python function which will take add 2 numbers, in local and export it as a tool in langflow

[anshulyadav1976]

good morning

[SVyusti]

create a tool which uses PythonFunction tool and provide code for this pythonFunction

[dosubot[bot]]

Yes, you can create a tool using the PythonFunctionTool in LangFlow to add two numbers. Here is the code to define such a function and export it as a tool in LangFlow:

from typing import Callable, Optional
from pydantic.v1 import BaseModel, validator
from langflow.interface.custom.utils import get_function
from langflow.utils import validate
from langchain_core.tools import Tool

class Function(BaseModel):
    code: str
    function: Optional[Callable] = None
    imports: Optional[str] = None

    # Eval code and store the function
    def __init__(self, **data):
        super().__init__(**data)

    # Validate the function
    @validator("code")
    def validate_func(cls, v):
        try:
            validate.eval_function(v)
        except Exception as e:
            raise e
        return v

    def get_function(self):
        """Get the function"""
        function_name = validate.extract_function_name(self.code)
        return validate.create_function(self.code, function_name)

class PythonFunctionTool(Function, Tool):
    name: str = "Custom Tool"
    description: str
    code: str

    def __init__(self, name: str, description: str, code: str):
        self.name = name
        self.description = description
        self.code = code
        self.func = get_function(self.code)
        super().__init__(name=name, description=description, func=self.func)

# Define the function to add two numbers
function_code = """
def add_two_numbers(a, b):
    return a + b
"""

# Create an instance of the tool
tool = PythonFunctionTool(name="AddTwoNumbers", description="A tool to add two numbers", code=function_code)

# Get the function from the tool
add_function = tool.get_function()

# Example usage
result = add_function(3, 5)
print(result)  # Output should be 8

This code defines a Python function that adds two numbers and then uses the PythonFunctionTool to build and execute it ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[SVyusti]

can we import langflow PythonFunction directly and just provide code to it to make a new tool?

[dosubot[bot]]

Yes, you can import the PythonFunction directly from LangFlow and provide the code to it to create a new tool. Here is the relevant code snippet:

from typing import Callable, Optional
from langflow.interface.importing.utils import get_function
from pydantic.v1 import BaseModel, validator
from langflow.utils import validate
from langchain.agents.tools import Tool

class Function(BaseModel):
    code: str
    function: Optional[Callable] = None
    imports: Optional[str] = None

    def __init__(self, **data):
        super().__init__(**data)

    @validator("code")
    def validate_func(cls, v):
        try:
            validate.eval_function(v)
        except Exception as e:
            raise e
        return v

    def get_function(self):
        function_name = validate.extract_function_name(self.code)
        return validate.create_function(self.code, function_name)

class PythonFunctionTool(Function, Tool):
    name: str = "Custom Tool"
    description: str
    code: str

    def __init__(self, name: str, description: str, code: str):
        self.name = name
        self.description = description
        self.code = code
        self.func = get_function(self.code)
        super().__init__(name=name, description=description, func=self.func)

class PythonFunction(Function):
    code: str

You can use the get_function method to provide the function code and create a callable function ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[SVyusti]

@dosu how to use None in custom_component

[dosubot[bot]]

To handle None values in a custom component in LangFlow, you can follow these steps:

1. Check for None in Initialization:
   Ensure that critical parameters are not None during initialization. If they are, raise an appropriate exception.

   def __init__(self, code=None, function_entrypoint_name="build"):
       if code is None:
           raise TypeError("Code cannot be None")
       self.code = code
       self.function_entrypoint_name = function_entrypoint_name

2. Handle None in Method Calls:
   When calling methods that depend on certain attributes, check if they are None and handle them accordingly.

   def get_function(self):
       if self.code is None:
           raise ValueError("Code is not set")
       # Proceed with the function logic

3. Example Custom Component Class:
   Here is an example of a custom component that handles None values:

   from langflow.interface.custom.custom_component import CustomComponent
   from langflow.field_typing import BaseLanguageModel, Prompt
   from langchain_core.documents import Document
   from langchain.chains import LLMChain
   from langchain.prompts import PromptTemplate
   import requests
   
   class YourComponent(CustomComponent):
       display_name: str = "Your Component"
       description: str = "Your description"
       field_config = { "url": { "multiline": True, "required": True } }
   
       def build(self, url: str, llm: BaseLanguageModel, template: Prompt) -> Document:
           if url is None:
               raise ValueError("URL cannot be None")
           response = requests.get(url)
           prompt = PromptTemplate.from_template(template)
           chain = LLMChain(llm=llm, prompt=prompt)
           result = chain.run(response.text[:300])
           return Document(page_content=str(result))

4. State Management:
   Ensure that state management methods handle None values appropriately.

   def update_state(self, name: str, value: Any):
       if not self.vertex:
           raise ValueError("Vertex is not set")
       try:
           self.vertex.graph.update_state(name=name, record=value, caller=self.vertex.id)
       except Exception as e:
           raise ValueError(f"Error updating state: {e}")
   
   def stop(self):
       if not self.vertex:
           raise ValueError("Vertex is not set")
       try:
           self.graph.mark_branch(self.vertex.id, "INACTIVE")
       except Exception as e:
           raise ValueError(f"Error stopping {self.display_name}: {e}")

By following these patterns, you can ensure that your custom components in LangFlow handle None values appropriately, either by raising exceptions or by providing default behavior ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.