langflow-base-nightly 0.0.95.dev5__tar.gz → 0.0.95.dev8__tar.gz

langflow_base_nightly-0.0.95.dev8/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: langflow-base-nightly
+Version: 0.0.95.dev8
+Summary: A Python package with a built-in web application
+Home-page: https://github.com/langflow-ai/langflow
+License: MIT
+Keywords: nlp,langchain,openai,gpt,gui
+Author: Langflow
+Author-email: contact@langflow.org
+Maintainer: Carlos Coelho
+Maintainer-email: carlos@langflow.org
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: all
+Provides-Extra: deploy
+Provides-Extra: local
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
+Requires-Dist: alembic (>=1.13.0,<2.0.0)
+Requires-Dist: asyncer (>=0.0.5,<0.0.6)
+Requires-Dist: bcrypt (==4.0.1)
+Requires-Dist: cachetools (>=5.3.1,<6.0.0)
+Requires-Dist: chardet (>=5.2.0,<6.0.0)
+Requires-Dist: clickhouse-connect (==0.7.19)
+Requires-Dist: crewai (>=0.36.0,<0.37.0)
+Requires-Dist: cryptography (>=42.0.5,<44.0.0)
+Requires-Dist: diskcache (>=5.6.3,<6.0.0)
+Requires-Dist: docstring-parser (>=0.16,<0.17)
+Requires-Dist: duckdb (>=1.0.0,<2.0.0)
+Requires-Dist: emoji (>=2.12.0,<3.0.0)
+Requires-Dist: fastapi (>=0.111.0,<0.112.0)
+Requires-Dist: filelock (>=3.15.4,<4.0.0)
+Requires-Dist: firecrawl-py (>=0.0.16,<0.0.17)
+Requires-Dist: grandalf (>=0.8.0,<0.9.0)
+Requires-Dist: gunicorn (>=22.0.0,<23.0.0)
+Requires-Dist: httpx
+Requires-Dist: jq (>=1.7.0,<2.0.0) ; sys_platform != "win32"
+Requires-Dist: langchain (>=0.2.0,<0.3.0)
+Requires-Dist: langchain-core (>=0.2.32,<0.3.0)
+Requires-Dist: langchain-experimental (>=0.0.61,<0.0.62)
+Requires-Dist: langchainhub (>=0.1.15,<0.2.0)
+Requires-Dist: loguru (>=0.7.1,<0.8.0)
+Requires-Dist: multiprocess (>=0.70.14,<0.71.0)
+Requires-Dist: nanoid (>=2.0.0,<3.0.0)
+Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
+Requires-Dist: opentelemetry-api (>=1.25.0,<2.0.0)
+Requires-Dist: opentelemetry-exporter-prometheus (>=0.46b0,<0.47)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.46b0,<0.47)
+Requires-Dist: opentelemetry-sdk (>=1.25.0,<2.0.0)
+Requires-Dist: orjson (==3.10.0)
+Requires-Dist: pandas (==2.2.2)
+Requires-Dist: passlib (>=1.7.4,<2.0.0)
+Requires-Dist: pillow (>=10.2.0,<11.0.0)
+Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
+Requires-Dist: prometheus-client (>=0.20.0,<0.21.0)
+Requires-Dist: pydantic (>=2.7.0,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.2.0,<3.0.0)
+Requires-Dist: pypdf (>=4.2.0,<5.0.0)
+Requires-Dist: pyperclip (>=1.8.2,<2.0.0)
+Requires-Dist: python-docx (>=1.1.0,<2.0.0)
+Requires-Dist: python-jose (>=3.3.0,<4.0.0)
+Requires-Dist: python-multipart (>=0.0.7,<0.0.8)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: sentry-sdk[fastapi,loguru] (>=2.5.1,<3.0.0)
+Requires-Dist: setuptools (>=70)
+Requires-Dist: spider-client (>=0.0.27,<0.0.28)
+Requires-Dist: sqlmodel (>=0.0.18,<0.0.19)
+Requires-Dist: typer (>=0.12.0,<0.13.0)
+Requires-Dist: uncurl (>=0.0.11,<0.0.12)
+Requires-Dist: uvicorn (>=0.30.0,<0.31.0)
+Requires-Dist: websockets
+Project-URL: Documentation, https://docs.langflow.org
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Description-Content-Type: text/markdown
+
+

