mmrelay 1.0__py3-none-any.whl

mmrelay/__init__.py

@@ -0,0 +1,9 @@
+"""
+Meshtastic Matrix Relay - Bridge between Meshtastic mesh networks and Matrix chat rooms.
+"""
+
+import os
+
+# Get version from environment variable if available (set by GitHub Actions)
+# Otherwise, use a default version
+__version__ = os.environ.get("GITHUB_REF_NAME", "1.0.0")

mmrelay/cli.py

@@ -0,0 +1,384 @@
+"""
+Command-line interface handling for the Meshtastic Matrix Relay.
+"""
+
+import argparse
+import os
+import sys
+
+import yaml
+from yaml.loader import SafeLoader
+
+# Import version from package
+from mmrelay import __version__
+
+
+def parse_arguments():
+    """
+    Parse command-line arguments.
+
+    Returns:
+        argparse.Namespace: The parsed command-line arguments
+    """
+    parser = argparse.ArgumentParser(
+        description="Meshtastic Matrix Relay - Bridge between Meshtastic and Matrix"
+    )
+    parser.add_argument("--config", help="Path to config file", default=None)
+    parser.add_argument(
+        "--data-dir",
+        help="Base directory for all data (logs, database, plugins)",
+        default=None,
+    )
+    parser.add_argument(
+        "--log-level",
+        choices=["error", "warning", "info", "debug"],
+        help="Set logging level",
+        default=None,
+    )
+    parser.add_argument(
+        "--logfile",
+        help="Path to log file (can be overridden by --data-dir)",
+        default=None,
+    )
+    parser.add_argument("--version", action="store_true", help="Show version and exit")
+    parser.add_argument(
+        "--generate-config",
+        action="store_true",
+        help="Generate a sample config.yaml file",
+    )
+    parser.add_argument(
+        "--install-service",
+        action="store_true",
+        help="Install or update the systemd user service",
+    )
+    parser.add_argument(
+        "--check-config",
+        action="store_true",
+        help="Check if the configuration file is valid",
+    )
+
+    # Windows-specific handling for backward compatibility
+    # On Windows, add a positional argument for the config file path
+    if sys.platform == "win32":
+        parser.add_argument(
+            "config_path", nargs="?", help=argparse.SUPPRESS, default=None
+        )
+
+    args = parser.parse_args()
+
+    # If on Windows and a positional config path is provided but --config is not, use the positional one
+    if (
+        sys.platform == "win32"
+        and hasattr(args, "config_path")
+        and args.config_path
+        and not args.config
+    ):
+        args.config = args.config_path
+        # Print a deprecation warning
+        print("Warning: Using positional argument for config file is deprecated.")
+        print(f"Please use --config {args.config_path} instead.")
+        # Remove the positional argument from sys.argv to avoid issues with other argument parsers
+        if args.config_path in sys.argv:
+            sys.argv.remove(args.config_path)
+
+    return args
+
+
+def get_version():
+    """
+    Returns the current version of the application.
+
+    Returns:
+        str: The version string
+    """
+    return __version__
+
+
+def check_config(args=None):
+    """
+    Check if the configuration file is valid.
+
+    Args:
+        args: The parsed command-line arguments
+
+    Returns:
+        bool: True if the configuration is valid, False otherwise.
+    """
+    from mmrelay.config import get_config_paths
+
+    # If args is None, parse them now
+    if args is None:
+        args = parse_arguments()
+
+    config_paths = get_config_paths(args)
+    config_path = None
+
+    # Try each config path in order until we find one that exists
+    for path in config_paths:
+        if os.path.isfile(path):
+            config_path = path
+            print(f"Found configuration file at: {config_path}")
+            try:
+                with open(config_path, "r") as f:
+                    config = yaml.load(f, Loader=SafeLoader)
+
+                # Check if config is empty
+                if not config:
+                    print("Error: Configuration file is empty or invalid")
+                    return False
+
+                # Check matrix section
+                if "matrix" not in config:
+                    print("Error: Missing 'matrix' section in config")
+                    return False
+
+                matrix_section = config["matrix"]
+                required_matrix_fields = ["homeserver", "access_token", "bot_user_id"]
+                missing_matrix_fields = [
+                    field
+                    for field in required_matrix_fields
+                    if field not in matrix_section
+                ]
+
+                if missing_matrix_fields:
+                    print(
+                        f"Error: Missing required fields in 'matrix' section: {', '.join(missing_matrix_fields)}"
+                    )
+                    return False
+
+                # Check matrix_rooms section
+                if "matrix_rooms" not in config or not config["matrix_rooms"]:
+                    print("Error: Missing or empty 'matrix_rooms' section in config")
+                    return False
+
+                if not isinstance(config["matrix_rooms"], list):
+                    print("Error: 'matrix_rooms' must be a list")
+                    return False
+
+                for i, room in enumerate(config["matrix_rooms"]):
+                    if not isinstance(room, dict):
+                        print(
+                            f"Error: Room {i+1} in 'matrix_rooms' must be a dictionary"
+                        )
+                        return False
+
+                    if "id" not in room:
+                        print(
+                            f"Error: Room {i+1} in 'matrix_rooms' is missing the 'id' field"
+                        )
+                        return False
+
+                # Check meshtastic section
+                if "meshtastic" not in config:
+                    print("Error: Missing 'meshtastic' section in config")
+                    return False
+
+                meshtastic_section = config["meshtastic"]
+                if "connection_type" not in meshtastic_section:
+                    print("Error: Missing 'connection_type' in 'meshtastic' section")
+                    return False
+
+                connection_type = meshtastic_section["connection_type"]
+                if connection_type not in ["tcp", "serial", "ble", "network"]:
+                    print(
+                        f"Error: Invalid 'connection_type': {connection_type}. Must be 'tcp', 'serial', or 'ble'"
+                    )
+                    return False
+
+                # Check for deprecated connection_type
+                if connection_type == "network":
+                    print(
+                        "\nWarning: 'network' connection_type is deprecated. Please use 'tcp' instead."
+                    )
+                    print(
+                        "See ANNOUNCEMENT.md for more information about deprecated options.\n"
+                    )
+
+                # Check connection-specific fields
+                if (
+                    connection_type == "serial"
+                    and "serial_port" not in meshtastic_section
+                ):
+                    print("Error: Missing 'serial_port' for 'serial' connection type")
+                    return False
+
+                if (
+                    connection_type in ["tcp", "network"]
+                    and "host" not in meshtastic_section
+                ):
+                    print("Error: Missing 'host' for 'tcp' connection type")
+                    return False
+
+                if connection_type == "ble" and "ble_address" not in meshtastic_section:
+                    print("Error: Missing 'ble_address' for 'ble' connection type")
+                    return False
+
+                # Check for deprecated db section
+                if "db" in config:
+                    print(
+                        "\nWarning: 'db' section is deprecated. Please use 'database' instead."
+                    )
+                    print(
+                        "See ANNOUNCEMENT.md for more information about deprecated options.\n"
+                    )
+
+                print("Configuration file is valid!")
+                return True
+            except yaml.YAMLError as e:
+                print(f"Error parsing YAML in {config_path}: {e}")
+                return False
+            except Exception as e:
+                print(f"Error checking configuration: {e}")
+                return False
+
+    print("Error: No configuration file found in any of the following locations:")
+    for path in config_paths:
+        print(f"  - {path}")
+    print("\nRun 'mmrelay --generate-config' to generate a sample configuration file.")
+    return False
+
+
+def main():
+    """Entry point for CLI commands.
+
+    Returns:
+        int: Exit code (0 for success, non-zero for failure)
+    """
+    args = parse_arguments()
+
+    # Handle --check-config
+    if args.check_config:
+        return 0 if check_config(args) else 1
+
+    # Handle --install-service
+    if args.install_service:
+        from mmrelay.setup_utils import install_service
+
+        return 0 if install_service() else 1
+
+    # Handle --generate-config
+    if args.generate_config:
+        return 0 if generate_sample_config() else 1
+
+    # Handle --version
+    if args.version:
+        print(f"mmrelay {get_version()}")
+        return 0
+
+    # If no command was specified, run the main functionality
+    from mmrelay.main import run_main
+
+    return run_main(args)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())
+
+
+def handle_cli_commands(args):
+    """Handle CLI commands like --generate-config, --install-service, and --check-config.
+
+    Args:
+        args: The parsed command-line arguments
+
+    Returns:
+        bool: True if a command was handled and the program should exit,
+              False if normal execution should continue.
+    """
+    # Handle --version
+    if args.version:
+        print(f"mmrelay {get_version()}")
+        return True
+
+    # Handle --install-service
+    if args.install_service:
+        from mmrelay.setup_utils import install_service
+
+        success = install_service()
+        import sys
+
+        sys.exit(0 if success else 1)
+
+    # Handle --generate-config
+    if args.generate_config:
+        if generate_sample_config():
+            # Exit with success if config was generated
+            return True
+        else:
+            # Exit with error if config generation failed
+            import sys
+
+            sys.exit(1)
+
+    # Handle --check-config
+    if args.check_config:
+        import sys
+
+        sys.exit(0 if check_config() else 1)
+
+    # No commands were handled
+    return False
+
+
+def generate_sample_config():
+    """Generate a sample config.yaml file.
+
+    Returns:
+        bool: True if the config was generated successfully, False otherwise.
+    """
+
+    import shutil
+
+    from mmrelay.config import get_config_paths
+
+    # Get the first config path (highest priority)
+    config_paths = get_config_paths()
+
+    # Check if any config file exists
+    existing_config = None
+    for path in config_paths:
+        if os.path.isfile(path):
+            existing_config = path
+            break
+
+    if existing_config:
+        print(f"A config file already exists at: {existing_config}")
+        print(
+            "Use --config to specify a different location if you want to generate a new one."
+        )
+        return False
+
+    # No config file exists, generate one in the first location
+    target_path = config_paths[0]
+
+    # Ensure the directory exists
+    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+
+    # Try to find the sample config file
+    # First, check in the package directory
+    package_dir = os.path.dirname(__file__)
+    sample_config_path = os.path.join(
+        os.path.dirname(os.path.dirname(package_dir)), "sample_config.yaml"
+    )
+
+    # If not found, try the repository root
+    if not os.path.exists(sample_config_path):
+        repo_root = os.path.dirname(os.path.dirname(__file__))
+        sample_config_path = os.path.join(repo_root, "sample_config.yaml")
+
+    # If still not found, try the current directory
+    if not os.path.exists(sample_config_path):
+        sample_config_path = os.path.join(os.getcwd(), "sample_config.yaml")
+
+    if os.path.exists(sample_config_path):
+        shutil.copy(sample_config_path, target_path)
+        print(f"Generated sample config file at: {target_path}")
+        print(
+            "\nEdit this file with your Matrix and Meshtastic settings before running mmrelay."
+        )
+        return True
+    else:
+        print("Error: Could not find sample_config.yaml")
+        return False

