mmrelay 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

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/plugin_loader.py

@@ -56,50 +56,444 @@ def get_community_plugin_dirs():
     return dirs
 
 
-def clone_or_update_repo(repo_url, tag, plugins_dir):
+def clone_or_update_repo(repo_url, ref, 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 ref is not specified
+    default_branches = ["main", "master"]
+
+    # Get the ref type and value
+    ref_type = ref["type"]  # "tag" or "branch"
+    ref_value = ref["value"]
+
+    # Log what we're trying to do
+    logger.info(f"Using {ref_type} '{ref_value}' for repository {repo_name}")
+
+    # If it's a branch and one of the default branches, we'll handle it specially
+    is_default_branch = ref_type == "branch" and ref_value in default_branches
+
     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}")
+            # 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 == ref_value:
+                        # We're on the right branch, just pull
+                        try:
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "pull", "origin", ref_value]
+                            )
+                            logger.info(
+                                f"Updated repository {repo_name} branch {ref_value}"
+                            )
+                            return True
+                        except subprocess.CalledProcessError as e:
+                            logger.warning(f"Error pulling branch {ref_value}: {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", ref_value]
+                        )
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "pull", "origin", ref_value]
+                        )
+                        if ref_type == "branch":
+                            logger.info(f"Switched to and updated branch {ref_value}")
+                        else:
+                            logger.info(f"Switched to and updated tag {ref_value}")
+                        return True
+                except subprocess.CalledProcessError:
+                    # If we can't checkout the specified branch, try the other default branch
+                    other_default = "main" if ref_value == "master" else "master"
+                    try:
+                        logger.warning(
+                            f"Branch {ref_value} 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 {ref_value}"
+                        )
+                        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", ref_value],
+                            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 {ref_value}"
+                        )
+                        return True
+
+                    # Otherwise, try to checkout the tag
+                    subprocess.check_call(
+                        ["git", "-C", repo_path, "checkout", ref_value]
+                    )
+                    if ref_type == "branch":
+                        logger.info(
+                            f"Updated repository {repo_name} to branch {ref_value}"
+                        )
+                    else:
+                        logger.info(
+                            f"Updated repository {repo_name} to tag {ref_value}"
+                        )
+                    return True
+                except subprocess.CalledProcessError:
+                    # If tag checkout fails, try to fetch it specifically
+                    logger.warning(
+                        f"Tag {ref_value} 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", ref_value]
+                            )
+                        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/{ref_value}",
+                                ]
+                            )
+                        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/{ref_value}:refs/tags/{ref_value}",
+                                ]
+                            )
+
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "checkout", ref_value]
+                        )
+                        if ref_type == "branch":
+                            logger.info(
+                                f"Successfully fetched and checked out branch {ref_value}"
+                            )
+                        else:
+                            logger.info(
+                                f"Successfully fetched and checked out tag {ref_value}"
+                            )
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails too, try as a branch
+                        logger.warning(
+                            f"Could not fetch tag {ref_value}, trying as a branch"
+                        )
+                        try:
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "fetch", "origin", ref_value]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "checkout", ref_value]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "pull", "origin", ref_value]
+                            )
+                            logger.info(
+                                f"Updated repository {repo_name} to branch {ref_value}"
+                            )
+                            return True
+                        except subprocess.CalledProcessError:
+                            # If all else fails, just use a default branch
+                            logger.warning(
+                                f"Could not checkout {ref_value} 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 {ref_value}"
+                                    )
+                                    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}"
             )
-            sys.exit(1)
+            return False
     else:
+        # Repository doesn't exist yet, clone it
         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}")