langflow_base_nightly-0.0.95.dev8/langflow/api/v1/variable.py

@@ -0,0 +1,105 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.exc import NoResultFound
+from sqlmodel import Session
+
+from langflow.services.auth.utils import get_current_active_user
+from langflow.services.database.models.user.model import User
+from langflow.services.database.models.variable import VariableCreate, VariableRead, VariableUpdate
+from langflow.services.deps import get_session, get_settings_service, get_variable_service
+from langflow.services.variable.base import VariableService
+from langflow.services.variable.constants import GENERIC_TYPE
+from langflow.services.variable.service import DatabaseVariableService
+
+router = APIRouter(prefix="/variables", tags=["Variables"])
+
+
+@router.post("/", response_model=VariableRead, status_code=201)
+def create_variable(
+    *,
+    session: Session = Depends(get_session),
+    variable: VariableCreate,
+    current_user: User = Depends(get_current_active_user),
+    settings_service=Depends(get_settings_service),
+    variable_service: DatabaseVariableService = Depends(get_variable_service),
+):
+    """Create a new variable."""
+    try:
+        if not variable.name and not variable.value:
+            raise HTTPException(status_code=400, detail="Variable name and value cannot be empty")
+
+        if not variable.name:
+            raise HTTPException(status_code=400, detail="Variable name cannot be empty")
+
+        if not variable.value:
+            raise HTTPException(status_code=400, detail="Variable value cannot be empty")
+
+        if variable.name in variable_service.list_variables(user_id=current_user.id, session=session):
+            raise HTTPException(status_code=400, detail="Variable name already exists")
+
+        return variable_service.create_variable(
+            user_id=current_user.id,
+            name=variable.name,
+            value=variable.value,
+            default_fields=variable.default_fields or [],
+            _type=variable.type or GENERIC_TYPE,
+            session=session,
+        )
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@router.get("/", response_model=list[VariableRead], status_code=200)
+def read_variables(
+    *,
+    session: Session = Depends(get_session),
+    current_user: User = Depends(get_current_active_user),
+    variable_service: DatabaseVariableService = Depends(get_variable_service),
+):
+    """Read all variables."""
+    try:
+        return variable_service.get_all(user_id=current_user.id, session=session)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@router.patch("/{variable_id}", response_model=VariableRead, status_code=200)
+def update_variable(
+    *,
+    session: Session = Depends(get_session),
+    variable_id: UUID,
+    variable: VariableUpdate,
+    current_user: User = Depends(get_current_active_user),
+    variable_service: DatabaseVariableService = Depends(get_variable_service),
+):
+    """Update a variable."""
+    try:
+        return variable_service.update_variable_fields(
+            user_id=current_user.id,
+            variable_id=variable_id,
+            variable=variable,
+            session=session,
+        )
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Variable not found")
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+@router.delete("/{variable_id}", status_code=204)
+def delete_variable(
+    *,
+    session: Session = Depends(get_session),
+    variable_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    variable_service: VariableService = Depends(get_variable_service),
+):
+    """Delete a variable."""
+    try:
+        variable_service.delete_variable_by_id(user_id=current_user.id, variable_id=variable_id, session=session)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e

langflow_base_nightly-0.0.95.dev8/langflow/components/tools/PythonREPLTool.py

