langflow-base-nightly 0.5.0.dev37__py3-none-any.whl → 0.5.0.dev39__py3-none-any.whl

langflow/components/logic/notify.py

@@ -85,4 +85,4 @@ class NotifyComponent(Component):
             self.status = "No record provided."
         self._vertex.is_state = True
         self.graph.activate_state_vertices(name=self.context_key, caller=self._id)
-        return cast(Data, input_value)
+        return cast("Data", input_value)

langflow/components/logic/run_flow.py

@@ -1,9 +1,8 @@
 from typing import Any
 
-from loguru import logger
-
 from langflow.base.tools.run_flow import RunFlowBaseComponent
 from langflow.helpers.flow import run_flow
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -34,7 +33,7 @@ class RunFlowComponent(RunFlowBaseComponent):
                     build_config = self.update_build_config_from_graph(build_config, graph)
                 except Exception as e:
                     msg = f"Error building graph for flow {field_value}"
-                    logger.exception(msg)
+                    await logger.aexception(msg)
                     raise RuntimeError(msg) from e
         return build_config
 

langflow/components/logic/sub_flow.py

@@ -1,13 +1,12 @@
 from typing import Any
 
-from loguru import logger
-
 from langflow.base.flow_processing.utils import build_data_from_result_data
 from langflow.custom.custom_component.component import Component
 from langflow.graph.graph.base import Graph
 from langflow.graph.vertex.base import Vertex
 from langflow.helpers.flow import get_flow_inputs
 from langflow.io import DropdownInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 
@@ -41,11 +40,11 @@ class SubFlowComponent(Component):
             try:
                 flow_data = await self.get_flow(field_value)
             except Exception:  # noqa: BLE001
-                logger.exception(f"Error getting flow {field_value}")
+                await logger.aexception(f"Error getting flow {field_value}")
             else:
                 if not flow_data:
                     msg = f"Flow {field_value} not found."
-                    logger.error(msg)
+                    await logger.aerror(msg)
                 else:
                     try:
                         graph = Graph.from_payload(flow_data.data["data"])
@@ -54,7 +53,7 @@ class SubFlowComponent(Component):
                         # Add inputs to the build config
                         build_config = self.add_inputs_to_build_config(inputs, build_config)
                     except Exception:  # noqa: BLE001
-                        logger.exception(f"Error building graph for flow {field_value}")
+                        await logger.aexception(f"Error building graph for flow {field_value}")
 
         return build_config
 

langflow/components/mem0/mem0_chat_memory.py

@@ -1,17 +1,11 @@
 import os
 
-from loguru import logger
 from mem0 import Memory, MemoryClient
 
 from langflow.base.memory.model import LCChatMemoryComponent
-from langflow.inputs.inputs import (
-    DictInput,
-    HandleInput,
-    MessageTextInput,
-    NestedDictInput,
-    SecretStrInput,
-)
+from langflow.inputs.inputs import DictInput, HandleInput, MessageTextInput, NestedDictInput, SecretStrInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 

langflow/components/milvus/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .milvus import MilvusVectorStoreComponent
+
+_dynamic_imports = {
+    "MilvusVectorStoreComponent": "milvus",
+}
+
+__all__ = [
+    "MilvusVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Milvus components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

langflow/components/mongodb/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .mongodb_atlas import MongoVectorStoreComponent
+
+_dynamic_imports = {
+    "MongoVectorStoreComponent": "mongodb_atlas",
+}
+
+__all__ = [
+    "MongoVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import MongoDB components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

langflow/components/nvidia/nvidia.py

@@ -1,6 +1,5 @@
 from typing import Any
 
-from loguru import logger
 from requests.exceptions import ConnectionError  # noqa: A004
 from urllib3.exceptions import MaxRetryError, NameResolutionError
 
@@ -8,6 +7,7 @@ from langflow.base.models.model import LCModelComponent
 from langflow.field_typing import LanguageModel
 from langflow.field_typing.range_spec import RangeSpec
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput, SliderInput
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -97,7 +97,7 @@ class NVIDIAModelComponent(LCModelComponent):
         ),
     ]
 
