mmrelay 1.0.3__tar.gz → 1.0.4__tar.gz

{mmrelay-1.0.3/src/mmrelay.egg-info → mmrelay-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0.3
+Version: 1.0.4
 Summary: Bridge between Meshtastic mesh networks and Matrix chat rooms
 Home-page: https://github.com/geoffwhittington/meshtastic-matrix-relay
 Author: Geoff Whittington, Jeremiah K., and contributors

{mmrelay-1.0.3 → mmrelay-1.0.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = mmrelay
-version = 1.0.3
+version = 1.0.4
 author = Geoff Whittington, Jeremiah K., and contributors
 author_email = jeremiahk@gmx.com
 description = Bridge between Meshtastic mesh networks and Matrix chat rooms

{mmrelay-1.0.3 → mmrelay-1.0.4}/src/mmrelay/config.py

@@ -103,6 +103,32 @@ def get_data_dir():
     return data_dir
 
 
+def get_plugin_data_dir(plugin_name=None):
+    """
+    Returns the directory for storing plugin-specific data files.
+    If plugin_name is provided, returns a plugin-specific subdirectory.
+    Creates the directory if it doesn't exist.
+
+    Example:
+    - get_plugin_data_dir() returns ~/.mmrelay/data/plugins/
+    - get_plugin_data_dir("my_plugin") returns ~/.mmrelay/data/plugins/my_plugin/
+    """
+    # Get the base data directory
+    base_data_dir = get_data_dir()
+
+    # Create the plugins directory
+    plugins_data_dir = os.path.join(base_data_dir, "plugins")
+    os.makedirs(plugins_data_dir, exist_ok=True)
+
+    # If a plugin name is provided, create and return a plugin-specific directory
+    if plugin_name:
+        plugin_data_dir = os.path.join(plugins_data_dir, plugin_name)
+        os.makedirs(plugin_data_dir, exist_ok=True)
+        return plugin_data_dir
+
+    return plugins_data_dir
+
+
 def get_log_dir():
     """
     Returns the directory for storing log files.

mmrelay-1.0.4/src/mmrelay/plugin_loader.py

@@ -0,0 +1,642 @@
+# trunk-ignore-all(bandit)
+import hashlib
+import importlib.util
+import os
+import subprocess
+import sys
+
+from mmrelay.config import get_app_path, get_base_dir
+from mmrelay.log_utils import get_logger
+
+# Global config variable that will be set from main.py
+config = None
+
+logger = get_logger(name="Plugins")
+sorted_active_plugins = []
+plugins_loaded = False
+
+
+def get_custom_plugin_dirs():
+    """
+    Returns a list of directories to check for custom plugins in order of priority:
+    1. User directory (~/.mmrelay/plugins/custom)
+    2. Local directory (plugins/custom) for backward compatibility
+    """
+    dirs = []
+
+    # Check user directory first (preferred location)
+    user_dir = os.path.join(get_base_dir(), "plugins", "custom")
+    os.makedirs(user_dir, exist_ok=True)
+    dirs.append(user_dir)
+
+    # Check local directory (backward compatibility)
+    local_dir = os.path.join(get_app_path(), "plugins", "custom")
+    dirs.append(local_dir)
+
+    return dirs
+
+
+def get_community_plugin_dirs():
+    """
+    Returns a list of directories to check for community plugins in order of priority:
+    1. User directory (~/.mmrelay/plugins/community)
+    2. Local directory (plugins/community) for backward compatibility
+    """
+    dirs = []
+
+    # Check user directory first (preferred location)
+    user_dir = os.path.join(get_base_dir(), "plugins", "community")
+    os.makedirs(user_dir, exist_ok=True)
+    dirs.append(user_dir)
+
+    # Check local directory (backward compatibility)
+    local_dir = os.path.join(get_app_path(), "plugins", "community")
+    dirs.append(local_dir)
+
+    return dirs
+
+
+def clone_or_update_repo(repo_url, tag, plugins_dir):
+    # Extract the repository name from the URL
+    repo_name = os.path.splitext(os.path.basename(repo_url.rstrip("/")))[0]
+    repo_path = os.path.join(plugins_dir, repo_name)
+
+    # Default branch names to try if tag is not specified
+    default_branches = ["main", "master"]
+
+    # If tag is one of the default branches, we'll handle it as a branch
+    is_default_branch = tag in default_branches
+
+    if os.path.isdir(repo_path):
+        try:
+            # Fetch all branches but don't fetch tags to avoid conflicts
+            try:
+                subprocess.check_call(["git", "-C", repo_path, "fetch", "origin"])
+            except subprocess.CalledProcessError as e:
+                logger.warning(f"Error fetching from remote: {e}")
+                # Continue anyway, we'll try to use what we have
+
+            # If it's a default branch, handle it differently
+            if is_default_branch:
+                try:
+                    # Check if we're already on the right branch
+                    current_branch = subprocess.check_output(
+                        ["git", "-C", repo_path, "rev-parse", "--abbrev-ref", "HEAD"],
+                        universal_newlines=True,
+                    ).strip()
+
+                    if current_branch == tag:
+                        # We're on the right branch, just pull
+                        try:
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "pull", "origin", tag]
+                            )
+                            logger.info(f"Updated repository {repo_name} branch {tag}")
+                            return True
+                        except subprocess.CalledProcessError as e:
+                            logger.warning(f"Error pulling branch {tag}: {e}")
+                            # Continue anyway, we'll use what we have
+                            return True
+                    else:
+                        # Switch to the right branch
+                        subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "pull", "origin", tag]
+                        )
+                        logger.info(f"Switched to and updated branch {tag}")
+                        return True
+                except subprocess.CalledProcessError:
+                    # If we can't checkout the specified branch, try the other default branch
+                    other_default = "main" if tag == "master" else "master"
+                    try:
+                        logger.warning(
+                            f"Branch {tag} not found, trying {other_default}"
+                        )
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "checkout", other_default]
+                        )
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "pull", "origin", other_default]
+                        )
+                        logger.info(f"Using {other_default} branch instead of {tag}")
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails too, just use whatever branch we're on
+                        logger.warning(
+                            "Could not checkout any default branch, using current branch"
+                        )
+                        return True
+            else:
+                # Handle tag checkout
+                # Check if we're already on the correct tag/commit
+                try:
+                    # Get the current commit hash
+                    current_commit = subprocess.check_output(
+                        ["git", "-C", repo_path, "rev-parse", "HEAD"],
+                        universal_newlines=True,
+                    ).strip()
+
+                    # Get the commit hash for the tag
+                    tag_commit = None
+                    try:
+                        tag_commit = subprocess.check_output(
+                            ["git", "-C", repo_path, "rev-parse", tag],
+                            universal_newlines=True,
+                        ).strip()
+                    except subprocess.CalledProcessError:
+                        # Tag doesn't exist locally, we'll need to fetch it
+                        pass
+
+                    # If we're already at the tag's commit, we're done
+                    if tag_commit and current_commit == tag_commit:
+                        logger.info(f"Repository {repo_name} is already at tag {tag}")
+                        return True
+
+                    # Otherwise, try to checkout the tag
+                    subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
+                    logger.info(f"Updated repository {repo_name} to tag {tag}")
+                    return True
+                except subprocess.CalledProcessError:
+                    # If tag checkout fails, try to fetch it specifically
+                    logger.warning(
+                        f"Tag {tag} not found locally, trying to fetch it specifically"
+                    )
+                    try:
+                        # Try to fetch the specific tag, but first remove any existing tag with the same name
+                        try:
+                            # Delete the local tag if it exists to avoid conflicts
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "tag", "-d", tag]
+                            )
+                        except subprocess.CalledProcessError:
+                            # Tag doesn't exist locally, which is fine
+                            pass
+
+                        # Now fetch the tag from remote
+                        try:
+                            # Try to fetch the tag
+                            subprocess.check_call(
+                                [
+                                    "git",
+                                    "-C",
+                                    repo_path,
+                                    "fetch",
+                                    "origin",
+                                    f"refs/tags/{tag}",
+                                ]
+                            )
+                        except subprocess.CalledProcessError:
+                            # If that fails, try to fetch the tag without the refs/tags/ prefix
+                            subprocess.check_call(
+                                [
+                                    "git",
+                                    "-C",
+                                    repo_path,
+                                    "fetch",
+                                    "origin",
+                                    f"refs/tags/{tag}:refs/tags/{tag}",
+                                ]
+                            )
+
+                        subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
+                        logger.info(f"Successfully fetched and checked out tag {tag}")
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails too, try as a branch
+                        logger.warning(f"Could not fetch tag {tag}, trying as a branch")
+                        try:
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "fetch", "origin", tag]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "checkout", tag]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "pull", "origin", tag]
+                            )
+                            logger.info(
+                                f"Updated repository {repo_name} to branch {tag}"
+                            )
+                            return True
+                        except subprocess.CalledProcessError:
+                            # If all else fails, just use a default branch
+                            logger.warning(
+                                f"Could not checkout {tag} as tag or branch, trying default branches"
+                            )
+                            for default_branch in default_branches:
+                                try:
+                                    subprocess.check_call(
+                                        [
+                                            "git",
+                                            "-C",
+                                            repo_path,
+                                            "checkout",
+                                            default_branch,
+                                        ]
+                                    )
+                                    subprocess.check_call(
+                                        [
+                                            "git",
+                                            "-C",
+                                            repo_path,
+                                            "pull",
+                                            "origin",
+                                            default_branch,
+                                        ]
+                                    )
+                                    logger.info(
+                                        f"Using {default_branch} instead of {tag}"
+                                    )
+                                    return True
+                                except subprocess.CalledProcessError:
+                                    continue
+
+                            # If we get here, we couldn't checkout any branch
+                            logger.warning(
+                                "Could not checkout any branch, using current state"
+                            )
+                            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error updating repository {repo_name}: {e}")
+            logger.error(
+                f"Please manually git clone the repository {repo_url} into {repo_path}"
+            )
+            return False
+    else:
+        # Repository doesn't exist yet, clone it
+        try:
+            os.makedirs(plugins_dir, exist_ok=True)
+
+            # If it's a default branch, just clone it directly
+            if is_default_branch:
+                try:
+                    # Try to clone with the specified branch
+                    subprocess.check_call(
+                        ["git", "clone", "--branch", tag, repo_url], cwd=plugins_dir
+                    )
+                    logger.info(
+                        f"Cloned repository {repo_name} from {repo_url} at branch {tag}"
+                    )
+                    return True
+                except subprocess.CalledProcessError:
+                    # If that fails, try the other default branch
+                    other_default = "main" if tag == "master" else "master"
+                    try:
+                        logger.warning(
+                            f"Could not clone with branch {tag}, trying {other_default}"
+                        )
+                        subprocess.check_call(
+                            ["git", "clone", "--branch", other_default, repo_url],
+                            cwd=plugins_dir,
+                        )
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} at branch {other_default}"
+                        )
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails too, clone without specifying a branch
+                        logger.warning(
+                            f"Could not clone with branch {other_default}, cloning default branch"
+                        )
+                        subprocess.check_call(
+                            ["git", "clone", repo_url], cwd=plugins_dir
+                        )
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} (default branch)"
+                        )
+                        return True
+            else:
+                # It's a tag, try to clone with the tag
+                try:
+                    # Try to clone with the specified tag
+                    subprocess.check_call(
+                        ["git", "clone", "--branch", tag, repo_url], cwd=plugins_dir
+                    )
+                    logger.info(
+                        f"Cloned repository {repo_name} from {repo_url} at tag {tag}"
+                    )
+                    return True
+                except subprocess.CalledProcessError:
+                    # If that fails, clone without specifying a tag
+                    logger.warning(
+                        f"Could not clone with tag {tag}, cloning default branch"
+                    )
+                    subprocess.check_call(["git", "clone", repo_url], cwd=plugins_dir)
+
+                    # Then try to fetch and checkout the tag
+                    try:
+                        # Try to fetch the tag
+                        try:
+                            subprocess.check_call(
+                                [
+                                    "git",
+                                    "-C",
+                                    repo_path,
+                                    "fetch",
+                                    "origin",
+                                    f"refs/tags/{tag}",
+                                ]
+                            )
+                        except subprocess.CalledProcessError:
+                            # If that fails, try to fetch the tag without the refs/tags/ prefix
+                            subprocess.check_call(
+                                [
+                                    "git",
+                                    "-C",
+                                    repo_path,
+                                    "fetch",
+                                    "origin",
+                                    f"refs/tags/{tag}:refs/tags/{tag}",
+                                ]
+                            )
+
+                        # Now checkout the tag
+                        subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
+                        logger.info(
+                            f"Cloned repository {repo_name} and checked out tag {tag}"
+                        )
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails, try as a branch
+                        try:
+                            logger.warning(
+                                f"Could not checkout {tag} as a tag, trying as a branch"
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "fetch", "origin", tag]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "checkout", tag]
+                            )
+                            logger.info(
+                                f"Cloned repository {repo_name} and checked out branch {tag}"
+                            )
+                            return True
+                        except subprocess.CalledProcessError:
+                            logger.warning(
+                                f"Could not checkout {tag}, using default branch"
+                            )
+                            logger.info(
+                                f"Cloned repository {repo_name} from {repo_url} (default branch)"
+                            )
+                            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error cloning repository {repo_name}: {e}")
+            logger.error(
+                f"Please manually git clone the repository {repo_url} into {repo_path}"
+            )
+            return False
+    # Install requirements if requirements.txt exists
+    requirements_path = os.path.join(repo_path, "requirements.txt")
+    if os.path.isfile(requirements_path):
+        try:
+            # Use pip to install the requirements.txt
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", "-r", requirements_path]
+            )
+            logger.info(f"Installed requirements for plugin {repo_name}")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error installing requirements for plugin {repo_name}: {e}")
+            logger.error(
+                f"Please manually install the requirements from {requirements_path}"
+            )
+            sys.exit(1)
+
+
+def load_plugins_from_directory(directory, recursive=False):
+    plugins = []
+    if os.path.isdir(directory):
+        for root, _dirs, files in os.walk(directory):
+            for filename in files:
+                if filename.endswith(".py"):
+                    plugin_path = os.path.join(root, filename)
+                    module_name = (
+                        "plugin_"
+                        + hashlib.sha256(plugin_path.encode("utf-8")).hexdigest()
+                    )
+                    spec = importlib.util.spec_from_file_location(
+                        module_name, plugin_path
+                    )
+                    plugin_module = importlib.util.module_from_spec(spec)
+                    try:
+                        spec.loader.exec_module(plugin_module)
+                        if hasattr(plugin_module, "Plugin"):
+                            plugins.append(plugin_module.Plugin())
+                        else:
+                            logger.warning(
+                                f"{plugin_path} does not define a Plugin class."
+                            )
+                    except Exception as e:
+                        logger.error(f"Error loading plugin {plugin_path}: {e}")
+            if not recursive:
+                break
+    else:
+        if not plugins_loaded:  # Only log the missing directory once
+            logger.debug(f"Directory {directory} does not exist.")
+    return plugins
+
+
+def load_plugins(passed_config=None):
+    global sorted_active_plugins
+    global plugins_loaded
+    global config
+
+    if plugins_loaded:
+        return sorted_active_plugins
+
+    logger.info("Checking plugin config...")
+
+    # Update the global config if a config is passed
+    if passed_config is not None:
+        config = passed_config
+
+    # Check if config is available
+    if config is None:
+        logger.error("No configuration available. Cannot load plugins.")
+        return []
+
+    # Import core plugins
+    from mmrelay.plugins.debug_plugin import Plugin as DebugPlugin
+    from mmrelay.plugins.drop_plugin import Plugin as DropPlugin
+    from mmrelay.plugins.health_plugin import Plugin as HealthPlugin
+    from mmrelay.plugins.help_plugin import Plugin as HelpPlugin
+    from mmrelay.plugins.map_plugin import Plugin as MapPlugin
+    from mmrelay.plugins.mesh_relay_plugin import Plugin as MeshRelayPlugin
+    from mmrelay.plugins.nodes_plugin import Plugin as NodesPlugin
+    from mmrelay.plugins.ping_plugin import Plugin as PingPlugin
+    from mmrelay.plugins.telemetry_plugin import Plugin as TelemetryPlugin
+    from mmrelay.plugins.weather_plugin import Plugin as WeatherPlugin
+
+    # Initial list of core plugins
+    core_plugins = [
+        HealthPlugin(),
+        MapPlugin(),
+        MeshRelayPlugin(),
+        PingPlugin(),
+        TelemetryPlugin(),
+        WeatherPlugin(),
+        HelpPlugin(),
+        NodesPlugin(),
+        DropPlugin(),
+        DebugPlugin(),
+    ]
+
+    plugins = core_plugins.copy()
+
+    # Process and load custom plugins
+    custom_plugins_config = config.get("custom-plugins", {})
+    custom_plugin_dirs = get_custom_plugin_dirs()
+
+    active_custom_plugins = [
+        plugin_name
+        for plugin_name, plugin_info in custom_plugins_config.items()
+        if plugin_info.get("active", False)
+    ]
+
+    if active_custom_plugins:
+        logger.debug(
+            f"Loading active custom plugins: {', '.join(active_custom_plugins)}"
+        )
+
+    # Only load custom plugins that are explicitly enabled
+    for plugin_name in active_custom_plugins:
+        plugin_found = False
+
+        # Try each directory in order
+        for custom_dir in custom_plugin_dirs:
+            plugin_path = os.path.join(custom_dir, plugin_name)
+            if os.path.exists(plugin_path):
+                logger.debug(f"Loading custom plugin from: {plugin_path}")
+                plugins.extend(
+                    load_plugins_from_directory(plugin_path, recursive=False)
+                )
+                plugin_found = True
+                break
+
+        if not plugin_found:
+            logger.warning(
+                f"Custom plugin '{plugin_name}' not found in any of the plugin directories"
+            )
+
+    # Process and download community plugins
+    community_plugins_config = config.get("community-plugins", {})
+    community_plugin_dirs = get_community_plugin_dirs()
+
+    # Get the first directory for cloning (prefer user directory)
+    community_plugins_dir = community_plugin_dirs[
+        -1
+    ]  # Use the user directory for new clones
+
+    # Create community plugins directory if needed
+    active_community_plugins = [
+        plugin_name
+        for plugin_name, plugin_info in community_plugins_config.items()
+        if plugin_info.get("active", False)
+    ]
+
+    if active_community_plugins:
+        # Ensure all community plugin directories exist
+        for dir_path in community_plugin_dirs:
+            os.makedirs(dir_path, exist_ok=True)
+
+        logger.debug(
+            f"Loading active community plugins: {', '.join(active_community_plugins)}"
+        )
+
+    # Only process community plugins if config section exists and is a dictionary
+    if isinstance(community_plugins_config, dict):
+        for plugin_name, plugin_info in community_plugins_config.items():
+            if not plugin_info.get("active", False):
+                logger.debug(
+                    f"Skipping community plugin {plugin_name} - not active in config"
+                )
+                continue
+
+            repo_url = plugin_info.get("repository")
+            tag = plugin_info.get("tag", "master")
+            if repo_url:
+                # Clone to the user directory by default
+                success = clone_or_update_repo(repo_url, tag, community_plugins_dir)
+                if not success:
+                    logger.warning(
+                        f"Failed to clone/update plugin {plugin_name}, skipping"
+                    )
+                    continue
+            else:
+                logger.error("Repository URL not specified for a community plugin")
+                logger.error("Please specify the repository URL in config.yaml")
+                continue
+
+    # Only load community plugins that are explicitly enabled
+    for plugin_name in active_community_plugins:
+        plugin_info = community_plugins_config[plugin_name]
+        repo_url = plugin_info.get("repository")
+        if repo_url:
+            # Extract repository name from URL
+            repo_name = os.path.splitext(os.path.basename(repo_url.rstrip("/")))[0]
+
+            # Try each directory in order
+            plugin_found = False
+            for dir_path in community_plugin_dirs:
+                plugin_path = os.path.join(dir_path, repo_name)
+                if os.path.exists(plugin_path):
+                    logger.debug(f"Loading community plugin from: {plugin_path}")
+                    plugins.extend(
+                        load_plugins_from_directory(plugin_path, recursive=True)
+                    )
+                    plugin_found = True
+                    break
+
+            if not plugin_found:
+                logger.warning(
+                    f"Community plugin '{repo_name}' not found in any of the plugin directories"
+                )
+        else:
+            logger.error(
+                f"Repository URL not specified for community plugin: {plugin_name}"
+            )
+
+    # Filter and sort active plugins by priority
+    active_plugins = []
+    for plugin in plugins:
+        plugin_name = getattr(plugin, "plugin_name", plugin.__class__.__name__)
+
+        # Determine if the plugin is active based on the configuration
+        if plugin in core_plugins:
+            # Core plugins: default to inactive unless specified otherwise
+            plugin_config = config.get("plugins", {}).get(plugin_name, {})
+            is_active = plugin_config.get("active", False)
+        else:
+            # Custom and community plugins: default to inactive unless specified
+            if plugin_name in config.get("custom-plugins", {}):
+                plugin_config = config.get("custom-plugins", {}).get(plugin_name, {})
+            elif plugin_name in community_plugins_config:
+                plugin_config = community_plugins_config.get(plugin_name, {})
+            else:
+                plugin_config = {}
+
+            is_active = plugin_config.get("active", False)
+
+        if is_active:
+            plugin.priority = plugin_config.get(
+                "priority", getattr(plugin, "priority", 100)
+            )
+            active_plugins.append(plugin)
+            try:
+                plugin.start()
+            except Exception as e:
+                logger.error(f"Error starting plugin {plugin_name}: {e}")
+
+    sorted_active_plugins = sorted(active_plugins, key=lambda plugin: plugin.priority)
+
+    # Log all loaded plugins
+    if sorted_active_plugins:
+        plugin_names = [
+            getattr(plugin, "plugin_name", plugin.__class__.__name__)
+            for plugin in sorted_active_plugins
+        ]
+        logger.info(f"Plugins loaded: {', '.join(plugin_names)}")
+    else:
+        logger.info("Plugins loaded: none")
+
+    plugins_loaded = True  # Set the flag to indicate that plugins have been load

{mmrelay-1.0.3 → mmrelay-1.0.4}/src/mmrelay/plugins/base_plugin.py

@@ -1,3 +1,4 @@
+import os
 import threading
 import time
 from abc import ABC, abstractmethod
@@ -5,6 +6,7 @@ from abc import ABC, abstractmethod
 import markdown
 import schedule
 
+from mmrelay.config import get_plugin_data_dir
 from mmrelay.db_utils import (
     delete_plugin_data,
     get_plugin_data,
@@ -195,6 +197,33 @@ class BasePlugin(ABC):
     def get_data(self):
         return get_plugin_data(self.plugin_name)
 
+    def get_plugin_data_dir(self, subdir=None):
+        """
+        Returns the directory for storing plugin-specific data files.
+        Creates the directory if it doesn't exist.
+
+        Args:
+            subdir (str, optional): Optional subdirectory within the plugin's data directory.
+                                   If provided, this subdirectory will be created.
+
+        Returns:
+            str: Path to the plugin's data directory or subdirectory
+
+        Example:
+            self.get_plugin_data_dir() returns ~/.mmrelay/data/plugins/your_plugin_name/
+            self.get_plugin_data_dir("data_files") returns ~/.mmrelay/data/plugins/your_plugin_name/data_files/
+        """
+        # Get the plugin-specific data directory
+        plugin_dir = get_plugin_data_dir(self.plugin_name)
+
+        # If a subdirectory is specified, create and return it
+        if subdir:
+            subdir_path = os.path.join(plugin_dir, subdir)
+            os.makedirs(subdir_path, exist_ok=True)
+            return subdir_path
+
+        return plugin_dir
+
     def matches(self, event):
         from mmrelay.matrix_utils import bot_command
 

{mmrelay-1.0.3 → mmrelay-1.0.4/src/mmrelay.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0.3
+Version: 1.0.4
 Summary: Bridge between Meshtastic mesh networks and Matrix chat rooms
 Home-page: https://github.com/geoffwhittington/meshtastic-matrix-relay
 Author: Geoff Whittington, Jeremiah K., and contributors

mmrelay-1.0.3/src/mmrelay/plugin_loader.py

@@ -1,336 +0,0 @@
-# trunk-ignore-all(bandit)
-import hashlib
-import importlib.util
-import os
-import subprocess
-import sys
-
-from mmrelay.config import get_app_path, get_base_dir
-from mmrelay.log_utils import get_logger
-
-# Global config variable that will be set from main.py
-config = None
-
-logger = get_logger(name="Plugins")
-sorted_active_plugins = []
-plugins_loaded = False
-
-
-def get_custom_plugin_dirs():
-    """
-    Returns a list of directories to check for custom plugins in order of priority:
-    1. User directory (~/.mmrelay/plugins/custom)
-    2. Local directory (plugins/custom) for backward compatibility
-    """
-    dirs = []
-
-    # Check user directory first (preferred location)
-    user_dir = os.path.join(get_base_dir(), "plugins", "custom")
-    os.makedirs(user_dir, exist_ok=True)
-    dirs.append(user_dir)
-
-    # Check local directory (backward compatibility)
-    local_dir = os.path.join(get_app_path(), "plugins", "custom")
-    dirs.append(local_dir)
-
-    return dirs
-
-
-def get_community_plugin_dirs():
-    """
-    Returns a list of directories to check for community plugins in order of priority:
-    1. User directory (~/.mmrelay/plugins/community)
-    2. Local directory (plugins/community) for backward compatibility
-    """
-    dirs = []
-
-    # Check user directory first (preferred location)
-    user_dir = os.path.join(get_base_dir(), "plugins", "community")
-    os.makedirs(user_dir, exist_ok=True)
-    dirs.append(user_dir)
-
-    # Check local directory (backward compatibility)
-    local_dir = os.path.join(get_app_path(), "plugins", "community")
-    dirs.append(local_dir)
-
-    return dirs
-
-
-def clone_or_update_repo(repo_url, tag, plugins_dir):
-    # Extract the repository name from the URL
-    repo_name = os.path.splitext(os.path.basename(repo_url.rstrip("/")))[0]
-    repo_path = os.path.join(plugins_dir, repo_name)
-    if os.path.isdir(repo_path):
-        try:
-            subprocess.check_call(["git", "-C", repo_path, "fetch"])
-            subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
-            subprocess.check_call(["git", "-C", repo_path, "pull", "origin", tag])
-            logger.info(f"Updated repository {repo_name} to {tag}")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Error updating repository {repo_name}: {e}")
-            logger.error(
-                f"Please manually git clone the repository {repo_url} into {repo_path}"
-            )
-            sys.exit(1)
-    else:
-        try:
-            os.makedirs(plugins_dir, exist_ok=True)
-            subprocess.check_call(
-                ["git", "clone", "--branch", tag, repo_url], cwd=plugins_dir
-            )
-            logger.info(f"Cloned repository {repo_name} from {repo_url} at {tag}")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Error cloning repository {repo_name}: {e}")
-            logger.error(
-                f"Please manually git clone the repository {repo_url} into {repo_path}"
-            )
-            sys.exit(1)
-    # Install requirements if requirements.txt exists
-    requirements_path = os.path.join(repo_path, "requirements.txt")
-    if os.path.isfile(requirements_path):
-        try:
-            # Use pip to install the requirements.txt
-            subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", "-r", requirements_path]
-            )
-            logger.info(f"Installed requirements for plugin {repo_name}")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Error installing requirements for plugin {repo_name}: {e}")
-            logger.error(
-                f"Please manually install the requirements from {requirements_path}"
-            )
-            sys.exit(1)
-
-
-def load_plugins_from_directory(directory, recursive=False):
-    plugins = []
-    if os.path.isdir(directory):
-        for root, _dirs, files in os.walk(directory):
-            for filename in files:
-                if filename.endswith(".py"):
-                    plugin_path = os.path.join(root, filename)
-                    module_name = (
-                        "plugin_"
-                        + hashlib.sha256(plugin_path.encode("utf-8")).hexdigest()
-                    )
-                    spec = importlib.util.spec_from_file_location(
-                        module_name, plugin_path
-                    )
-                    plugin_module = importlib.util.module_from_spec(spec)
-                    try:
-                        spec.loader.exec_module(plugin_module)
-                        if hasattr(plugin_module, "Plugin"):
-                            plugins.append(plugin_module.Plugin())
-                        else:
-                            logger.warning(
-                                f"{plugin_path} does not define a Plugin class."
-                            )
-                    except Exception as e:
-                        logger.error(f"Error loading plugin {plugin_path}: {e}")
-            if not recursive:
-                break
-    else:
-        if not plugins_loaded:  # Only log the missing directory once
-            logger.debug(f"Directory {directory} does not exist.")
-    return plugins
-
-
-def load_plugins(passed_config=None):
-    global sorted_active_plugins
-    global plugins_loaded
-    global config
-
-    if plugins_loaded:
-        return sorted_active_plugins
-
-    logger.info("Checking plugin config...")
-
-    # Update the global config if a config is passed
-    if passed_config is not None:
-        config = passed_config
-
-    # Check if config is available
-    if config is None:
-        logger.error("No configuration available. Cannot load plugins.")
-        return []
-
-    # Import core plugins
-    from mmrelay.plugins.debug_plugin import Plugin as DebugPlugin
-    from mmrelay.plugins.drop_plugin import Plugin as DropPlugin
-    from mmrelay.plugins.health_plugin import Plugin as HealthPlugin
-    from mmrelay.plugins.help_plugin import Plugin as HelpPlugin
-    from mmrelay.plugins.map_plugin import Plugin as MapPlugin
-    from mmrelay.plugins.mesh_relay_plugin import Plugin as MeshRelayPlugin
-    from mmrelay.plugins.nodes_plugin import Plugin as NodesPlugin
-    from mmrelay.plugins.ping_plugin import Plugin as PingPlugin
-    from mmrelay.plugins.telemetry_plugin import Plugin as TelemetryPlugin
-    from mmrelay.plugins.weather_plugin import Plugin as WeatherPlugin
-
-    # Initial list of core plugins
-    core_plugins = [
-        HealthPlugin(),
-        MapPlugin(),
-        MeshRelayPlugin(),
-        PingPlugin(),
-        TelemetryPlugin(),
-        WeatherPlugin(),
-        HelpPlugin(),
-        NodesPlugin(),
-        DropPlugin(),
-        DebugPlugin(),
-    ]
-
-    plugins = core_plugins.copy()
-
-    # Process and load custom plugins
-    custom_plugins_config = config.get("custom-plugins", {})
-    custom_plugin_dirs = get_custom_plugin_dirs()
-
-    active_custom_plugins = [
-        plugin_name
-        for plugin_name, plugin_info in custom_plugins_config.items()
-        if plugin_info.get("active", False)
-    ]
-
-    if active_custom_plugins:
-        logger.debug(
-            f"Loading active custom plugins: {', '.join(active_custom_plugins)}"
-        )
-
-    # Only load custom plugins that are explicitly enabled
-    for plugin_name in active_custom_plugins:
-        plugin_found = False
-
-        # Try each directory in order
-        for custom_dir in custom_plugin_dirs:
-            plugin_path = os.path.join(custom_dir, plugin_name)
-            if os.path.exists(plugin_path):
-                logger.debug(f"Loading custom plugin from: {plugin_path}")
-                plugins.extend(
-                    load_plugins_from_directory(plugin_path, recursive=False)
-                )
-                plugin_found = True
-                break
-
-        if not plugin_found:
-            logger.warning(
-                f"Custom plugin '{plugin_name}' not found in any of the plugin directories"
-            )
-
-    # Process and download community plugins
-    community_plugins_config = config.get("community-plugins", {})
-    community_plugin_dirs = get_community_plugin_dirs()
-
-    # Get the first directory for cloning (prefer user directory)
-    community_plugins_dir = community_plugin_dirs[
-        -1
-    ]  # Use the user directory for new clones
-
-    # Create community plugins directory if needed
-    active_community_plugins = [
-        plugin_name
-        for plugin_name, plugin_info in community_plugins_config.items()
-        if plugin_info.get("active", False)
-    ]
-
-    if active_community_plugins:
-        # Ensure all community plugin directories exist
-        for dir_path in community_plugin_dirs:
-            os.makedirs(dir_path, exist_ok=True)
-
-        logger.debug(
-            f"Loading active community plugins: {', '.join(active_community_plugins)}"
-        )
-
-    # Only process community plugins if config section exists and is a dictionary
-    if isinstance(community_plugins_config, dict):
-        for plugin_name, plugin_info in community_plugins_config.items():
-            if not plugin_info.get("active", False):
-                logger.debug(
-                    f"Skipping community plugin {plugin_name} - not active in config"
-                )
-                continue
-
-            repo_url = plugin_info.get("repository")
-            tag = plugin_info.get("tag", "master")
-            if repo_url:
-                # Clone to the user directory by default
-                clone_or_update_repo(repo_url, tag, community_plugins_dir)
-            else:
-                logger.error("Repository URL not specified for a community plugin")
-                logger.error("Please specify the repository URL in config.yaml")
-                sys.exit(1)
-
-    # Only load community plugins that are explicitly enabled
-    for plugin_name in active_community_plugins:
-        plugin_info = community_plugins_config[plugin_name]
-        repo_url = plugin_info.get("repository")
-        if repo_url:
-            # Extract repository name from URL
-            repo_name = os.path.splitext(os.path.basename(repo_url.rstrip("/")))[0]
-
-            # Try each directory in order
-            plugin_found = False
-            for dir_path in community_plugin_dirs:
-                plugin_path = os.path.join(dir_path, repo_name)
-                if os.path.exists(plugin_path):
-                    logger.debug(f"Loading community plugin from: {plugin_path}")
-                    plugins.extend(
-                        load_plugins_from_directory(plugin_path, recursive=True)
-                    )
-                    plugin_found = True
-                    break
-
-            if not plugin_found:
-                logger.warning(
-                    f"Community plugin '{repo_name}' not found in any of the plugin directories"
-                )
-        else:
-            logger.error(
-                f"Repository URL not specified for community plugin: {plugin_name}"
-            )
-
-    # Filter and sort active plugins by priority
-    active_plugins = []
-    for plugin in plugins:
-        plugin_name = getattr(plugin, "plugin_name", plugin.__class__.__name__)
-
-        # Determine if the plugin is active based on the configuration
-        if plugin in core_plugins:
-            # Core plugins: default to inactive unless specified otherwise
-            plugin_config = config.get("plugins", {}).get(plugin_name, {})
-            is_active = plugin_config.get("active", False)
-        else:
-            # Custom and community plugins: default to inactive unless specified
-            if plugin_name in config.get("custom-plugins", {}):
-                plugin_config = config.get("custom-plugins", {}).get(plugin_name, {})
-            elif plugin_name in community_plugins_config:
-                plugin_config = community_plugins_config.get(plugin_name, {})
-            else:
-                plugin_config = {}
-
-            is_active = plugin_config.get("active", False)
-
-        if is_active:
-            plugin.priority = plugin_config.get(
-                "priority", getattr(plugin, "priority", 100)
-            )
-            active_plugins.append(plugin)
-            try:
-                plugin.start()
-            except Exception as e:
-                logger.error(f"Error starting plugin {plugin_name}: {e}")
-
-    sorted_active_plugins = sorted(active_plugins, key=lambda plugin: plugin.priority)
-
-    # Log all loaded plugins
-    if sorted_active_plugins:
-        plugin_names = [
-            getattr(plugin, "plugin_name", plugin.__class__.__name__)
-            for plugin in sorted_active_plugins
-        ]
-        logger.info(f"Plugins loaded: {', '.join(plugin_names)}")
-    else:
-        logger.info("Plugins loaded: none")
-
-    plugins_loaded = True  # Set the flag to indicate that plugins have been load