@@ -0,0 +1,81 @@
+import importlib
+from typing import cast
+
+from langchain_experimental.utilities import PythonREPL
+
+from langflow.base.langchain_utilities.model import LCToolComponent
+from langflow.field_typing import Tool
+from langflow.io import MessageTextInput, MultiselectInput
+from langflow.schema.data import Data
+from langflow.template.field.base import Output
+
+
+class PythonREPLToolComponent(LCToolComponent):
+    display_name = "Python REPL Tool"
+    description = "A tool for running Python code in a REPL environment."
+    name = "PythonREPLTool"
+
+    inputs = [
+        MessageTextInput(name="input_value", display_name="Input", value=""),
+        MessageTextInput(name="name", display_name="Name", value="python_repl"),
+        MessageTextInput(
+            name="description",
+            display_name="Description",
+            value="A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with `print(...)`.",
+        ),
+        MultiselectInput(
+            name="global_imports",
+            display_name="Global Imports",
+            info="A list of modules to import globally, e.g. ['math', 'numpy'].",
+            value=["math"],
+            combobox=True,
+        ),
+    ]
+
+    outputs = [
+        Output(name="api_run_model", display_name="Data", method="run_model"),
+        # Keep this for backwards compatibility
+        Output(name="tool", display_name="Tool", method="build_tool"),
+    ]
+
+    def get_globals(self, globals: list[str]) -> dict:
+        """
+        Retrieves the global variables from the specified modules.
+
+        Args:
+            globals (list[str]): A list of module names.
+
+        Returns:
+            dict: A dictionary containing the global variables from the specified modules.
+        """
+        global_dict = {}
+        for module in globals:
+            try:
+                imported_module = importlib.import_module(module)
+                global_dict[imported_module.__name__] = imported_module
+            except ImportError:
+                raise ImportError(f"Could not import module {module}")
+        return global_dict
+
+    def build_tool(self) -> Tool:
+        """
+        Builds a Python REPL tool.
+
+        Returns:
+            Tool: The built Python REPL tool.
+        """
+        _globals = self.get_globals(self.global_imports)
+        python_repl = PythonREPL(_globals=_globals)
+        return cast(
+            Tool,
+            Tool(
+                name=self.name,
+                description=self.description,
+                func=python_repl.run,
+            ),
+        )
+
+    def run_model(self) -> Data:
+        tool = self.build_tool()
+        result = tool.invoke(self.input_value)
+        return Data(text=result)

langflow_base_nightly-0.0.95.dev8/langflow/components/tools/YfinanceTool.py

@@ -0,0 +1,35 @@
+from typing import cast
+
+from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
+
+from langflow.base.langchain_utilities.model import LCToolComponent
+from langflow.field_typing import Data, Tool
+from langflow.inputs.inputs import MessageTextInput
+from langflow.template.field.base import Output
+
+
+class YfinanceToolComponent(LCToolComponent):
+    display_name = "Yahoo Finance News Tool"
+    description = "Tool for interacting with Yahoo Finance News."
+    name = "YFinanceTool"
+
+    inputs = [
+        MessageTextInput(
+            name="input_value",
+            display_name="Query",
+            info="Input should be a company ticker. For example, AAPL for Apple, MSFT for Microsoft.",
+        )
+    ]
+
+    outputs = [
+        Output(name="api_run_model", display_name="Data", method="run_model"),
+        # Keep this for backwards compatibility
+        Output(name="tool", display_name="Tool", method="build_tool"),
+    ]
+
+    def build_tool(self) -> Tool:
+        return cast(Tool, YahooFinanceNewsTool())
+
+    def run_model(self) -> Data:
+        tool = self.build_tool()
+        return tool.run(self.input_value)

langflow_base_nightly-0.0.95.dev8/langflow/components/vectorstores/HCD.py