-    def get_models(self, tool_model_enabled: bool | None = None) -> list[str]:
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
         try:
             from langchain_nvidia_ai_endpoints import ChatNVIDIA
         except ImportError as e:
@@ -114,7 +114,7 @@ class NVIDIAModelComponent(LCModelComponent):
     def update_build_config(self, build_config: dotdict, _field_value: Any, field_name: str | None = None):
         if field_name in {"model_name", "tool_model_enabled", "base_url", "api_key"}:
             try:
-                ids = self.get_models(self.tool_model_enabled)
+                ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
                 build_config["model_name"]["options"] = ids
 
                 if "value" not in build_config["model_name"] or build_config["model_name"]["value"] is None:

langflow/components/olivya/olivya.py

@@ -1,10 +1,10 @@
 import json
 
 import httpx
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.io import MessageTextInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -83,7 +83,7 @@ class OlivyaComponent(Component):
                 "Content-Type": "application/json",
             }
 
-            logger.info("Sending POST request with payload: %s", payload)
+            await logger.ainfo("Sending POST request with payload: %s", payload)
 
             # Send the POST request with a timeout
             async with httpx.AsyncClient() as client:
@@ -97,19 +97,19 @@ class OlivyaComponent(Component):
 
                 # Parse and return the successful response
                 response_data = response.json()
-                logger.info("Request successful: %s", response_data)
+                await logger.ainfo("Request successful: %s", response_data)
 
         except httpx.HTTPStatusError as http_err:
-            logger.exception("HTTP error occurred")
+            await logger.aexception("HTTP error occurred")
             response_data = {"error": f"HTTP error occurred: {http_err}", "response_text": response.text}
         except httpx.RequestError as req_err:
-            logger.exception("Request failed")
+            await logger.aexception("Request failed")
             response_data = {"error": f"Request failed: {req_err}"}
         except json.JSONDecodeError as json_err:
-            logger.exception("Response parsing failed")
+            await logger.aexception("Response parsing failed")
             response_data = {"error": f"Response parsing failed: {json_err}", "raw_response": response.text}
         except Exception as e:  # noqa: BLE001
-            logger.exception("An unexpected error occurred")
+            await logger.aexception("An unexpected error occurred")
             response_data = {"error": f"An unexpected error occurred: {e!s}"}
 
         # Return the response as part of the output

langflow/components/ollama/ollama.py

@@ -34,6 +34,7 @@ class ChatOllamaComponent(LCModelComponent):
             display_name="Base URL",
             info="Endpoint of the Ollama API.",
             value="",
