FastPluggy 0.2.7__py3-none-any.whl

fastpluggy/__init__.py

@@ -0,0 +1,4 @@
+import os
+
+__version__ = "0.2.7"  # Update this manually when needed
+__SOURCE_COMMIT_CORE__ = os.getenv("SOURCE_COMMIT_CORE", "")

fastpluggy/core/auth/__init__.py

@@ -0,0 +1,34 @@
+# core/dependency.py
+from fastapi import Request, HTTPException, Depends
+from starlette import status
+from starlette.authentication import UnauthenticatedUser
+
+
+async def require_authentication(request: Request):
+    auth_manager = request.app.state.fastpluggy.auth_manager
+    if auth_manager:
+        if isinstance(request.user, UnauthenticatedUser):
+            # If a custom error handler is defined, call it.
+            if hasattr(auth_manager, "on_authenticate_error") and callable(auth_manager.on_authenticate_error):
+                result = await auth_manager.on_authenticate_error(request)
+                if result is not None:
+                    return result
+
+            # Fallback to default behavior if no custom error handling was provided.
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Not authenticated"
+            )
+        return request.user
+
+
+def require_role(role: str):
+    async def dependency(request: Request):
+        # your `require_authentication` should already have populated request.user & request.auth
+        # (e.g. via an AuthenticationMiddleware + your backend)
+        auth_manager = request.app.state.fastpluggy.auth_manager
+        if auth_manager:
+            scopes = getattr(request.auth, "scopes", [])
+            if role not in scopes:
+                raise HTTPException(status_code=403, detail=f"'{role}' role required")
+    return Depends(dependency)

fastpluggy/core/auth/auth_interface.py