@@ -0,0 +1,320 @@
+from loguru import logger
+
+from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from langflow.helpers import docs_to_data
+from langflow.inputs import DictInput, FloatInput
+from langflow.io import (
+    BoolInput,
+    DataInput,
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    MultilineInput,
+    SecretStrInput,
+    StrInput,
+)
+from langflow.schema import Data
+
+
+class HCDVectorStoreComponent(LCVectorStoreComponent):
+    display_name: str = "Hyper-Converged Database"
+    description: str = "Implementation of Vector Store using Hyper-Converged Database (HCD) with search capabilities"
+    documentation: str = "https://python.langchain.com/docs/integrations/vectorstores/astradb"
+    name = "HCD"
+    icon: str = "HCD"
+
+    inputs = [
+        StrInput(
+            name="collection_name",
+            display_name="Collection Name",
+            info="The name of the collection within HCD where the vectors will be stored.",
+            required=True,
+        ),
+        StrInput(
+            name="username",
+            display_name="HCD Username",
+            info="Authentication username for accessing HCD.",
+            value="hcd-superuser",
+            required=True,
+        ),
+        SecretStrInput(
+            name="password",
+            display_name="HCD Password",
+            info="Authentication password for accessing HCD.",
+            value="HCD_PASSWORD",
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_endpoint",
+            display_name="HCD API Endpoint",
+            info="API endpoint URL for the HCD service.",
+            value="HCD_API_ENDPOINT",
+            required=True,
+        ),
+        MultilineInput(
+            name="search_input",
+            display_name="Search Input",
+        ),
+        DataInput(
+            name="ingest_data",
+            display_name="Ingest Data",
+            is_list=True,
+        ),
+        StrInput(
+            name="namespace",
+            display_name="Namespace",
+            info="Optional namespace within HCD to use for the collection.",
+            value="default_namespace",
+            advanced=True,
+        ),
+        MultilineInput(
+            name="ca_certificate",
+            display_name="CA Certificate",
+            info="Optional CA certificate for TLS connections to HCD.",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="metric",
+            display_name="Metric",
+            info="Optional distance metric for vector comparisons in the vector store.",
+            options=["cosine", "dot_product", "euclidean"],
+            advanced=True,
+        ),
+        IntInput(
+            name="batch_size",
+            display_name="Batch Size",
+            info="Optional number of data to process in a single batch.",
+            advanced=True,
+        ),
+        IntInput(
+            name="bulk_insert_batch_concurrency",
+            display_name="Bulk Insert Batch Concurrency",
+            info="Optional concurrency level for bulk insert operations.",
+            advanced=True,
+        ),
+        IntInput(
+            name="bulk_insert_overwrite_concurrency",
+            display_name="Bulk Insert Overwrite Concurrency",
+            info="Optional concurrency level for bulk insert operations that overwrite existing data.",
+            advanced=True,
+        ),
+        IntInput(
+            name="bulk_delete_concurrency",
+            display_name="Bulk Delete Concurrency",
+            info="Optional concurrency level for bulk delete operations.",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="setup_mode",
+            display_name="Setup Mode",
+            info="Configuration mode for setting up the vector store, with options like 'Sync', 'Async', or 'Off'.",
+            options=["Sync", "Async", "Off"],
+            advanced=True,
+            value="Sync",
+        ),
+        BoolInput(
+            name="pre_delete_collection",
+            display_name="Pre Delete Collection",
+            info="Boolean flag to determine whether to delete the collection before creating a new one.",
+            advanced=True,
+        ),
+        StrInput(
+            name="metadata_indexing_include",
+            display_name="Metadata Indexing Include",
+            info="Optional list of metadata fields to include in the indexing.",
+            advanced=True,
+        ),
+        HandleInput(
+            name="embedding",
+            display_name="Embedding or Astra Vectorize",
+            input_types=["Embeddings", "dict"],
+            info="Allows either an embedding model or an Astra Vectorize configuration.",  # TODO: This should be optional, but need to refactor langchain-astradb first.
+        ),
+        StrInput(
+            name="metadata_indexing_exclude",
+            display_name="Metadata Indexing Exclude",
+            info="Optional list of metadata fields to exclude from the indexing.",
+            advanced=True,
+        ),
+        StrInput(
+            name="collection_indexing_policy",
+            display_name="Collection Indexing Policy",
+            info="Optional dictionary defining the indexing policy for the collection.",
+            advanced=True,
+        ),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            advanced=True,
+            value=4,
+        ),
+        DropdownInput(
+            name="search_type",
+            display_name="Search Type",
+            info="Search type to use",
+            options=["Similarity", "Similarity with score threshold", "MMR (Max Marginal Relevance)"],
+            value="Similarity",
+            advanced=True,
+        ),
+        FloatInput(
+            name="search_score_threshold",
+            display_name="Search Score Threshold",
+            info="Minimum similarity score threshold for search results. (when using 'Similarity with score threshold')",
+            value=0,
+            advanced=True,
+        ),
+        DictInput(
+            name="search_filter",
+            display_name="Search Metadata Filter",
+            info="Optional dictionary of filters to apply to the search query.",
+            advanced=True,
+            is_list=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self):
+        try:
+            from langchain_astradb import AstraDBVectorStore
+            from langchain_astradb.utils.astradb import SetupMode
+        except ImportError:
+            raise ImportError(
+                "Could not import langchain Astra DB integration package. "
+                "Please install it with `pip install langchain-astradb`."
+            )
+
+        try:
+            from astrapy.constants import Environment
+            from astrapy.authentication import UsernamePasswordTokenProvider
+        except ImportError:
+            raise ImportError(
+                "Could not import astrapy integration package. " "Please install it with `pip install astrapy`."
+            )
+
+        try:
+            if not self.setup_mode:
+                self.setup_mode = self._inputs["setup_mode"].options[0]
+
+            setup_mode_value = SetupMode[self.setup_mode.upper()]
+        except KeyError:
+            raise ValueError(f"Invalid setup mode: {self.setup_mode}")
+
+        if not isinstance(self.embedding, dict):
+            embedding_dict = {"embedding": self.embedding}
+        else:
+            from astrapy.info import CollectionVectorServiceOptions
+
+            dict_options = self.embedding.get("collection_vector_service_options", {})
+            dict_options["authentication"] = {
+                k: v for k, v in dict_options.get("authentication", {}).items() if k and v
+            }
+            dict_options["parameters"] = {k: v for k, v in dict_options.get("parameters", {}).items() if k and v}
+            embedding_dict = {
+                "collection_vector_service_options": CollectionVectorServiceOptions.from_dict(dict_options)
+            }
+            collection_embedding_api_key = self.embedding.get("collection_embedding_api_key")
+            if collection_embedding_api_key:
+                embedding_dict["collection_embedding_api_key"] = collection_embedding_api_key
+
+        token_provider = UsernamePasswordTokenProvider(self.username, self.password)
+        vector_store_kwargs = {
+            **embedding_dict,
+            "collection_name": self.collection_name,
+            "token": token_provider,
+            "api_endpoint": self.api_endpoint,
+            "namespace": self.namespace,
+            "metric": self.metric or None,
+            "batch_size": self.batch_size or None,
+            "bulk_insert_batch_concurrency": self.bulk_insert_batch_concurrency or None,
+            "bulk_insert_overwrite_concurrency": self.bulk_insert_overwrite_concurrency or None,
+            "bulk_delete_concurrency": self.bulk_delete_concurrency or None,
+            "setup_mode": setup_mode_value,
+            "pre_delete_collection": self.pre_delete_collection or False,
+            "environment": Environment.HCD,
+        }
+
+        if self.metadata_indexing_include:
+            vector_store_kwargs["metadata_indexing_include"] = self.metadata_indexing_include
+        elif self.metadata_indexing_exclude:
+            vector_store_kwargs["metadata_indexing_exclude"] = self.metadata_indexing_exclude
+        elif self.collection_indexing_policy:
+            vector_store_kwargs["collection_indexing_policy"] = self.collection_indexing_policy
+
+        try:
+            vector_store = AstraDBVectorStore(**vector_store_kwargs)
+        except Exception as e:
+            raise ValueError(f"Error initializing AstraDBVectorStore: {str(e)}") from e
+
+        self._add_documents_to_vector_store(vector_store)
+        return vector_store
+
+    def _add_documents_to_vector_store(self, vector_store):
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                raise ValueError("Vector Store Inputs must be Data objects.")
+
+        if documents:
+            logger.debug(f"Adding {len(documents)} documents to the Vector Store.")
+            try:
+                vector_store.add_documents(documents)
+            except Exception as e:
+                raise ValueError(f"Error adding documents to AstraDBVectorStore: {str(e)}") from e
+        else:
+            logger.debug("No documents to add to the Vector Store.")
+
+    def _map_search_type(self):
+        if self.search_type == "Similarity with score threshold":
+            return "similarity_score_threshold"
+        elif self.search_type == "MMR (Max Marginal Relevance)":
+            return "mmr"
+        else:
+            return "similarity"
+
+    def _build_search_args(self):
+        args = {
+            "k": self.number_of_results,
+            "score_threshold": self.search_score_threshold,
+        }
+
+        if self.search_filter:
+            clean_filter = {k: v for k, v in self.search_filter.items() if k and v}
+            if len(clean_filter) > 0:
+                args["filter"] = clean_filter
+        return args
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        logger.debug(f"Search input: {self.search_input}")
+        logger.debug(f"Search type: {self.search_type}")
+        logger.debug(f"Number of results: {self.number_of_results}")
+
+        if self.search_input and isinstance(self.search_input, str) and self.search_input.strip():
+            try:
+                search_type = self._map_search_type()
+                search_args = self._build_search_args()
+
+                docs = vector_store.search(query=self.search_input, search_type=search_type, **search_args)
+            except Exception as e:
+                raise ValueError(f"Error performing search in AstraDBVectorStore: {str(e)}") from e
+
+            logger.debug(f"Retrieved documents: {len(docs)}")
+
+            data = docs_to_data(docs)
+            logger.debug(f"Converted documents to data: {len(data)}")
+            self.status = data
+            return data
+        else:
+            logger.debug("No search input provided. Skipping search.")
+            return []
+
+    def get_retriever_kwargs(self):
+        search_args = self._build_search_args()
+        return {
+            "search_type": self._map_search_type(),
+            "search_kwargs": search_args,
+        }

