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

langflow/services/variable/service.py

@@ -4,10 +4,10 @@ import os
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
-from loguru import logger
 from sqlmodel import select
 from typing_extensions import override
 
+from langflow.logging.logger import logger
 from langflow.services.auth import utils as auth_utils
 from langflow.services.base import Service
 from langflow.services.database.models.variable.model import Variable, VariableCreate, VariableRead, VariableUpdate
@@ -29,7 +29,7 @@ class DatabaseVariableService(VariableService, Service):
 
     async def initialize_user_variables(self, user_id: UUID | str, session: AsyncSession) -> None:
         if not self.settings_service.settings.store_environment_variables:
-            logger.debug("Skipping environment variable storage.")
+            await logger.adebug("Skipping environment variable storage.")
             return
 
         for var_name in self.settings_service.settings.variables_to_get_from_environment:
@@ -49,9 +49,9 @@ class DatabaseVariableService(VariableService, Service):
                             type_=CREDENTIAL_TYPE,
                             session=session,
                         )
-                    logger.debug(f"Processed {var_name} variable from environment.")
+                    await logger.adebug(f"Processed {var_name} variable from environment.")
                 except Exception as e:  # noqa: BLE001
-                    logger.exception(f"Error processing {var_name} variable: {e!s}")
+                    await logger.aexception(f"Error processing {var_name} variable: {e!s}")
 
     async def get_variable(
         self,
@@ -91,7 +91,7 @@ class DatabaseVariableService(VariableService, Service):
                 try:
                     value = auth_utils.decrypt_api_key(variable.value, settings_service=self.settings_service)
                 except Exception as e:  # noqa: BLE001
-                    logger.debug(
+                    await logger.adebug(
                         f"Decryption of {variable.type} failed for variable '{variable.name}': {e}. Assuming plaintext."
                     )
                     value = variable.value

langflow/utils/component_utils.py

@@ -53,7 +53,7 @@ def update_input_types(build_config: dotdict) -> dotdict:
     return build_config
 
 
-def set_field_display(build_config: dotdict, field: str, value: bool | None = None) -> dotdict:
+def set_field_display(build_config: dotdict, field: str, value: bool | None = None) -> dotdict:  # noqa: FBT001
     """Set whether a field should be displayed in the UI."""
     if field in build_config and isinstance(build_config[field], dict) and "show" in build_config[field]:
         build_config[field]["show"] = value
@@ -63,20 +63,21 @@ def set_field_display(build_config: dotdict, field: str, value: bool | None = No
 def set_multiple_field_display(
     build_config: dotdict,
     fields: dict[str, bool] | None = None,
+    *,
     value: bool | None = None,
     field_list: list[str] | None = None,
 ) -> dotdict:
     """Set display property for multiple fields at once."""
     if fields is not None:
         for field, visibility in fields.items():
-            build_config = set_field_display(build_config, field, visibility)
+            build_config = set_field_display(build_config, field, value=visibility)
     elif field_list is not None:
         for field in field_list:
-            build_config = set_field_display(build_config, field, value)
+            build_config = set_field_display(build_config, field, value=value)
     return build_config
 
 
-def set_field_advanced(build_config: dotdict, field: str, value: bool | None = None) -> dotdict:
+def set_field_advanced(build_config: dotdict, field: str, value: bool | None = None) -> dotdict:  # noqa: FBT001
     """Set whether a field is considered 'advanced' in the UI."""
     if value is None:
         value = False
@@ -88,16 +89,17 @@ def set_field_advanced(build_config: dotdict, field: str, value: bool | None = N
 def set_multiple_field_advanced(
     build_config: dotdict,
     fields: dict[str, bool] | None = None,
+    *,
     value: bool | None = None,
     field_list: list[str] | None = None,
 ) -> dotdict:
     """Set advanced property for multiple fields at once."""
     if fields is not None:
         for field, advanced in fields.items():
-            build_config = set_field_advanced(build_config, field, advanced)
+            build_config = set_field_advanced(build_config, field, value=advanced)
     elif field_list is not None:
         for field in field_list:
-            build_config = set_field_advanced(build_config, field, value)
+            build_config = set_field_advanced(build_config, field, value=value)
     return build_config
 
 
@@ -120,6 +122,7 @@ def set_current_fields(
     selected_action: str | None = None,
     default_fields: list[str] = DEFAULT_FIELDS,
     func: Callable[[dotdict, str, bool], dotdict] = set_field_display,
+    *,
     default_value: bool | None = None,
 ) -> dotdict:
     """Set the current fields for a selected action."""

langflow/utils/util.py

@@ -53,7 +53,7 @@ def build_template_from_function(name: str, type_to_loader_dict: dict, *, add_fu
                                 module=class_.__base__.__module__, function=value_
                             )
                         except Exception:  # noqa: BLE001
-                            logger.opt(exception=True).debug(f"Error getting default factory for {value_}")
+                            logger.debug(f"Error getting default factory for {value_}", exc_info=True)
                             variables[class_field_items]["default"] = None
                     elif name_ != "name":
                         variables[class_field_items][name_] = value_
@@ -431,16 +431,16 @@ async def update_settings(
     initialize_settings_service()
     settings_service = get_settings_service()
     if config:
-        logger.debug(f"Loading settings from {config}")
+        await logger.adebug(f"Loading settings from {config}")
         await settings_service.settings.update_from_yaml(config, dev=dev)
     if remove_api_keys:
-        logger.debug(f"Setting remove_api_keys to {remove_api_keys}")
+        await logger.adebug(f"Setting remove_api_keys to {remove_api_keys}")
         settings_service.settings.update_settings(remove_api_keys=remove_api_keys)
     if cache:
-        logger.debug(f"Setting cache to {cache}")
+        await logger.adebug(f"Setting cache to {cache}")
         settings_service.settings.update_settings(cache=cache)
     if components_path:
-        logger.debug(f"Adding component path {components_path}")
+        await logger.adebug(f"Adding component path {components_path}")
         settings_service.settings.update_settings(components_path=components_path)
     if not store:
         logger.debug("Setting store to False")

langflow/utils/validate.py

@@ -6,10 +6,10 @@ from types import FunctionType
 from typing import Optional, Union
 
 from langchain_core._api.deprecation import LangChainDeprecationWarning
-from loguru import logger
 from pydantic import ValidationError
 
 from langflow.field_typing.constants import CUSTOM_COMPONENT_SUPPORTED_TYPES, DEFAULT_IMPORT_STRING
+from langflow.logging.logger import logger
 
 
 def add_type_ignores() -> None:
@@ -30,7 +30,7 @@ def validate_code(code):
         tree = ast.parse(code)
     except Exception as e:  # noqa: BLE001
         if hasattr(logger, "opt"):
-            logger.opt(exception=True).debug("Error parsing code")
+            logger.debug("Error parsing code", exc_info=True)
         else:
             logger.debug("Error parsing code")
         errors["function"]["errors"].append(str(e))
@@ -58,7 +58,7 @@ def validate_code(code):
                 exec_globals = _create_langflow_execution_context()
                 exec(code_obj, exec_globals)
             except Exception as e:  # noqa: BLE001
-                logger.opt(exception=True).debug("Error executing function code")
+                logger.debug("Error executing function code", exc_info=True)
                 errors["function"]["errors"].append(str(e))
 
     # Return the errors dictionary

langflow/utils/voice_utils.py

@@ -81,9 +81,9 @@ async def write_audio_to_file(audio_base64: str, filename: str = "output_audio.r
         audio_bytes = base64.b64decode(audio_base64)
         # Use asyncio.to_thread to perform file I/O without blocking the event loop
         await asyncio.to_thread(_write_bytes_to_file, audio_bytes, filename)
-        logger.info(f"Wrote {len(audio_bytes)} bytes to {filename}")
+        await logger.ainfo(f"Wrote {len(audio_bytes)} bytes to {filename}")
     except (OSError, base64.binascii.Error) as e:  # type: ignore[attr-defined]
-        logger.error(f"Error writing audio to file: {e}")
+        await logger.aerror(f"Error writing audio to file: {e}")
 
 
 def _write_bytes_to_file(data: bytes, filename: str) -> None:

{langflow_base_nightly-0.5.0.dev37.dist-info → langflow_base_nightly-0.5.0.dev39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langflow-base-nightly
-Version: 0.5.0.dev37
+Version: 0.5.0.dev39
 Summary: A Python package with a built-in web application
 Project-URL: Repository, https://github.com/langflow-ai/langflow
 Project-URL: Documentation, https://docs.langflow.org
@@ -75,6 +75,7 @@ Requires-Dist: setuptools<79.0.0,>=78.1.0
 Requires-Dist: spider-client<1.0.0,>=0.0.27
 Requires-Dist: sqlalchemy[aiosqlite]<3.0.0,>=2.0.38
 Requires-Dist: sqlmodel==0.0.22
+Requires-Dist: structlog>=25.4.0
 Requires-Dist: trustcall>=0.0.38
 Requires-Dist: typer<1.0.0,>=0.13.0
 Requires-Dist: uncurl<1.0.0,>=0.0.11