+
+            # 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", ref_value, repo_url],
+                        cwd=plugins_dir,
+                    )
+                    if ref_type == "branch":
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} at branch {ref_value}"
+                        )
+                    else:
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} at tag {ref_value}"
+                        )
+                    return True
+                except subprocess.CalledProcessError:
+                    # If that fails, try the other default branch
+                    other_default = "main" if ref_value == "master" else "master"
+                    try:
+                        logger.warning(
+                            f"Could not clone with branch {ref_value}, 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", ref_value, repo_url],
+                        cwd=plugins_dir,
+                    )
+                    if ref_type == "branch":
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} at branch {ref_value}"
+                        )
+                    else:
+                        logger.info(
+                            f"Cloned repository {repo_name} from {repo_url} at tag {ref_value}"
+                        )
+                    return True
+                except subprocess.CalledProcessError:
+                    # If that fails, clone without specifying a tag
+                    logger.warning(
+                        f"Could not clone with tag {ref_value}, 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/{ref_value}",
+                                ]
+                            )
+                        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/{ref_value}:refs/tags/{ref_value}",
+                                ]
+                            )
+
+                        # Now checkout the tag
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "checkout", ref_value]
+                        )
+                        if ref_type == "branch":
+                            logger.info(
+                                f"Cloned repository {repo_name} and checked out branch {ref_value}"
+                            )
+                        else:
+                            logger.info(
+                                f"Cloned repository {repo_name} and checked out tag {ref_value}"
+                            )
+                        return True
+                    except subprocess.CalledProcessError:
+                        # If that fails, try as a branch
+                        try:
+                            logger.warning(
+                                f"Could not checkout {ref_value} as a tag, trying as a branch"
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "fetch", "origin", ref_value]
+                            )
+                            subprocess.check_call(
+                                ["git", "-C", repo_path, "checkout", ref_value]
+                            )
+                            logger.info(
+                                f"Cloned repository {repo_name} and checked out branch {ref_value}"
+                            )
+                            return True
+                        except subprocess.CalledProcessError:
+                            logger.warning(
+                                f"Could not checkout {ref_value}, 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}"
             )
-            sys.exit(1)
+            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}")
+            # Check if we're running in a pipx environment
+            in_pipx = "PIPX_HOME" in os.environ or "PIPX_LOCAL_VENVS" in os.environ
+
+            # Read requirements from file
+            with open(requirements_path, "r") as f:
+                requirements = [
+                    line.strip()
+                    for line in f
+                    if line.strip() and not line.startswith("#")
+                ]
+
+            if requirements:
+                if in_pipx:
+                    # Use pipx inject for each requirement
+                    logger.info(
+                        f"Installing requirements for plugin {repo_name} with pipx inject"
+                    )
+                    for req in requirements:
+                        logger.info(f"Installing {req}")
+                        subprocess.check_call(["pipx", "inject", "mmrelay", req])
+                else:
+                    # Use pip to install the requirements.txt
+                    logger.info(
+                        f"Installing requirements for plugin {repo_name} with pip"
+                    )
+                    subprocess.check_call(
+                        [
+                            sys.executable,
+                            "-m",
+                            "pip",
+                            "install",
+                            "-r",
+                            requirements_path,
+                        ]
+                    )
+                logger.info(
+                    f"Successfully 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)
+            # Don't exit, just continue with a warning
+            logger.warning(
+                f"Plugin {repo_name} may not work correctly without its dependencies"
+            )
 
 
 def load_plugins_from_directory(directory, recursive=False):
@@ -117,14 +511,101 @@ def load_plugins_from_directory(directory, recursive=False):
                         module_name, plugin_path
                     )
                     plugin_module = importlib.util.module_from_spec(spec)
+
+                    # Create a compatibility layer for plugins
+                    # This allows plugins to import from 'plugins' or 'mmrelay.plugins'
+                    if "mmrelay.plugins" not in sys.modules:
+                        import mmrelay.plugins
+
+                        sys.modules["mmrelay.plugins"] = mmrelay.plugins
+
+                    # For backward compatibility with older plugins
+                    if "plugins" not in sys.modules:
+                        import mmrelay.plugins
+
+                        sys.modules["plugins"] = mmrelay.plugins
+
                     try:
+                        # Add the plugin's directory to sys.path temporarily
+                        plugin_dir = os.path.dirname(plugin_path)
+                        sys.path.insert(0, plugin_dir)
+
+                        # Execute the module
                         spec.loader.exec_module(plugin_module)