langflow_base_nightly-0.0.95.dev8/langflow/custom/attributes.py

@@ -0,0 +1,66 @@
+import warnings
+from collections.abc import Callable
+
+import emoji
+
+
+def validate_icon(value: str, *args, **kwargs):
+    # we are going to use the emoji library to validate the emoji
+    # emojis can be defined using the :emoji_name: syntax
+
+    if not value.startswith(":") and not value.endswith(":"):
+        return value
+    elif not value.startswith(":") or not value.endswith(":"):
+        # emoji should have both starting and ending colons
+        # so if one of them is missing, we will raise
+        raise ValueError(f"Invalid emoji. {value} is not a valid emoji.")
+
+    emoji_value = emoji.emojize(value, variant="emoji_type")
+    if value == emoji_value:
+        warnings.warn(f"Invalid emoji. {value} is not a valid emoji.")
+        return value
+    return emoji_value
+
+
+def getattr_return_str(value):
+    return str(value) if value else ""
+
+
+def getattr_return_bool(value):
+    if isinstance(value, bool):
+        return value
+
+
+def getattr_return_list_of_str(value):
+    if isinstance(value, list):
+        return [str(val) for val in value]
+    return []
+
+
+def getattr_return_list_of_object(value):
+    if isinstance(value, list):
+        return value
+    return []
+
+
+def getattr_return_list_of_values_from_dict(value):
+    if isinstance(value, dict):
+        return list(value.values())
+    return []
+
+
+ATTR_FUNC_MAPPING: dict[str, Callable] = {
+    "display_name": getattr_return_str,
+    "description": getattr_return_str,
+    "beta": getattr_return_bool,
+    "documentation": getattr_return_str,
+    "icon": validate_icon,
+    "frozen": getattr_return_bool,
+    "is_input": getattr_return_bool,
+    "is_output": getattr_return_bool,
+    "conditional_paths": getattr_return_list_of_str,
+    "_outputs_maps": getattr_return_list_of_values_from_dict,
+    "_inputs": getattr_return_list_of_values_from_dict,
+    "outputs": getattr_return_list_of_object,
+    "inputs": getattr_return_list_of_object,
+}