+            real_time_refresh=True,
         ),
         DropdownInput(
             name="model_name",
@@ -245,11 +246,13 @@ class ChatOllamaComponent(LCModelComponent):
         if field_name in {"model_name", "base_url", "tool_model_enabled"}:
             if await self.is_valid_ollama_url(self.base_url):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
-                build_config["model_name"]["options"] = await self.get_models(self.base_url, tool_model_enabled)
+                build_config["model_name"]["options"] = await self.get_models(
+                    self.base_url, tool_model_enabled=tool_model_enabled
+                )
             elif await self.is_valid_ollama_url(build_config["base_url"].get("value", "")):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
                 build_config["model_name"]["options"] = await self.get_models(
-                    build_config["base_url"].get("value", ""), tool_model_enabled
+                    build_config["base_url"].get("value", ""), tool_model_enabled=tool_model_enabled
                 )
             else:
                 build_config["model_name"]["options"] = []
@@ -265,7 +268,7 @@ class ChatOllamaComponent(LCModelComponent):
 
         return build_config
 
-    async def get_models(self, base_url_value: str, tool_model_enabled: bool | None = None) -> list[str]:
+    async def get_models(self, base_url_value: str, *, tool_model_enabled: bool | None = None) -> list[str]:
         """Fetches a list of models from the Ollama API that do not have the "embedding" capability.
 
         Args:
@@ -298,13 +301,13 @@ class ChatOllamaComponent(LCModelComponent):
                 models = tags_response.json()
                 if asyncio.iscoroutine(models):
                     models = await models
-                logger.debug(f"Available models: {models}")
+                await logger.adebug(f"Available models: {models}")
 
                 # Filter models that are NOT embedding models
                 model_ids = []
                 for model in models[self.JSON_MODELS_KEY]:
                     model_name = model[self.JSON_NAME_KEY]
-                    logger.debug(f"Checking model: {model_name}")
+                    await logger.adebug(f"Checking model: {model_name}")
 
                     payload = {"model": model_name}
                     show_response = await client.post(show_url, json=payload)
@@ -313,7 +316,7 @@ class ChatOllamaComponent(LCModelComponent):
                     if asyncio.iscoroutine(json_data):
                         json_data = await json_data
                     capabilities = json_data.get(self.JSON_CAPABILITIES_KEY, [])
-                    logger.debug(f"Model: {model_name}, Capabilities: {capabilities}")
+                    await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
 
                     if self.DESIRED_CAPABILITY in capabilities and (
                         not tool_model_enabled or self.TOOL_CALLING_CAPABILITY in capabilities

langflow/components/perplexity/perplexity.py

@@ -31,9 +31,7 @@ class PerplexityComponent(LCModelComponent):
             ],
             value="llama-3.1-sonar-small-128k-online",
         ),
-        IntInput(
-            name="max_output_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."
-        ),
+        IntInput(name="max_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."),
         SecretStrInput(
             name="api_key",
             display_name="Perplexity API Key",
@@ -57,20 +55,13 @@ class PerplexityComponent(LCModelComponent):
             "Note that the API may not return the full n completions if duplicates are generated.",
             advanced=True,
         ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            info="Decode using top-k sampling: consider the set of top_k most probable tokens. Must be positive.",
-            advanced=True,
-        ),
     ]
 
     def build_model(self) -> LanguageModel:  # type: ignore[type-var]
         api_key = SecretStr(self.api_key).get_secret_value()
         temperature = self.temperature
         model = self.model_name
-        max_output_tokens = self.max_output_tokens
-        top_k = self.top_k
+        max_tokens = self.max_tokens
         top_p = self.top_p
         n = self.n
 
@@ -78,8 +69,7 @@ class PerplexityComponent(LCModelComponent):
             model=model,
             temperature=temperature or 0.75,
             pplx_api_key=api_key,
-            top_k=top_k or None,
             top_p=top_p or None,
             n=n or 1,
-            max_output_tokens=max_output_tokens,
+            max_tokens=max_tokens,
         )

langflow/components/pgvector/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .pgvector import PGVectorStoreComponent
+
+_dynamic_imports = {
+    "PGVectorStoreComponent": "pgvector",
+}
+
+__all__ = [
+    "PGVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import pgvector components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

langflow/components/pinecone/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .pinecone import PineconeVectorStoreComponent
+
+_dynamic_imports = {
+    "PineconeVectorStoreComponent": "pinecone",
+}
+
+__all__ = [
+    "PineconeVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Pinecone components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

langflow/components/processing/batch_run.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 if TYPE_CHECKING:
@@ -144,11 +144,11 @@ class BatchRunComponent(Component):
                 user_texts = df[col_name].astype(str).tolist()
             else:
                 user_texts = [
-                    self._format_row_as_toml(cast(dict[str, Any], row)) for row in df.to_dict(orient="records")
+                    self._format_row_as_toml(cast("dict[str, Any]", row)) for row in df.to_dict(orient="records")
                 ]
 
             total_rows = len(user_texts)
-            logger.info(f"Processing {total_rows} rows with batch run")
+            await logger.ainfo(f"Processing {total_rows} rows with batch run")
 
             # Prepare the batch of conversations
             conversations = [
@@ -185,21 +185,21 @@ class BatchRunComponent(Component):
             ):
                 response_text = response[1].content if hasattr(response[1], "content") else str(response[1])
                 row = self._create_base_row(
-                    cast(dict[str, Any], original_row), model_response=response_text, batch_index=idx
+                    cast("dict[str, Any]", original_row), model_response=response_text, batch_index=idx
                 )
                 self._add_metadata(row, success=True, system_msg=system_msg)
                 rows.append(row)
 
                 # Log progress
                 if (idx + 1) % max(1, total_rows // 10) == 0:
-                    logger.info(f"Processed {idx + 1}/{total_rows} rows")
+                    await logger.ainfo(f"Processed {idx + 1}/{total_rows} rows")
 
-            logger.info("Batch processing completed successfully")
+            await logger.ainfo("Batch processing completed successfully")
             return DataFrame(rows)
 
         except (KeyError, AttributeError) as e:
             # Handle data structure and attribute access errors
-            logger.error(f"Data processing error: {e!s}")
-            error_row = self._create_base_row({col: "" for col in df.columns}, model_response="", batch_index=-1)
+            await logger.aerror(f"Data processing error: {e!s}")
+            error_row = self._create_base_row(dict.fromkeys(df.columns, ""), model_response="", batch_index=-1)
             self._add_metadata(error_row, success=False, error=str(e))
             return DataFrame([error_row])

langflow/components/processing/data_operations.py

@@ -181,7 +181,7 @@ class DataOperationsComponent(Component):
         raise ValueError(msg)
 
     # Data transformation operations
-    def select_keys(self, evaluate: bool | None = None) -> Data:
+    def select_keys(self, *, evaluate: bool | None = None) -> Data:
         """Select specific keys from the data dictionary."""
         self.validate_single_data("Select Keys")
         data_dict = self.get_normalized_data()
@@ -266,7 +266,7 @@ class DataOperationsComponent(Component):
         logger.info("evaluating data")
         return Data(**self.recursive_eval(self.get_data_dict()))
 
-    def combine_data(self, evaluate: bool | None = None) -> Data:
+    def combine_data(self, *, evaluate: bool | None = None) -> Data:
         """Combine multiple data objects into one."""
         logger.info("combining data")
         if not self.data_is_list():

langflow/components/processing/merge_data.py

@@ -1,10 +1,9 @@
 from enum import Enum
 from typing import cast
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import DataInput, DropdownInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.dataframe import DataFrame
 
 

langflow/components/processing/message_to_data.py

@@ -1,7 +1,6 @@
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.io import MessageInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 
@@ -32,6 +31,6 @@ class MessageToDataComponent(Component):
             return Data(data=self.message.data)
 
         msg = "Error converting Message to Data: Input must be a Message object"
-        logger.opt(exception=True).debug(msg)
+        logger.debug(msg, exc_info=True)
         self.status = msg
         return Data(data={"error": msg})

langflow/components/processing/parse_json_data.py

@@ -3,11 +3,11 @@ from json import JSONDecodeError
 
 import jq
 from json_repair import repair_json
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import HandleInput, MessageTextInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/components/prototypes/python_function.py

@@ -1,10 +1,9 @@
 from collections.abc import Callable
 
-from loguru import logger
-
 from langflow.custom.custom_component.component import Component
 from langflow.custom.utils import get_function
 from langflow.io import CodeInput, Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 from langflow.schema.message import Message
@@ -58,7 +57,7 @@ class PythonFunctionComponent(Component):
             func = get_function(function_code)
             return func()
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error executing function")
+            logger.debug("Error executing function", exc_info=True)
             return f"Error executing function: {e}"
 
     def execute_function_data(self) -> list[Data]:

langflow/components/qdrant/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .qdrant import QdrantVectorStoreComponent
+
+_dynamic_imports = {
+    "QdrantVectorStoreComponent": "qdrant",
+}
+
+__all__ = [
+    "QdrantVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Qdrant components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

langflow/components/redis/__init__.py

@@ -1,3 +1,37 @@
-from .redis import RedisIndexChatMemory
+from __future__ import annotations
 
-__all__ = ["RedisIndexChatMemory"]
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .redis import RedisVectorStoreComponent
+    from .redis_chat import RedisIndexChatMemory
+
+_dynamic_imports = {
+    "RedisVectorStoreComponent": "redis",
+    "RedisIndexChatMemory": "redis_chat",
+}
+
+__all__ = [
+    "RedisIndexChatMemory",
+    "RedisVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Redis components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)