+
+                        # Remove the plugin directory from sys.path
+                        if plugin_dir in sys.path:
+                            sys.path.remove(plugin_dir)
+
                         if hasattr(plugin_module, "Plugin"):
                             plugins.append(plugin_module.Plugin())
                         else:
                             logger.warning(
                                 f"{plugin_path} does not define a Plugin class."
                             )
+                    except ModuleNotFoundError as e:
+                        missing_module = str(e).split()[-1].strip("'")
+                        logger.warning(
+                            f"Missing dependency for plugin {plugin_path}: {missing_module}"
+                        )
+
+                        # Try to automatically install the missing dependency
+                        try:
+                            # Check if we're running in a pipx environment
+                            in_pipx = (
+                                "PIPX_HOME" in os.environ
+                                or "PIPX_LOCAL_VENVS" in os.environ
+                            )
+
+                            if in_pipx:
+                                logger.info(
+                                    f"Attempting to install missing dependency with pipx inject: {missing_module}"
+                                )
+                                subprocess.check_call(
+                                    ["pipx", "inject", "mmrelay", missing_module]
+                                )
+                            else:
+                                logger.info(
+                                    f"Attempting to install missing dependency with pip: {missing_module}"
+                                )
+                                subprocess.check_call(
+                                    [
+                                        sys.executable,
+                                        "-m",
+                                        "pip",
+                                        "install",
+                                        missing_module,
+                                    ]
+                                )
+
+                            logger.info(
+                                f"Successfully installed {missing_module}, retrying plugin load"
+                            )
+
+                            # Try to load the module again
+                            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 subprocess.CalledProcessError:
+                            logger.error(
+                                f"Failed to automatically install {missing_module}"
+                            )
+                            logger.error("Please install it manually:")
+                            logger.error(
+                                f"pipx inject mmrelay {missing_module}  # if using pipx"
+                            )
+                            logger.error(
+                                f"pip install {missing_module}  # if using pip"
+                            )
+                            logger.error(
+                                f"Plugin directory: {os.path.dirname(plugin_path)}"
+                            )
                     except Exception as e:
                         logger.error(f"Error loading plugin {plugin_path}: {e}")
             if not recursive:
@@ -223,7 +704,7 @@ def load_plugins(passed_config=None):
 
     # Get the first directory for cloning (prefer user directory)
     community_plugins_dir = community_plugin_dirs[
-        -1
+        0
     ]  # Use the user directory for new clones
 
     # Create community plugins directory if needed
@@ -252,14 +733,37 @@ def load_plugins(passed_config=None):
                 continue
 
             repo_url = plugin_info.get("repository")
-            tag = plugin_info.get("tag", "master")
+
+            # Support both tag and branch parameters
+            tag = plugin_info.get("tag")
+            branch = plugin_info.get("branch")
+
+            # Determine what to use (tag, branch, or default)
+            if tag and branch:
+                logger.warning(
+                    f"Both tag and branch specified for plugin {plugin_name}, using tag"
+                )
+                ref = {"type": "tag", "value": tag}
+            elif tag:
+                ref = {"type": "tag", "value": tag}
+            elif branch:
+                ref = {"type": "branch", "value": branch}
+            else:
+                # Default to main branch if neither is specified
+                ref = {"type": "branch", "value": "main"}
+
             if repo_url:
                 # Clone to the user directory by default
-                clone_or_update_repo(repo_url, tag, community_plugins_dir)
+                success = clone_or_update_repo(repo_url, ref, 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")
-                sys.exit(1)
+                continue
 
     # Only load community plugins that are explicitly enabled
     for plugin_name in active_community_plugins:
@@ -274,7 +778,7 @@ def load_plugins(passed_config=None):
             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}")
+                    logger.info(f"Loading community plugin from: {plugin_path}")
                     plugins.extend(
                         load_plugins_from_directory(plugin_path, recursive=True)
                     )

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.dist-info → mmrelay-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0.3
+Version: 1.0.5
 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.dist-info → mmrelay-1.0.5.dist-info}/RECORD

@@ -1,16 +1,16 @@
 mmrelay/__init__.py,sha256=8fghAZAeSUb8uIaiit0FGNUWI0ZsBR__QbXNwqNbGtw,588
 mmrelay/cli.py,sha256=yBYOkCwGYDJ2gRKPoPltxB_PydX1CPNUerVJHcNuHTo,12355
