Flowfile 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

flowfile_core/configs/node_store/user_defined_node_registry.py

@@ -1,18 +1,16 @@
-import sys
 import importlib.util
 import inspect
-from pathlib import Path
-from typing import Dict, Type, List
 import logging
+import sys
+from pathlib import Path
 
-from flowfile_core.flowfile.node_designer.custom_node import CustomNodeBase, NodeSettings
+from flowfile_core.flowfile.node_designer.custom_node import CustomNodeBase
 from shared import storage
 
-
 logger = logging.getLogger(__name__)
 
 
-def get_all_custom_nodes() -> Dict[str, Type[CustomNodeBase]]:
+def get_all_custom_nodes() -> dict[str, type[CustomNodeBase]]:
     """
     Scan the user-defined nodes directory and import all CustomNodeBase subclasses.
 
@@ -55,12 +53,9 @@ def get_all_custom_nodes() -> Dict[str, Type[CustomNodeBase]]:
                 for name, obj in inspect.getmembers(module):
                     # Check if it's a class and a subclass of CustomNodeBase
                     # but not CustomNodeBase itself
-                    if (inspect.isclass(obj) and
-                            issubclass(obj, CustomNodeBase) and
-                            obj is not CustomNodeBase):
-
+                    if inspect.isclass(obj) and issubclass(obj, CustomNodeBase) and obj is not CustomNodeBase:
                         # Use the node_name attribute if it exists, otherwise use class name
-                        node_name = getattr(obj, 'node_name', name)
+                        node_name = getattr(obj, "node_name", name)
                         custom_nodes[node_name] = obj
                         print(f"Loaded custom node: {node_name} from {file_path.name}")
 
@@ -72,7 +67,7 @@ def get_all_custom_nodes() -> Dict[str, Type[CustomNodeBase]]:
     return custom_nodes
 
 
-def get_all_custom_nodes_with_validation() -> Dict[str, Type[CustomNodeBase]]:
+def get_all_custom_nodes_with_validation() -> dict[str, type[CustomNodeBase]]:
     """
     Enhanced version that validates the nodes before adding them.
     """
@@ -97,22 +92,19 @@ def get_all_custom_nodes_with_validation() -> Dict[str, Type[CustomNodeBase]]:
                 spec.loader.exec_module(module)
 
                 for name, obj in inspect.getmembers(module):
-                    if (inspect.isclass(obj) and
-                            issubclass(obj, CustomNodeBase) and
-                            obj is not CustomNodeBase):
-
+                    if inspect.isclass(obj) and issubclass(obj, CustomNodeBase) and obj is not CustomNodeBase:
                         try:
                             _obj = obj()
                             # Validate that the node has required attributes
-                            if not hasattr(_obj, 'node_name'):
+                            if not hasattr(_obj, "node_name"):
                                 logger.error(f"Warning: {name} missing node_name attribute")
                                 raise ValueError(f"Node {name} must implement a node_name attribute")
 
-                            if not hasattr(_obj, 'settings_schema'):
+                            if not hasattr(_obj, "settings_schema"):
                                 logger.error(f"Warning: {name} missing settings_schema attribute")
                                 raise ValueError(f"Node {name} must implement a settings_schema attribute")
 
-                            if not hasattr(_obj, 'process'):
+                            if not hasattr(_obj, "process"):
                                 logger.error(f"Warning: {name} missing process method")
                                 raise ValueError(f"Node {name} must implement a process method")
                             if not (storage.user_defined_nodes_icons / _obj.node_icon).exists():
@@ -137,7 +129,7 @@ def get_all_custom_nodes_with_validation() -> Dict[str, Type[CustomNodeBase]]:
     return custom_nodes
 
 
-def get_custom_nodes_lazy() -> List[Type[CustomNodeBase]]:
+def get_custom_nodes_lazy() -> list[type[CustomNodeBase]]:
     """
     Returns a list of custom node classes without instantiating them.
     Useful for registration or catalog purposes.
@@ -162,10 +154,12 @@ def get_custom_nodes_lazy() -> List[Type[CustomNodeBase]]:
                 spec.loader.exec_module(module)
 
                 for name, obj in inspect.getmembers(module):
-                    if (inspect.isclass(obj) and
-                            issubclass(obj, CustomNodeBase) and
-                            obj is not CustomNodeBase and
-                            obj.__module__ == module.__name__):  # Only get classes defined in this module
+                    if (
+                        inspect.isclass(obj)
+                        and issubclass(obj, CustomNodeBase)
+                        and obj is not CustomNodeBase
+                        and obj.__module__ == module.__name__
+                    ):  # Only get classes defined in this module
                         nodes.append(obj)
 
         except Exception as e:
