mmrelay 1.0.3__py3-none-any.whl → 1.0.4__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

@@ -60,31 +60,332 @@ 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:
-            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 == 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}"
             )
-            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", 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}"
             )
-            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):
@@ -255,11 +556,16 @@ def load_plugins(passed_config=None):
             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)
+                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")
-                sys.exit(1)
+                continue
 
     # Only load community plugins that are explicitly enabled
     for plugin_name in active_community_plugins:

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.4.dist-info}/METADATA

@@ -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.dist-info → mmrelay-1.0.4.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=na1fso1jaN_APto3LqtXctTciDEOWMyghzAO6TqH4J8,27839
 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.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,,