mmrelay/config.py

@@ -0,0 +1,218 @@
+import logging
+import os
+import sys
+
+import platformdirs
+import yaml
+from yaml.loader import SafeLoader
+
+# Define custom base directory for Unix systems
+APP_NAME = "mmrelay"
+APP_AUTHOR = None  # No author directory
+
+
+# Global variable to store the custom data directory
+custom_data_dir = None
+
+
+# Custom base directory for Unix systems
+def get_base_dir():
+    """Returns the base directory for all application files.
+
+    If a custom data directory has been set via --data-dir, that will be used.
+    Otherwise, defaults to ~/.mmrelay on Unix systems or the appropriate
+    platformdirs location on Windows.
+    """
+    # If a custom data directory has been set, use that
+    if custom_data_dir:
+        return custom_data_dir
+
+    if sys.platform in ["linux", "darwin"]:
+        # Use ~/.mmrelay for Linux and Mac
+        return os.path.expanduser(os.path.join("~", "." + APP_NAME))
+    else:
+        # Use platformdirs default for Windows
+        return platformdirs.user_data_dir(APP_NAME, APP_AUTHOR)
+
+
+def get_app_path():
+    """
+    Returns the base directory of the application, whether running from source or as an executable.
+    """
+    if getattr(sys, "frozen", False):
+        # Running in a bundle (PyInstaller)
+        return os.path.dirname(sys.executable)
+    else:
+        # Running in a normal Python environment
+        return os.path.dirname(os.path.abspath(__file__))
+
+
+def get_config_paths(args=None):
+    """
+    Returns a list of possible config file paths in order of priority:
+    1. Command line argument (if provided)
+    2. User config directory (~/.mmrelay/config/ on Linux)
+    3. Current directory (for backward compatibility)
+    4. Application directory (for backward compatibility)
+
+    Args:
+        args: The parsed command-line arguments
+    """
+    paths = []
+
+    # Check command line arguments for config path
+    if args and args.config:
+        paths.append(os.path.abspath(args.config))
+
+    # Check user config directory (preferred location)
+    if sys.platform in ["linux", "darwin"]:
+        # Use ~/.mmrelay/ for Linux and Mac
+        user_config_dir = get_base_dir()
+    else:
+        # Use platformdirs default for Windows
+        user_config_dir = platformdirs.user_config_dir(APP_NAME, APP_AUTHOR)
+
+    os.makedirs(user_config_dir, exist_ok=True)
+    user_config_path = os.path.join(user_config_dir, "config.yaml")
+    paths.append(user_config_path)
+
+    # Check current directory (for backward compatibility)
+    current_dir_config = os.path.join(os.getcwd(), "config.yaml")
+    paths.append(current_dir_config)
+
+    # Check application directory (for backward compatibility)
+    app_dir_config = os.path.join(get_app_path(), "config.yaml")
+    paths.append(app_dir_config)
+
+    return paths
+
+
+def get_data_dir():
+    """
+    Returns the directory for storing application data files.
+    Creates the directory if it doesn't exist.
+    """
+    if sys.platform in ["linux", "darwin"]:
+        # Use ~/.mmrelay/data/ for Linux and Mac
+        data_dir = os.path.join(get_base_dir(), "data")
+    else:
+        # Use platformdirs default for Windows
+        data_dir = platformdirs.user_data_dir(APP_NAME, APP_AUTHOR)
+
+    os.makedirs(data_dir, exist_ok=True)
+    return data_dir
+
+
+def get_log_dir():
+    """
+    Returns the directory for storing log files.
+    Creates the directory if it doesn't exist.
+    """
+    if sys.platform in ["linux", "darwin"]:
+        # Use ~/.mmrelay/logs/ for Linux and Mac
+        log_dir = os.path.join(get_base_dir(), "logs")
+    else:
+        # Use platformdirs default for Windows
+        log_dir = platformdirs.user_log_dir(APP_NAME, APP_AUTHOR)
+
+    os.makedirs(log_dir, exist_ok=True)
+    return log_dir
+
+
+# Set up a basic logger for config
+logger = logging.getLogger("Config")
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setFormatter(
+    logging.Formatter(
+        fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S %z",
+    )
+)
+logger.addHandler(handler)
+
+# Initialize empty config
+relay_config = {}
+config_path = None
+
+
+def set_config(module, passed_config):
+    """
+    Set the configuration for a module.
+
+    Args:
+        module: The module to set the configuration for
+        passed_config: The configuration dictionary to use
+
+    Returns:
+        The updated config
+    """
+    # Set the module's config variable
+    module.config = passed_config
+
+    # Handle module-specific setup based on module name
+    module_name = module.__name__.split(".")[-1]
+
+    if module_name == "matrix_utils":
+        # Set Matrix-specific configuration
+        if hasattr(module, "matrix_homeserver") and "matrix" in passed_config:
+            module.matrix_homeserver = passed_config["matrix"]["homeserver"]
+            module.matrix_rooms = passed_config["matrix_rooms"]
+            module.matrix_access_token = passed_config["matrix"]["access_token"]
+            module.bot_user_id = passed_config["matrix"]["bot_user_id"]
+
+    elif module_name == "meshtastic_utils":
+        # Set Meshtastic-specific configuration
+        if hasattr(module, "matrix_rooms") and "matrix_rooms" in passed_config:
+            module.matrix_rooms = passed_config["matrix_rooms"]
+
+    # If the module still has a setup_config function, call it for backward compatibility
+    if hasattr(module, "setup_config") and callable(module.setup_config):
+        module.setup_config()
+
+    return passed_config
+
+
+def load_config(config_file=None, args=None):
+    """Load the configuration from the specified file or search for it.
+
+    Args:
+        config_file (str, optional): Path to the config file. If None, search for it.
+        args: The parsed command-line arguments
+
+    Returns:
+        dict: The loaded configuration
+    """
+    global relay_config, config_path
+
+    # If a specific config file was provided, use it
+    if config_file and os.path.isfile(config_file):
+        logger.info(f"Loading configuration from: {config_file}")
+        with open(config_file, "r") as f:
+            relay_config = yaml.load(f, Loader=SafeLoader)
+        config_path = config_file
+        return relay_config
+
+    # Otherwise, search for a config file
+    config_paths = get_config_paths(args)
+
+    # Try each config path in order until we find one that exists
+    for path in config_paths:
+        if os.path.isfile(path):
+            config_path = path
+            logger.info(f"Loading configuration from: {config_path}")
+            with open(config_path, "r") as f:
+                relay_config = yaml.load(f, Loader=SafeLoader)
+            logger.info(f"Loaded configuration with keys: {list(relay_config.keys())}")
+            return relay_config
+
+    # No config file found
+    logger.error("Configuration file not found in any of the following locations:")
+    for path in config_paths:
+        logger.error(f"  - {path}")
+    logger.error("Using empty configuration. This will likely cause errors.")
+    logger.error(
+        "Run 'mmrelay --generate-config' to generate a sample configuration file."
+    )
+
+    return relay_config