@@ -176,18 +170,105 @@ def get_custom_nodes_lazy() -> List[Type[CustomNodeBase]]:
 
 
 # Example usage function that matches your original pattern
-def add_custom_node(node_class: Type[CustomNodeBase], registry: Dict[str, Type[CustomNodeBase]]):
+def add_custom_node(node_class: type[CustomNodeBase], registry: dict[str, type[CustomNodeBase]]):
     """Add a single custom node to the registry."""
-    if hasattr(node_class, 'node_name'):
+    if hasattr(node_class, "node_name"):
         registry[node_class.node_name] = node_class
     else:
         registry[node_class.__name__] = node_class
 
 
-def get_all_nodes_from_standard_location() -> Dict[str, Type[CustomNodeBase]]:
+def get_all_nodes_from_standard_location() -> dict[str, type[CustomNodeBase]]:
     """
     Main function to get all custom nodes from the standard location.
     This matches your original function signature.
     """
 
     return get_all_custom_nodes_with_validation()
+
+
+def load_single_node_from_file(file_path: Path) -> type[CustomNodeBase] | None:
+    """
+    Load a single custom node from a specific file.
+
+    Args:
+        file_path: Path to the Python file containing the custom node
+
+    Returns:
+        The custom node class if found and valid, None otherwise
+    """
+    if not file_path.exists():
+        logger.error(f"File not found: {file_path}")
+        return None
+
+    try:
+        # Create a unique module name to avoid conflicts with cached modules
+        module_name = f"custom_node_{file_path.stem}_{id(file_path)}"
+
+        # Remove old module from sys.modules if it exists (for reloading)
+        old_module_name = file_path.stem
+        if old_module_name in sys.modules:
+            del sys.modules[old_module_name]
+
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+
+        if spec and spec.loader:
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            for name, obj in inspect.getmembers(module):
+                if inspect.isclass(obj) and issubclass(obj, CustomNodeBase) and obj is not CustomNodeBase:
+                    try:
+                        _obj = obj()
+                        # Validate required attributes
+                        if not hasattr(_obj, "node_name"):
+                            raise ValueError(f"Node {name} must have a node_name attribute")
+                        if not hasattr(_obj, "settings_schema"):
+                            raise ValueError(f"Node {name} must have a settings_schema attribute")
+                        if not hasattr(_obj, "process"):
+                            raise ValueError(f"Node {name} must have a process method")
+
+                        logger.info(f"✓ Loaded: {_obj.node_name} from {file_path.name}")
+                        return obj
+                    except Exception as e:
+                        logger.error(f"Error validating node {name}: {e}")
+                        raise
+
+    except SyntaxError as e:
+        logger.error(f"Syntax error in {file_path}: {e}")
+        raise
+    except ImportError as e:
+        logger.error(f"Import error in {file_path}: {e}")
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error loading {file_path}: {e}")
+        raise
+
+    return None
+
+
+def unload_node_by_name(node_name: str) -> bool:
+    """
+    Remove a node from sys.modules cache by its name.
+    This helps ensure the node can be cleanly reloaded later.
+
+    Args:
+        node_name: The name of the node to unload
+
+    Returns:
+        True if any modules were removed, False otherwise
+    """
+    # Convert node name to potential module names
+    module_stem = node_name.lower().replace(" ", "_")
+
+    # Find and remove any matching modules from sys.modules
+    modules_to_remove = [
+        key for key in sys.modules.keys() if key == module_stem or key.startswith(f"custom_node_{module_stem}")
+    ]
+
+    for mod_name in modules_to_remove:
+        del sys.modules[mod_name]
+        logger.info(f"Removed module from cache: {mod_name}")
+
+    return len(modules_to_remove) > 0

flowfile_core/configs/settings.py

@@ -1,16 +1,14 @@
-
 # flowfile_core/flowfile_core/configs/settings.py
-import platform
+import argparse
 import os
+import platform
 import tempfile
-import argparse
 
 from passlib.context import CryptContext
 from starlette.config import Config
-from shared.storage_config import storage
 
 from flowfile_core.configs.utils import MutableBool
-
+from shared.storage_config import storage
 
 # Constants for server and worker configuration
 DEFAULT_SERVER_HOST = "0.0.0.0"
