mmrelay 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

mmrelay/plugin_loader.py

@@ -56,16 +56,23 @@ 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 tag is not specified
+    # Default branch names to try if ref 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
+    # 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:
@@ -85,32 +92,39 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                         universal_newlines=True,
                     ).strip()
 
-                    if current_branch == tag:
+                    if current_branch == ref_value:
                         # We're on the right branch, just pull
                         try:
                             subprocess.check_call(
-                                ["git", "-C", repo_path, "pull", "origin", tag]
+                                ["git", "-C", repo_path, "pull", "origin", ref_value]
+                            )
+                            logger.info(
+                                f"Updated repository {repo_name} branch {ref_value}"
                             )
-                            logger.info(f"Updated repository {repo_name} branch {tag}")
                             return True
                         except subprocess.CalledProcessError as e:
-                            logger.warning(f"Error pulling branch {tag}: {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", tag])
                         subprocess.check_call(
-                            ["git", "-C", repo_path, "pull", "origin", tag]
+                            ["git", "-C", repo_path, "checkout", ref_value]
+                        )
+                        subprocess.check_call(
+                            ["git", "-C", repo_path, "pull", "origin", ref_value]
                         )
-                        logger.info(f"Switched to and updated branch {tag}")
+                        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 tag == "master" else "master"
+                    other_default = "main" if ref_value == "master" else "master"
                     try:
                         logger.warning(
-                            f"Branch {tag} not found, trying {other_default}"
+                            f"Branch {ref_value} not found, trying {other_default}"
                         )
                         subprocess.check_call(
                             ["git", "-C", repo_path, "checkout", other_default]
@@ -118,7 +132,9 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                         subprocess.check_call(
                             ["git", "-C", repo_path, "pull", "origin", other_default]
                         )
-                        logger.info(f"Using {other_default} branch instead of {tag}")
+                        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
@@ -140,7 +156,7 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                     tag_commit = None
                     try:
                         tag_commit = subprocess.check_output(
-                            ["git", "-C", repo_path, "rev-parse", tag],
+                            ["git", "-C", repo_path, "rev-parse", ref_value],
                             universal_newlines=True,
                         ).strip()
                     except subprocess.CalledProcessError:
@@ -149,24 +165,35 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
 
                     # 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}")
+                        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", tag])
-                    logger.info(f"Updated repository {repo_name} to tag {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 {tag} not found locally, trying to fetch it specifically"
+                        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", tag]
+                                ["git", "-C", repo_path, "tag", "-d", ref_value]
                             )
                         except subprocess.CalledProcessError:
                             # Tag doesn't exist locally, which is fine
@@ -182,7 +209,7 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                                     repo_path,
                                     "fetch",
                                     "origin",
-                                    f"refs/tags/{tag}",
+                                    f"refs/tags/{ref_value}",
                                 ]
                             )
                         except subprocess.CalledProcessError:
@@ -194,34 +221,45 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                                     repo_path,
                                     "fetch",
                                     "origin",
-                                    f"refs/tags/{tag}:refs/tags/{tag}",
+                                    f"refs/tags/{ref_value}:refs/tags/{ref_value}",
                                 ]
                             )
 
-                        subprocess.check_call(["git", "-C", repo_path, "checkout", tag])
-                        logger.info(f"Successfully fetched and checked out tag {tag}")
+                        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 {tag}, trying 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", tag]
+                                ["git", "-C", repo_path, "fetch", "origin", ref_value]
                             )
                             subprocess.check_call(
-                                ["git", "-C", repo_path, "checkout", tag]
+                                ["git", "-C", repo_path, "checkout", ref_value]
                             )
                             subprocess.check_call(
-                                ["git", "-C", repo_path, "pull", "origin", tag]
+                                ["git", "-C", repo_path, "pull", "origin", ref_value]
                             )
                             logger.info(
-                                f"Updated repository {repo_name} to branch {tag}"
+                                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 {tag} as tag or branch, trying default branches"
+                                f"Could not checkout {ref_value} as tag or branch, trying default branches"
                             )
                             for default_branch in default_branches:
                                 try:
@@ -245,7 +283,7 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                                         ]
                                     )
                                     logger.info(
-                                        f"Using {default_branch} instead of {tag}"
+                                        f"Using {default_branch} instead of {ref_value}"
                                     )
                                     return True
                                 except subprocess.CalledProcessError:
@@ -272,18 +310,24 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                 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}"
+                        ["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 tag == "master" else "master"
+                    other_default = "main" if ref_value == "master" else "master"
                     try:
                         logger.warning(
-                            f"Could not clone with branch {tag}, trying {other_default}"
+                            f"Could not clone with branch {ref_value}, trying {other_default}"
                         )
                         subprocess.check_call(
                             ["git", "clone", "--branch", other_default, repo_url],
@@ -310,16 +354,22 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                 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}"
+                        ["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 {tag}, cloning default branch"
+                        f"Could not clone with tag {ref_value}, cloning default branch"
                     )
                     subprocess.check_call(["git", "clone", repo_url], cwd=plugins_dir)
 
@@ -334,7 +384,7 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                                     repo_path,
                                     "fetch",
                                     "origin",
-                                    f"refs/tags/{tag}",
+                                    f"refs/tags/{ref_value}",
                                 ]
                             )
                         except subprocess.CalledProcessError:
@@ -346,35 +396,42 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
                                     repo_path,
                                     "fetch",
                                     "origin",
-                                    f"refs/tags/{tag}:refs/tags/{tag}",
+                                    f"refs/tags/{ref_value}:refs/tags/{ref_value}",
                                 ]
                             )
 
                         # 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}"
+                        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 {tag} as a tag, trying as a branch"
+                                f"Could not checkout {ref_value} as a tag, trying as a branch"
                             )
                             subprocess.check_call(
-                                ["git", "-C", repo_path, "fetch", "origin", tag]
+                                ["git", "-C", repo_path, "fetch", "origin", ref_value]
                             )
                             subprocess.check_call(
-                                ["git", "-C", repo_path, "checkout", tag]
+                                ["git", "-C", repo_path, "checkout", ref_value]
                             )
                             logger.info(
-                                f"Cloned repository {repo_name} and checked out branch {tag}"
+                                f"Cloned repository {repo_name} and checked out branch {ref_value}"
                             )
                             return True
                         except subprocess.CalledProcessError:
                             logger.warning(
-                                f"Could not checkout {tag}, using default branch"
+                                f"Could not checkout {ref_value}, using default branch"
                             )
                             logger.info(
                                 f"Cloned repository {repo_name} from {repo_url} (default branch)"
@@ -390,17 +447,53 @@ def clone_or_update_repo(repo_url, tag, plugins_dir):
     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):
@@ -418,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:
@@ -524,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
@@ -553,10 +733,28 @@ 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
-                success = 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"
@@ -580,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/setup_utils.py

@@ -91,42 +91,82 @@ def get_template_service_path():
         str: The path to the template service file, or None if not found.
     """
     # Try to find the service template file
-    # First, check in the package directory (where it should be after installation)
     package_dir = os.path.dirname(__file__)
-    template_path = os.path.join(
-        os.path.dirname(os.path.dirname(package_dir)), "tools", "mmrelay.service"
-    )
-
-    # If not found, try the repository root (for development)
-    if not os.path.exists(template_path):
-        repo_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        template_path = os.path.join(repo_root, "tools", "mmrelay.service")
-
-    # If still not found, try the current directory (fallback)
-    if not os.path.exists(template_path):
-        template_path = os.path.join(os.getcwd(), "tools", "mmrelay.service")
 
-    if not os.path.exists(template_path):
-        return None
-
-    return template_path
+    # Try to find the service template file in various locations
+    template_paths = [
+        # Check in the package directory (where it should be after installation)
+        os.path.join(package_dir, "mmrelay.service"),
+        # Check in a tools subdirectory of the package
+        os.path.join(package_dir, "tools", "mmrelay.service"),
+        # Check in the data files location (where it should be after installation)
+        os.path.join(sys.prefix, "share", "mmrelay", "mmrelay.service"),
+        os.path.join(sys.prefix, "share", "mmrelay", "tools", "mmrelay.service"),
+        # Check in the user site-packages location
+        os.path.join(os.path.expanduser("~"), ".local", "share", "mmrelay", "mmrelay.service"),
+        os.path.join(os.path.expanduser("~"), ".local", "share", "mmrelay", "tools", "mmrelay.service"),
+        # Check one level up from the package directory
+        os.path.join(os.path.dirname(package_dir), "tools", "mmrelay.service"),
+        # Check two levels up from the package directory (for development)
+        os.path.join(os.path.dirname(os.path.dirname(package_dir)), "tools", "mmrelay.service"),
+        # Check in the repository root (for development)
+        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "tools", "mmrelay.service"),
+        # Check in the current directory (fallback)
+        os.path.join(os.getcwd(), "tools", "mmrelay.service")
+    ]
+
+    # Try each path until we find one that exists
+    for path in template_paths:
+        if os.path.exists(path):
+            return path
+
+    # If we get here, we couldn't find the template
+    # Debug output to help diagnose issues
+    print("Debug: Could not find mmrelay.service in any of these locations:")
+    for path in template_paths:
+        print(f"  - {path}")
+
+    # If we get here, we couldn't find the template
+    return None
 
 
 def get_template_service_content():
     """Get the content of the template service file.
 
     Returns:
-        str: The content of the template service file, or None if not found.
+        str: The content of the template service file, or a default template if not found.
     """
     template_path = get_template_service_path()
-    if not template_path:
-        return None
-
-    # Read the template
-    with open(template_path, "r") as f:
-        service_template = f.read()
-
-    return service_template
+    if template_path:
+        # Read the template from file
+        try:
+            with open(template_path, "r") as f:
+                service_template = f.read()
+            return service_template
+        except Exception as e:
+            print(f"Error reading service template file: {e}")
+
+    # If we couldn't find or read the template file, use a default template
+    print("Using default service template")
+    return """[Unit]
+Description=A Meshtastic <=> Matrix Relay
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=idle
+# The mmrelay binary can be installed via pipx or pip
+ExecStart=%h/.local/bin/mmrelay --config %h/.mmrelay/config.yaml --logfile %h/.mmrelay/logs/mmrelay.log
+WorkingDirectory=%h/.mmrelay
+Restart=on-failure
+RestartSec=10
+Environment=PYTHONUNBUFFERED=1
+# Ensure both pipx and pip environments are properly loaded
+Environment=PATH=%h/.local/bin:%h/.local/pipx/venvs/mmrelay/bin:/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
+"""
 
 
 def is_service_enabled():

{mmrelay-1.0.4.dist-info → mmrelay-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0.4
+Version: 1.0.6
 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
@@ -25,6 +25,7 @@ Requires-Dist: schedule==1.2.2
 Requires-Dist: platformdirs==4.3.7
 Requires-Dist: py-staticmaps>=0.4.0
 Requires-Dist: rich==14.0.0
+Requires-Dist: setuptools==80.3.1
 Dynamic: license-file
 
 # M<>M Relay

{mmrelay-1.0.4.dist-info → mmrelay-1.0.6.dist-info}/RECORD

@@ -7,8 +7,8 @@ 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=na1fso1jaN_APto3LqtXctTciDEOWMyghzAO6TqH4J8,27839
-mmrelay/setup_utils.py,sha256=GHttNLoqPwOpjSly0osaCnotPxCq0hfyopsZ2qq313A,14091
+mmrelay/plugin_loader.py,sha256=Gg8E_TKqndMQHiVJwtmlIC-jCgcty-5EsX_5JJ6Onvo,36590
+mmrelay/setup_utils.py,sha256=UZLX944GyiUQPUGNGNDwLocgShA8SzOJtvfntEu821A,16060
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
 mmrelay/plugins/base_plugin.py,sha256=hv21tSEYG-AB36aLAFdW9DDKm0NOTRNPpGIO5F3i1ts,8633
 mmrelay/plugins/debug_plugin.py,sha256=Jziht9Nj_bRO6Rmy7TjfBXaYo5eM3XsenbWFxPpyUs4,443
@@ -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.4.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.0.4.dist-info/METADATA,sha256=fZZsYxyfKn-KANTa3l4CIB7aSwkbg7mKAxRB3UL76FA,6953
-mmrelay-1.0.4.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-mmrelay-1.0.4.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.0.4.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.0.4.dist-info/RECORD,,
+mmrelay-1.0.6.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.0.6.dist-info/METADATA,sha256=V_JcF794O_pNB39Bm3K1TxVpB3C5f1lWYGQu4s3j3Dc,6987
+mmrelay-1.0.6.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+mmrelay-1.0.6.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.0.6.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.0.6.dist-info/RECORD,,

{mmrelay-1.0.4.dist-info → mmrelay-1.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any