@@ -0,0 +1,78 @@
+from abc import abstractmethod
+from typing import Type
+
+from fastapi import Request
+from starlette.authentication import BaseUser, AuthenticationBackend, AuthCredentials
+from starlette.requests import HTTPConnection
+
+
+class AuthInterface(AuthenticationBackend):
+
+    async def on_authenticate_error(self, request: Request):
+        """
+        Handle authentication errors when a user fails to authenticate.
+
+        This method is invoked when authentication fails (e.g., due to missing or invalid credentials).
+        It examines the request's 'Accept' header and, if the client expects HTML and login redirection is enabled,
+        returns a redirect response to the login page. Otherwise, it raises an HTTP 401 Unauthorized exception with
+        a WWW-Authenticate header, which can trigger the browser's Basic Authentication popup.
+
+        Args:
+            request (Request): The incoming FastAPI request object containing details such as headers.
+
+        Returns:
+            A RedirectResponse if HTML is accepted and redirection is enabled. If not, this method raises an
+            HTTPException and does not return normally.
+
+        Raises:
+            HTTPException: Raised with status code 401 if authentication fails and the client does not accept HTML,
+            prompting the Basic Auth dialog.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def user_model(self) -> Type[BaseUser]:
+        """
+        Returns the SQLAlchemy model class representing a user.
+        Implementations can override this property to use a different model.
+        """
+        pass
+
+    @abstractmethod
+    async def authenticate(self, conn: HTTPConnection) -> tuple[AuthCredentials, BaseUser] | None:
+        """
+        Check if the user is authenticated.
+        Should return a User object if authenticated.
+        Otherwise, it can either raise an HTTPException or return a Response (e.g. a redirect).
+        """
+        pass
+
+    def get_user_menu_entries(self, request: Request) -> list:
+        """
+        Returns menu items for the user dropdown based on whether a user is logged in.
+            If a user is logged in, the menu is obtained from the FastPluggy menu manager (using the "user" menu).
+            Otherwise, a default login entry is returned.
+
+        Each menu item should be a dictionary containing keys such as:
+            - "name": the display text
+            - "icon": (optional) an icon class
+            - "url": the destination URL
+
+
+            """
+        # Check if a user is attached to request.state (set by middleware)
+        user = getattr(request.state, "current_user", None)
+        if user:
+            from fastpluggy.fastpluggy import FastPluggy
+
+            # Retrieve the menu manager from the app state.
+            fast_pluggy: FastPluggy = request.app.state.fastpluggy
+
+            menu_manager = fast_pluggy.menu_manager
+            # Try to get the "user" menu from the manager.
+            user_menu = menu_manager.get_menu("user")
+            return user_menu
+        else:
+            # If no user is logged in, return a default login entry.
+            return [{'router': {"name": "Login", "icon": "fa-solid fa-sign-in-alt", "url": "/login"}}]

fastpluggy/core/auth/middleware.py

@@ -0,0 +1,31 @@
+from fastapi import Request
+from loguru import logger
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+class CurrentUserMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        # Obtain a DB session; in production you might want a better scoped session
+
+        from fastpluggy.fastpluggy import FastPluggy
+
+        # Retrieve the FastPluggy instance (assuming it's stored in app.state)
+        fast_pluggy: FastPluggy = request.app.state.fastpluggy
+        try:
+            # Use the current auth manager to authenticate the user
+            if fast_pluggy.auth_manager:
+                user = await fast_pluggy.auth_manager.authenticate(request)
+            else:
+                user = None
+        except Exception as e:
+            logger.exception(e)
+            user = None
+        # Attach the user to request.state
+        request.state.current_user = user[1] if user else None
+        request.state.roles = user[0] if user else None
+        if hasattr(fast_pluggy.auth_manager, 'get_user_menu_entries'):
+            request.state.user_menu = fast_pluggy.auth_manager.get_user_menu_entries(request)
+        else:
+            request.state.user_menu = []
+        response = await call_next(request)
+        return response

fastpluggy/core/base_module.py

@@ -0,0 +1,73 @@
+import ast
+import os
+
+from loguru import logger
+
+
+class BaseModule:
+    def __init__(self):
+        self.requirements_installed = False
+
+        # self.package_name = f"{self.module_type}s.{name}"
+        self.url = "#"
+
+    def common_module_load_param(self):
+
+        #        self.files = list_modules_in_package(self.module.__path__)
+
+        # Detect models
+        self.discover_models()
+
+    def discover_models(self, base_class_name="Base"):
+        """
+        Discover SQLAlchemy models in a plugin's models.py file using AST.
+
+        Args:
+            base_class_name (str): Name of the SQLAlchemy base class (default is 'Base').
+        """
+        try:
+            # Construct the path to models.py
+            models_path = os.path.join(self.path, "models.py")
+            if not os.path.exists(models_path):
+                logger.debug(f"No models.py file found in module '{self.name}'.")
+                return
+
+            # Parse the models.py file using AST
+            with open(models_path, "r") as file:
+                tree = ast.parse(file.read())
+
+            for node in ast.walk(tree):
+                # Look for class definitions
+                if isinstance(node, ast.ClassDef):
+                    # Check if the class inherits from the specified base class
+                    for base in node.bases:
+                        if (
+                                isinstance(base, ast.Name) and base.id == base_class_name
+                        ) or (
+                                isinstance(base, ast.Attribute) and base.attr == base_class_name
+                        ):
+                            # Check for __tablename__ attribute
+                            tablename = None
+                            for body_item in node.body:
+                                if isinstance(body_item, ast.Assign):
+                                    for target in body_item.targets:
+                                        if (
+                                                isinstance(target, ast.Name)
+                                                and target.id == "__tablename__"
+                                        ):
+                                            if isinstance(body_item.value, ast.Constant):
+                                                tablename = body_item.value.value
+
+                            # Add the discovered model to the module's models
+                            self.models.append(
+                                {"class_name": node.name, "table_name": tablename,
+                                 "module_name": '.'.join([self.package_name, 'models'])}
+                            )
+                            logger.info(
+                                f"Discovered model '{node.name}' with table '{tablename}' in module '{self.name}'"
+                            )
+
+            if not self.models:
+                logger.debug(f"No SQLAlchemy models discovered in module '{self.name}'.")
+        except Exception as e:
+            logger.error(f"Error discovering models in module '{self.name}': {e}")

fastpluggy/core/base_module_manager.py

@@ -0,0 +1,347 @@
+import inspect
+import shutil
+import sys
+import traceback
+import logging
+import types
+from abc import ABC
+from pathlib import Path
+from typing import Dict, Any, List
+
+from fastapi import FastAPI
+from jinja2 import FileSystemLoader
+from loguru import logger
+from sqlalchemy.orm import Session
+
+from fastpluggy.core.database import get_db
+from fastpluggy.core.module_base import FastPluggyBaseModule
+from fastpluggy.core.plugin.dependency_resolver import PluginDependencyResolver
+from fastpluggy.core.plugin.repository import get_all_modules_status
+from fastpluggy.core.plugin.service import PluginService
+from fastpluggy.core.plugin_state import PluginState
+from fastpluggy.core.tools.fs_tools import create_init_file, is_python_module
+from fastpluggy.core.tools.git_tools import get_git_info_for_module
+from fastpluggy.core.tools.inspect_tools import get_module, call_with_injection
+
+
+class BaseModuleManager(ABC):
+    def __init__(self, app: FastAPI, fast_pluggy):
+        self.app = app
+        self.fast_pluggy = fast_pluggy
+
+        self.modules: Dict[str, PluginState] = {}
+
+        self.template_loaders: Dict[str, FileSystemLoader] = {}
+
+        self.db_session: Session = next(get_db())
+        self.plugin_states: Dict[str, bool] = {}
+
+        self.refresh_plugins_states()
+
+    def refresh_plugins_states(self):
+        self.plugin_states = get_all_modules_status(db=self.db_session)
+
+    def get_template_loaders(self):
+        template_loaders = {}
+        for item_info in self.modules.values():
+            if self.is_module_loaded(item_info) and item_info.plugin.templates_dir:
+                name = item_info.plugin.module_name
+                template_loader = FileSystemLoader(str(item_info.plugin.templates_dir))
+                template_loaders[name] = template_loader
+                logger.info(f"Added templates for module '{name}' from {item_info.plugin.templates_dir}")
+
+        return template_loaders
+
+    def register_all_routes(self):
+        for name, item_info in self.modules.items():
+            if self.is_module_loaded(item_info):
+                self.include_routes(item_info)
+
+    def include_routes(self, module_info: PluginState):
+        router = module_info.plugin.module_router
+        if isinstance(router, types.FunctionType):
+            try:
+                module_info.plugin.module_router = module_info.plugin.module_router()
+                logger.debug(f"📡 Router resolved for plugin '{module_info.plugin.module_name}'")
+            except Exception as e:
+                module_info.plugin.module_router = None
+                module_info.error.append(f"Router loading failed: {e}")
+                module_info.traceback.append(traceback.format_exc())
+                logger.warning(f"⚠️ Could not resolve module_router for '{module_info.plugin.module_name}': {e}")
+
+        router = module_info.plugin.module_router
+        if router: # todo : check it's a fast api router
+            url = f"/{module_info.module_type}/{module_info.plugin.module_name}" if module_info.plugin.module_mount_url is None else module_info.plugin.module_mount_url
+
+            if len(router.tags) == 0:
+                router.tags.append(module_info.plugin.module_name)
+
+            # Patch operation_id to avoid duplicates in OpenAPI
+            for route in router.routes:
+                if hasattr(route, "operation_id") and route.operation_id:
+                    continue
+                if hasattr(route, "name") and route.name:
+                    safe_module = module_info.plugin.module_name.replace(".", "_") if module_info.plugin.module_name else "unknown"
+                    route.operation_id = f"{safe_module}_{route.name}"
+
+            self.fast_pluggy.app.include_router(
+                router, prefix=url,
+                tags=router.tags
+            )
+
+            logger.info(f"Router for module '{module_info.plugin.module_name}' included with prefix '{url}'")
+
+    def is_module_loaded(self, module_or_name):
+        """
+        Checks if a module exists and is loaded correctly.
+        Accepts either the module name or a PluginState instance.
+
+        :param module_or_name: PluginState object or module name string.
+        :return: True if the module is enabled and loaded, False otherwise.
+        """
+        if isinstance(module_or_name, str):
+            module_info = self.modules.get(module_or_name)
+        else:
+            module_info = module_or_name
+
+        return (
+            module_info is not None
+            and isinstance(module_info, PluginState)
+            and module_info.plugin is not None
+            and module_info.enabled
+            and module_info.loaded
+        )
+
+    def module_directory_exists(self, plugin_name: str) -> bool:
+        """
+        Checks if a plugin exists in the plugin directory.
+        """
+        module_info = self.modules.get(plugin_name)
+        plugin_path = module_info.path
+        #plugin_path = Path(os.path.join(self.fast_pluggy.get_folder_by_module_type('plugin'), plugin_name))
+        exists = plugin_path.is_dir() and any(plugin_path.glob("*.py"))
+        if exists:
+            logger.info(f"Plugin '{plugin_name}' exists.")
+        else:
+            logger.warning(f"Plugin '{plugin_name}' does not exist.")
+        return exists
+
+    def remove_plugin(self, plugin_name: str):
+        """
+        Removes a plugin directory and refreshes the plugins.
+        """
+
+        if not self.module_directory_exists(plugin_name):
+            logger.error(f"Plugin '{plugin_name}' not found for removal.")
+            raise FileNotFoundError(f"Plugin '{plugin_name}' not found.")
+
+        PluginService.disable_plugin(plugin_name=plugin_name, fast_pluggy=self.fast_pluggy)
+
+        try:
+            #plugin_path = Path(os.path.join(self.fast_pluggy.get_folder_by_module_type('plugin'), plugin_name))
+            module_info = self.modules.get(plugin_name)
+            plugin_path = module_info.path
+
+            shutil.rmtree(plugin_path)
+            logger.info(f"Plugin directory '{plugin_path}' removed.")
+            if plugin_name in sys.modules:
+                del sys.modules[plugin_name]
+                logger.info(f"Module '{plugin_name}' removed from sys.modules.")
+
+        except Exception as e:
+            logger.error(f"Error removing plugin '{plugin_name}': {e}")
+            raise e
+
+        self.fast_pluggy.load_app()
+
+    def _get_extra_files(self, attribute) -> List[Any]:
+        files = []
+        for name,module_info in self.modules.items():
+            if not module_info.loaded:
+                continue
+
+            plugin_attr = getattr(module_info.plugin, attribute, None)
+            if plugin_attr:
+                # plugin_attr is expected to be a list of paths
+                files.extend(plugin_attr)
+
+        return list(dict.fromkeys(files))
+
+    def get_extra_js_files(self):
+        return self._get_extra_files("extra_js_files")
+
+    def get_extra_css_files(self):
+        return self._get_extra_files("extra_css_files")
+
+    def discover_plugins(self, folder: str, module_type: str):
+        folder_path = Path(folder)
+
+        if not folder_path.exists():
+            folder_path.mkdir(parents=True, exist_ok=True)
+            logger.info(f"Created missing domain directory at {folder}")
+
+        create_init_file(folder)
+
+        # Add folder to module search path
+        domain_path = folder_path.resolve()
+        sys.path.append(str(domain_path))
+
+        logger.info(f"🔍 Discovering {module_type} modules in {domain_path}")
+
+        for plugin_dir in folder_path.iterdir():
+            if not plugin_dir.is_dir() or plugin_dir.name.startswith('.') \
+                    or not is_python_module(plugin_dir):
+                continue
+
+            plugin_file = plugin_dir / "plugin.py"
+            plugin_dir_name = plugin_dir.name
+            #module_name = f"{module_type}s.{plugin_dir_name}"
+
+            plugin_state = PluginState(
+                module_type=module_type,
+                path=plugin_dir,
+            )
+            logging.info(f"plugin file : {plugin_file}")
+
+
+            if not plugin_file.exists():
+                msg = f"Missing plugin.py in {plugin_dir_name}"
+                logger.warning(f"❌ {msg}")
+                plugin_state.error.append(msg)
+                plugin_state.plugin = FastPluggyBaseModule(module_name=plugin_dir_name)
+                self.modules[plugin_dir_name] = plugin_state
+                continue
+
+            try:
+                # STEP 1: Import module
+                package = get_module(module_name=plugin_dir_name, module_path=str(plugin_dir.resolve()))
+                plugin_module = getattr(package, "plugin", package)
+
+                # STEP 2: Get plugin class
+                plugin_class = next(
+                    (cls for _, cls in inspect.getmembers(plugin_module)
+                     if inspect.isclass(cls)
+                     and issubclass(cls, FastPluggyBaseModule)
+                     and cls is not FastPluggyBaseModule),
+                    None
+                )
+
+                if not plugin_class:
+                    msg = f"No valid plugin class in {plugin_dir_name}"
+                    logger.warning(f"⚠️ {msg}")
+                    plugin_state.error.append(msg)
+                    plugin_state.plugin = FastPluggyBaseModule(module_name=plugin_dir_name)
+                    self.modules[plugin_dir_name] = plugin_state
+                    continue
+
+                # STEP 3: Instantiate
+                plugin_instance = plugin_class()
+                plugin_instance.module_path = plugin_dir
+
+                plugin_state.plugin = plugin_instance
+                plugin_state.initialized = True
+                plugin_state.enabled=self.plugin_states.get(plugin_instance.module_name, True)
+
+                self.modules[plugin_instance.module_name] = plugin_state
+
+                logger.info(f"Plugin '{plugin_instance.module_name}' discovered in {folder}")
+                #if plugin_dir_name != plugin_instance.module_name:
+                #    logger.info(f"Re-key the discovered plugin '{plugin_dir_name}' to '{plugin_instance.module_name}'")
+                #    self.modules[plugin_instance.module_name] = plugin_state
+
+            except Exception as e:
+                err_msg = f"Failed to load plugin '{plugin_dir_name}': {str(e)}"
+                logger.exception(f"🚨 {err_msg}")
+                plugin_state.plugin = FastPluggyBaseModule(module_name=plugin_dir_name)
+                plugin_state.plugin.module_menu_icon = "fas fa-exclamation-triangle"
+                plugin_state.error.append(err_msg)
+                plugin_state.traceback.append(traceback.format_exc())
+                plugin_state.initialized = False
+                plugin_state.process()
+                self.modules[plugin_dir_name] = plugin_state
+
+    def initialize_plugins_in_order(self):
+        result = PluginDependencyResolver.get_sorted_modules_by_dependency(self.modules)
+        PluginDependencyResolver.update_plugin_states_from_result(result, self.modules)
+
+        if not result["success"]:
+            logger.error(f"❌ Dependency resolution failed: {result['error']}")
+            return
+
+        for name in result["sorted_modules"]:
+            plugin_state = self.modules.get(name)
+            if not plugin_state or not plugin_state.enabled and plugin_state.initialized:
+                continue
+
+            try:
+                # STEP 4: Install deps, git info, etc.
+                if self.fast_pluggy.settings.install_module_requirement_at_start:
+                    try:
+                        from fastpluggy.core.routers.actions.modules import install_module_requirements
+                        install_module_requirements(module_name=name, fast_pluggy=self.fast_pluggy)
+                    except Exception as install_err:
+                        plugin_state.error.append(f"Failed to install requirements: {install_err}")
+                        plugin_state.traceback.append(traceback.format_exc())
+
+                get_git_info_for_module(module=plugin_state) # todo make async and avoid fail
+                plugin_state.loaded = True
+                logger.success(f"✅ Plugin initialized: {plugin_state.plugin.display_name} ({plugin_state.plugin.module_name})")
+
+            except Exception as e:
+                logger.exception(f"🚨 Error loading plugin '{name}': {e}")
+                plugin_state.error.append(str(e))
+                plugin_state.traceback.append(traceback.format_exc())
+                plugin_state.plugin = FastPluggyBaseModule(module_name=name)
+                plugin_state.plugin.module_menu_icon = "fas fa-exclamation-triangle"
+                plugin_state.loaded = False
+
+            finally:
+                try:
+                    plugin_state.process()
+                except Exception as process_err:
+                    plugin_state.error.append(f"Error in process(): {process_err}")
+                    plugin_state.traceback.append(traceback.format_exc())
+                    plugin_state.loaded = False
+
+        return result
+
+    def execute_all_module_hook(self, hook_name: str, require_loaded: bool = True):
+        logger.info(f"Executing hook '{hook_name}' (require_loaded:{require_loaded}) for all modules...")
+        for module_name, module_info in self.modules.items():
+            if not module_info.enabled:
+                continue
+
+            if require_loaded and not module_info.loaded:
+                logger.warning(f"Skipping hook '{hook_name}' for module '{module_name}' because it is not loaded.")
+                continue
+
+            self.call_plugin_hook(plugin_state=module_info, hook_name=hook_name)
+
+
+    def call_plugin_hook(self, plugin_state, hook_name: str, **kwargs):
+        plugin = plugin_state.plugin
+        if not hasattr(plugin, hook_name):
+            return
+
+        hook = getattr(plugin, hook_name)
+        if not callable(hook):
+            return
+
+        try:
+            logger.debug(f"🔧 Calling '{hook_name}' for plugin '{plugin.module_name}'")
+
+            from fastpluggy.fastpluggy import FastPluggy
+            call_with_injection(
+                func=hook,
+                context_dict={
+                    FastPluggy: self.fast_pluggy,
+                    #  BaseModuleManager: self,
+                },
+                user_kwargs=kwargs
+            )
+
+        except Exception as e:
+            logger.exception(f"❌ Error in '{hook_name}' of plugin '{plugin.module_name}': {e}")
+            plugin_state.error.append(str(e))
+            plugin_state.traceback.append(traceback.format_exc())
+            plugin_state.plugin.module_menu_icon = "fas fa-exclamation-triangle"

fastpluggy/core/config.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from pydantic.v1 import BaseSettings
+
+from fastpluggy.core.repository.app_settings import database_settings_source
+
+
+class BaseDatabaseSettings(BaseSettings):
+    class Config:
+        @classmethod
+        def customise_sources(
+            cls,
+            init_settings,
+            env_settings,
+            file_secret_settings
+        ):
+            return (
+                init_settings,  # 1. Explicitly passed settings
+                env_settings,   # 2. Environment variables
+                file_secret_settings,  # 3. Secrets from files
+                database_settings_source,  # 4. Custom database source
+            )
+
+class FastPluggyConfig(BaseDatabaseSettings):
+    app_name : Optional[str] = 'FastPluggy'
+
+    # admin config
+    admin_enabled:Optional[bool] = True
+    fp_admin_base_url : Optional[str] = '/admin'
+    plugin_list_url : Optional[str] = 'https://registry.fastpluggy.xyz/plugins.json'
+
+    show_empty_menu_entries: Optional[bool] = True
+    install_module_requirement_at_start:Optional[bool] = False
+    check_all_plugin_updates_at_start:Optional[bool] = False
+#    thread_pool_max_workers:int=50
+
+    session_secret_key:str = "your-secret-key"
+