@@ -27,12 +25,8 @@ OFFLOAD_TO_WORKER: MutableBool = MutableBool(os.environ.get("FLOWFILE_OFFLOAD_TO
 def parse_args():
     """Parse command line arguments"""
     parser = argparse.ArgumentParser(description="Flowfile Backend Server")
-    parser.add_argument(
-        "--host", type=str, default=DEFAULT_SERVER_HOST, help="Host to bind to"
-    )
-    parser.add_argument(
-        "--port", type=int, default=DEFAULT_SERVER_PORT, help="Port to bind to"
-    )
+    parser.add_argument("--host", type=str, default=DEFAULT_SERVER_HOST, help="Host to bind to")
+    parser.add_argument("--port", type=int, default=DEFAULT_SERVER_PORT, help="Port to bind to")
     parser.add_argument(
         "--worker-port",
         type=int,
@@ -84,8 +78,9 @@ args = parse_args()
 
 SERVER_HOST = args.host if args.host is not None else DEFAULT_SERVER_HOST
 SERVER_PORT = args.port if args.port is not None else DEFAULT_SERVER_PORT
-WORKER_PORT = args.worker_port if args.worker_port is not None else int(os.getenv("FLOWFILE_WORKER_PORT",
-                                                                                  DEFAULT_WORKER_PORT))
+WORKER_PORT = (
+    args.worker_port if args.worker_port is not None else int(os.getenv("FLOWFILE_WORKER_PORT", DEFAULT_WORKER_PORT))
+)
 WORKER_HOST = os.getenv("WORKER_HOST", "0.0.0.0" if platform.system() != "Windows" else "127.0.0.1")
 
 config = Config(".env")
@@ -93,9 +88,27 @@ DEBUG: bool = config("DEBUG", cast=bool, default=False)
 FILE_LOCATION = config("FILE_LOCATION", cast=str, default=".\\files\\")
 AVAILABLE_RAM = config("AVAILABLE_RAM", cast=int, default=8)
 WORKER_URL = config("FLOWFILE_WORKER_URL", cast=str, default=get_default_worker_url(WORKER_PORT))
-IS_RUNNING_IN_DOCKER = os.getenv('RUNNING_IN_DOCKER', 'false').lower() == 'true'
 TEMP_DIR = storage.temp_directory
 
+# FLOWFILE_MODE: Determines the runtime environment
+# Possible values: "electron" (desktop app), "package" (Python package), "docker" (container)
+FLOWFILE_MODE = os.getenv("FLOWFILE_MODE", "electron")
+
+def is_docker_mode() -> bool:
+    """Check if running in Docker container mode"""
+    return FLOWFILE_MODE == "docker"
+
+def is_electron_mode() -> bool:
+    """Check if running in Electron desktop app mode"""
+    return FLOWFILE_MODE == "electron"
+
+def is_package_mode() -> bool:
+    """Check if running as Python package"""
+    return FLOWFILE_MODE == "package"
+
+# Legacy compatibility - will be removed in future versions
+IS_RUNNING_IN_DOCKER = is_docker_mode()
+
 ALGORITHM = "HS256"
 ACCESS_TOKEN_EXPIRE_MINUTES = 120
-PWD_CONTEXT = CryptContext(schemes=["bcrypt"], deprecated="auto")
+PWD_CONTEXT = CryptContext(schemes=["bcrypt"], deprecated="auto")

flowfile_core/database/connection.py

@@ -1,9 +1,11 @@
-from sqlalchemy import create_engine
-from contextlib import contextmanager
-from sqlalchemy.orm import sessionmaker
 import os
 import sys
+from contextlib import contextmanager
 from pathlib import Path
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
 from flowfile_core.configs import logger
 from shared.storage_config import storage
 
@@ -44,8 +46,7 @@ def get_database_path() -> Path:
 
 # Create database engine
 engine = create_engine(
-    get_database_url(),
-    connect_args={"check_same_thread": False} if "sqlite" in get_database_url() else {}
+    get_database_url(), connect_args={"check_same_thread": False} if "sqlite" in get_database_url() else {}
 )
 
 # Create session factory
@@ -77,5 +78,5 @@ def get_database_info():
         "url": get_database_url(),
         "path": str(get_database_path()) if get_database_path() else None,
         "app_data_dir": str(get_app_data_dir()),
-        "platform": sys.platform
+        "platform": sys.platform,
     }

flowfile_core/database/init_db.py

@@ -1,13 +1,53 @@
 # Generate a random secure password and hash it
+import os
 import secrets
 import string
+import logging
 from sqlalchemy.orm import Session
+from sqlalchemy import text
 from flowfile_core.database import models as db_models
 from flowfile_core.database.connection import engine, SessionLocal
+from flowfile_core.auth.password import get_password_hash
 
 from passlib.context import CryptContext
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
+logger = logging.getLogger(__name__)
+
+
+def run_migrations():
+    """Run database migrations to update schema for existing databases."""
+    with engine.connect() as conn:
+        # Check if users table exists
+        result = conn.execute(text(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='users'"
+        ))
+        if not result.fetchone():
+            logger.info("Users table does not exist, will be created with new schema")
+            return
+
+        # Check existing columns
+        result = conn.execute(text("PRAGMA table_info(users)"))
+        columns = [row[1] for row in result.fetchall()]
+
+        # Add is_admin column if missing
+        if 'is_admin' not in columns:
+            logger.info("Adding is_admin column to users table")
+            conn.execute(text("ALTER TABLE users ADD COLUMN is_admin BOOLEAN DEFAULT 0"))
+            conn.commit()
+            logger.info("Migration complete: is_admin column added")
+
+        # Add must_change_password column if missing
+        if 'must_change_password' not in columns:
+            logger.info("Adding must_change_password column to users table")
+            conn.execute(text("ALTER TABLE users ADD COLUMN must_change_password BOOLEAN DEFAULT 0"))
+            conn.commit()
+            logger.info("Migration complete: must_change_password column added")
+
+
+# Run migrations BEFORE create_all to update existing tables
+run_migrations()
+# Then create any new tables (this will include is_admin for new databases)
 db_models.Base.metadata.create_all(bind=engine)
 
 
@@ -21,19 +61,73 @@ def create_default_local_user(db: Session):
             username="local_user",
             email="local@flowfile.app",
             full_name="Local User",
-            hashed_password=hashed_password
+            hashed_password=hashed_password,
+            must_change_password=False  # Local user doesn't need to change password
         )
         db.add(local_user)
         db.commit()
         return True
-    else:
+    return False
+
+
+def create_docker_admin_user(db: Session):
+    """
+    Create admin user for Docker mode from environment variables.
+    Only runs when FLOWFILE_MODE=docker.
+    Reads FLOWFILE_ADMIN_USER and FLOWFILE_ADMIN_PASSWORD from environment.
+    """
+    # Only run in Docker mode
+    if os.environ.get("FLOWFILE_MODE") != "docker":
         return False
 
+    # Read environment variables
+    admin_username = os.environ.get("FLOWFILE_ADMIN_USER")
+    admin_password = os.environ.get("FLOWFILE_ADMIN_PASSWORD")
+
+    # Skip if either is not set
+    if not admin_username or not admin_password:
+        logger.warning(
+            "Docker mode detected but FLOWFILE_ADMIN_USER or FLOWFILE_ADMIN_PASSWORD "
+            "not set. Admin user will not be created."
+        )
+        return False
+
+    # Check if user already exists
+    existing_user = db.query(db_models.User).filter(
+        db_models.User.username == admin_username
+    ).first()
+
+    if existing_user:
+        # Ensure existing admin user has is_admin=True
+        if not existing_user.is_admin:
+            existing_user.is_admin = True
+            db.commit()
+            logger.info(f"Admin user '{admin_username}' updated with admin privileges.")
+        else:
+            logger.info(f"Admin user '{admin_username}' already exists with admin privileges.")
+        return False
+
+    # Create user with hashed password and admin privileges
+    hashed_password = get_password_hash(admin_password)
+    admin_user = db_models.User(
+        username=admin_username,
+        email=f"{admin_username}@flowfile.app",
+        full_name="Admin User",
+        hashed_password=hashed_password,
+        is_admin=True,
+        must_change_password=True  # Force password change on first login
+    )
+    db.add(admin_user)
+    db.commit()
+    logger.info(f"Admin user '{admin_username}' created successfully.")
+    return True
+
 
 def init_db():
     db = SessionLocal()
     try:
         create_default_local_user(db)
+        create_docker_admin_user(db)
     finally:
         db.close()
 

flowfile_core/database/models.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, Text, DateTime
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.sql import func
 
@@ -14,6 +14,8 @@ class User(Base):
     full_name = Column(String)
     hashed_password = Column(String)
     disabled = Column(Boolean, default=False)
+    is_admin = Column(Boolean, default=False)
+    must_change_password = Column(Boolean, default=True)
 
 
 class Secret(Base):

flowfile_core/fileExplorer/__init__.py

@@ -0,0 +1,17 @@
+from .funcs import (
+    FileExplorer,
+    FileInfo,
+    SecureFileExplorer,
+    get_files_from_directory,
+    validate_file_path,
+    validate_path_under_cwd,
+)
+
+__all__ = [
+    "FileExplorer",
+    "FileInfo",
+    "SecureFileExplorer",
+    "get_files_from_directory",
+    "validate_file_path",
+    "validate_path_under_cwd",
+]