-mmrelay/config.py,sha256=OIDxQStuVHyWxsDfnKqt0rr26ETEoZPqHVXReEH3IG8,7006
+mmrelay/config.py,sha256=5VZag8iSc5yLQgvwI76bbpizbtqag74cHnfXCrWHNyA,7910
 mmrelay/config_checker.py,sha256=UnoHVTXzfdTfFkbmXv9r_Si76v-sxXLb5FOaQSOM45E,4909
 mmrelay/db_utils.py,sha256=DP2YuKBZtV771wo9X-Z7Ww5txfaIR0inWh1K_oVZ7cA,11430
 mmrelay/log_utils.py,sha256=FXhaq4WSDHwlqiG3k1BbSxiOl5be4P4Kyr1gsIThOBw,4572
 mmrelay/main.py,sha256=acgBF-DnL0Rs8MmYAfbNHZ9xjqM3Qc0_oKtATN4iOEE,11085
 mmrelay/matrix_utils.py,sha256=GkIVj2bbPHtx1emFMwhEhc1SWHcv4UvkuyZYdb-Wnwo,30511
 mmrelay/meshtastic_utils.py,sha256=Pd0j7mz008ncBDIjRGyHOIb0U3vKq06uXWoJP-csHcQ,23381
-mmrelay/plugin_loader.py,sha256=QfSXu4nxxBL_pGttLJGzGki8kRtWbFdtSoD_Qnx2iqU,12758
+mmrelay/plugin_loader.py,sha256=Gg8E_TKqndMQHiVJwtmlIC-jCgcty-5EsX_5JJ6Onvo,36590
 mmrelay/setup_utils.py,sha256=GHttNLoqPwOpjSly0osaCnotPxCq0hfyopsZ2qq313A,14091
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
-mmrelay/plugins/base_plugin.py,sha256=7tBIARWp9Qc4iAEMcsKiUJh1cbqXHcXAk4dlu1b8SBg,7524
+mmrelay/plugins/base_plugin.py,sha256=hv21tSEYG-AB36aLAFdW9DDKm0NOTRNPpGIO5F3i1ts,8633
 mmrelay/plugins/debug_plugin.py,sha256=Jziht9Nj_bRO6Rmy7TjfBXaYo5eM3XsenbWFxPpyUs4,443
 mmrelay/plugins/drop_plugin.py,sha256=ACchX6GfEldqTyvsZVg-5jwbe2-CjENQVVZFnw8SaEM,4618
 mmrelay/plugins/health_plugin.py,sha256=svV_GfpAVL0QhiVzi3PVZ1mNpsOL1NHSmkRF-Mn_ExE,2250
@@ -21,9 +21,9 @@ mmrelay/plugins/nodes_plugin.py,sha256=RDabzyG5hKG5aYWecsRUcLSjMCCv6Pngmq2Qpld1A
 mmrelay/plugins/ping_plugin.py,sha256=RTRdgDQUSO33lreDTmWsTlI0L1C3FJrXE0KYqfEWYO0,4017
 mmrelay/plugins/telemetry_plugin.py,sha256=8SxWv4BLXMUTbiVaD3MjlMMdQyS7S_1OfLlVNAUMSO0,6306
 mmrelay/plugins/weather_plugin.py,sha256=yoKA_HdFqFEhgYdXqLhvXatLphCyLJFuGUKCR7fILv0,8546
-mmrelay-1.0.3.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.0.3.dist-info/METADATA,sha256=u2oPLnidTXciajKZyZuk28FaNTYL-Z_JygobFBJwm3I,6953
-mmrelay-1.0.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-mmrelay-1.0.3.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.0.3.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.0.3.dist-info/RECORD,,
+mmrelay-1.0.5.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.0.5.dist-info/METADATA,sha256=IrC7LB07B_2BqV3oTs-Epo3veb7XYlXE8H1aeD1WMQw,6953
+mmrelay-1.0.5.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+mmrelay-1.0.5.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.0.5.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.0.5.dist-info/RECORD,,