mmrelay 1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

mmrelay/__init__.py

@@ -2,8 +2,12 @@
 Meshtastic Matrix Relay - Bridge between Meshtastic mesh networks and Matrix chat rooms.
 """
 
+import importlib.metadata
 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")
+# Try to get version from package metadata (setup.cfg)
+try:
+    __version__ = importlib.metadata.version("mmrelay")
+except importlib.metadata.PackageNotFoundError:
+    # If package is not installed, fall back to environment variable or default
+    __version__ = os.environ.get("GITHUB_REF_NAME", "1.0.1")

mmrelay/cli.py

@@ -94,6 +94,13 @@ def get_version():
     return __version__
 
 
+def print_version():
+    """
+    Print the version in a simple format.
+    """
+    print(f"MMRelay v{__version__}")
+
+
 def check_config(args=None):
     """
     Check if the configuration file is valid.
@@ -262,7 +269,7 @@ def main():
 
     # Handle --version
     if args.version:
-        print(f"mmrelay {get_version()}")
+        print_version()
         return 0
 
     # If no command was specified, run the main functionality
@@ -289,7 +296,7 @@ def handle_cli_commands(args):
     """
     # Handle --version
     if args.version:
-        print(f"mmrelay {get_version()}")
+        print_version()
         return True
 
     # Handle --install-service

mmrelay/config.py

@@ -187,7 +187,7 @@ def load_config(config_file=None, args=None):
 
     # 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}")
+        # Store the config path but don't log it yet - will be logged by main.py
         with open(config_file, "r") as f:
             relay_config = yaml.load(f, Loader=SafeLoader)
         config_path = config_file
@@ -200,10 +200,9 @@ def load_config(config_file=None, args=None):
     for path in config_paths:
         if os.path.isfile(path):
             config_path = path
-            logger.info(f"Loading configuration from: {config_path}")
+            # Store the config path but don't log it yet - will be logged by main.py
             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

mmrelay/log_utils.py

@@ -2,44 +2,84 @@ import logging
 import os
 from logging.handlers import RotatingFileHandler
 
+from rich.console import Console
+from rich.logging import RichHandler
+
 from mmrelay.cli import parse_arguments
 from mmrelay.config import get_log_dir
 
+# Initialize Rich console
+console = Console()
+
+# Define custom log level styles - not used directly but kept for reference
+# Rich 14.0.0+ supports level_styles parameter, but we're using an approach
+# that works with older versions too
+LOG_LEVEL_STYLES = {
+    "DEBUG": "dim blue",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "bold red",
+    "CRITICAL": "bold white on red",
+}
+
 # Global config variable that will be set from main.py
 config = None
 
+# Global variable to store the log file path
+log_file_path = None
+
 
 def get_logger(name):
     logger = logging.getLogger(name=name)
 
     # Default to INFO level if config is not available
     log_level = logging.INFO
+    color_enabled = True  # Default to using colors
 
-    # Try to get log level from config
+    # Try to get log level and color settings from config
     global config
-    if config is not None and "logging" in config and "level" in config["logging"]:
-        log_level = getattr(logging, config["logging"]["level"].upper())
+    if config is not None and "logging" in config:
+        if "level" in config["logging"]:
+            log_level = getattr(logging, config["logging"]["level"].upper())
+        # Check if colors should be disabled
+        if "color_enabled" in config["logging"]:
+            color_enabled = config["logging"]["color_enabled"]
 
     logger.setLevel(log_level)
     logger.propagate = False
 
-    # Add stream handler (console logging)
-    stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(
-        logging.Formatter(
-            fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S %z",
+    # Add handler for console logging (with or without colors)
+    if color_enabled:
+        # Use Rich handler with colors
+        console_handler = RichHandler(
+            rich_tracebacks=True,
+            console=console,
+            show_time=True,
+            show_level=True,
+            show_path=False,
+            markup=True,
+            log_time_format="%Y-%m-%d %H:%M:%S",
+            omit_repeated_times=False,
+        )
+        console_handler.setFormatter(logging.Formatter("%(name)s: %(message)s"))
+    else:
+        # Use standard handler without colors
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(
+            logging.Formatter(
+                fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S %z",
+            )
         )
-    )
-    logger.addHandler(stream_handler)
+    logger.addHandler(console_handler)
 
     # Check command line arguments for log file path
     args = parse_arguments()
 
-    # Check if file logging is enabled
+    # Check if file logging is enabled (default to True for better user experience)
     if (
         config is not None
-        and config.get("logging", {}).get("log_to_file", False)
+        and config.get("logging", {}).get("log_to_file", True)
         or args.logfile
     ):
         # Priority: 1. Command line arg, 2. Config file, 3. Default location (~/.mmrelay/logs)
@@ -64,21 +104,10 @@ def get_logger(name):
         if log_dir:  # Ensure non-empty directory paths exist
             os.makedirs(log_dir, exist_ok=True)
 
-        # Log which file we're using (only for the first logger)
+        # Store the log file path for later use
         if name == "M<>M Relay":
-            # Create a basic logger to log the log file path
-            # This is needed because we can't use the logger we're creating to log its own creation
-            basic_logger = logging.getLogger("LogSetup")
-            basic_logger.setLevel(logging.INFO)
-            basic_handler = logging.StreamHandler()
-            basic_handler.setFormatter(
-                logging.Formatter(
-                    fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
-                    datefmt="%Y-%m-%d %H:%M:%S %z",
-                )
-            )
-            basic_logger.addHandler(basic_handler)
-            basic_logger.info(f"Writing logs to: {log_file}")
+            global log_file_path
+            log_file_path = log_file
 
         # Create a file handler for logging
         try:

mmrelay/main.py

@@ -10,8 +10,9 @@ import sys
 
 from nio import ReactionEvent, RoomMessageEmote, RoomMessageNotice, RoomMessageText
 
+# Import version from package
 # Import meshtastic_utils as a module to set event_loop
-from mmrelay import meshtastic_utils
+from mmrelay import __version__, meshtastic_utils
 from mmrelay.db_utils import (
     initialize_database,
     update_longnames,
@@ -33,6 +34,18 @@ logger = get_logger(name="M<>M Relay")
 logging.getLogger("nio").setLevel(logging.ERROR)
 
 
+# Flag to track if banner has been printed
+_banner_printed = False
+
+def print_banner():
+    """Print a simple startup message with version information."""
+    global _banner_printed
+    # Only print the banner once
+    if not _banner_printed:
+        logger.info(f"Starting MMRelay v{__version__}")
+        _banner_printed = True
+
+
 async def main(config):
     """
     Main asynchronous function to set up and run the relay.
@@ -202,6 +215,9 @@ def run_main(args):
     Returns:
         int: Exit code (0 for success, non-zero for failure)
     """
+    # Print the banner at startup
+    print_banner()
+
     # Handle the --data-dir option
     if args and args.data_dir:
         import os
@@ -245,6 +261,19 @@ def run_main(args):
     set_config(db_utils, config)
     set_config(base_plugin, config)
 
+    # Get config path and log file path for logging
+    from mmrelay.config import config_path
+    from mmrelay.log_utils import log_file_path
+
+    # Create a logger with a different name to avoid conflicts with the one in config.py
+    config_rich_logger = get_logger("ConfigInfo")
+
+    # Now log the config file and log file locations with the properly formatted logger
+    if config_path:
+        config_rich_logger.info(f"Config file location: {config_path}")
+    if log_file_path:
+        config_rich_logger.info(f"Log file location: {log_file_path}")
+
     # Check if config exists and has the required keys
     required_keys = ["matrix", "meshtastic", "matrix_rooms"]
 

mmrelay/meshtastic_utils.py

@@ -1,6 +1,8 @@
 import asyncio
 import contextlib
 import io
+import os
+import sys
 import threading
 import time
 from typing import List
@@ -46,6 +48,32 @@ shutting_down = False
 reconnect_task = None  # To keep track of the reconnect task
 
 
+def is_running_as_service():
+    """
+    Check if the application is running as a systemd service.
+    This is used to determine whether to show Rich progress indicators.
+
+    Returns:
+        bool: True if running as a service, False otherwise
+    """
+    # Check for INVOCATION_ID environment variable (set by systemd)
+    if os.environ.get("INVOCATION_ID"):
+        return True
+
+    # Check if parent process is systemd
+    try:
+        with open("/proc/self/status") as f:
+            for line in f:
+                if line.startswith("PPid:"):
+                    ppid = int(line.split()[1])
+                    with open(f"/proc/{ppid}/comm") as p:
+                        return p.read().strip() == "systemd"
+    except (FileNotFoundError, PermissionError, ValueError):
+        pass
+
+    return False
+
+
 def serial_port_exists(port_name):
     """
     Check if the specified serial port exists.
@@ -118,7 +146,7 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                 if connection_type == "serial":
                     # Serial connection
                     serial_port = config["meshtastic"]["serial_port"]
-                    logger.info(f"Connecting to serial port {serial_port} ...")
+                    logger.info(f"Connecting to serial port {serial_port}")
 
                     # Check if serial port exists before connecting
                     if not serial_port_exists(serial_port):
@@ -137,7 +165,9 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     # BLE connection
                     ble_address = config["meshtastic"].get("ble_address")
                     if ble_address:
-                        logger.info(f"Connecting to BLE address {ble_address} ...")
+                        logger.info(f"Connecting to BLE address {ble_address}")
+
+                        # Connect without progress indicator
                         meshtastic_client = meshtastic.ble_interface.BLEInterface(
                             address=ble_address,
                             noProto=False,
@@ -151,7 +181,9 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                 elif connection_type == "tcp":
                     # TCP connection
                     target_host = config["meshtastic"]["host"]
-                    logger.info(f"Connecting to host {target_host} ...")
+                    logger.info(f"Connecting to host {target_host}")
+
+                    # Connect without progress indicator
                     meshtastic_client = meshtastic.tcp_interface.TCPInterface(
                         hostname=target_host
                     )
@@ -244,7 +276,25 @@ async def reconnect():
                 logger.info(
                     f"Reconnection attempt starting in {backoff_time} seconds..."
                 )
-                await asyncio.sleep(backoff_time)
+
+                # Show reconnection countdown with Rich (if not in a service)
+                if not is_running_as_service():
+                    from rich.progress import Progress, TextColumn, BarColumn, TimeRemainingColumn
+                    with Progress(
+                        TextColumn("[cyan]Meshtastic: Reconnecting in"),
+                        BarColumn(),
+                        TextColumn("[cyan]{task.percentage:.0f}%"),
+                        TimeRemainingColumn(),
+                        transient=True,
+                    ) as progress:
+                        task = progress.add_task("Waiting", total=backoff_time)
+                        for _ in range(backoff_time):
+                            if shutting_down:
+                                break
+                            await asyncio.sleep(1)
+                            progress.update(task, advance=1)
+                else:
+                    await asyncio.sleep(backoff_time)
                 if shutting_down:
                     logger.debug(
                         "Shutdown in progress. Aborting reconnection attempts."

mmrelay/setup_utils.py

@@ -14,8 +14,20 @@ from pathlib import Path
 
 
 def get_executable_path():
-    """Get the full path to the mmrelay executable."""
-    return shutil.which("mmrelay") or sys.executable
+    """Get the full path to the mmrelay executable.
+
+    This function tries to find the mmrelay executable in the PATH,
+    which works for both pipx and pip installations.
+    """
+    mmrelay_path = shutil.which("mmrelay")
+    if mmrelay_path:
+        print(f"Found mmrelay executable at: {mmrelay_path}")
+        return mmrelay_path
+    else:
+        print(
+            "Warning: Could not find mmrelay executable in PATH. Using current Python interpreter."
+        )
+        return sys.executable
 
 
 def get_user_service_path():
@@ -31,7 +43,6 @@ def service_exists():
 
 def print_service_commands():
     """Print the commands for controlling the systemd user service."""
-    print("\nUse these commands to control the mmrelay service:")
     print("  systemctl --user start mmrelay.service    # Start the service")
     print("  systemctl --user stop mmrelay.service     # Stop the service")
     print("  systemctl --user restart mmrelay.service  # Restart the service")
@@ -39,24 +50,29 @@ def print_service_commands():
 
 
 def wait_for_service_start():
-    """Wait for the service to start with a loading animation."""
-    import sys
+    """Wait for the service to start with a Rich progress indicator."""
     import time
+    from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
 
-    print("\nStarting mmrelay service", end="")
-    sys.stdout.flush()
-
-    # Animation characters
-    chars = ["-", "\\", "|", "/"]
+    # Create a Rich progress display with spinner and elapsed time
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold green]Starting mmrelay service..."),
+        TimeElapsedColumn(),
+        transient=True,
+    ) as progress:
+        # Add a task that will run for approximately 10 seconds
+        task = progress.add_task("Starting", total=100)
 
-    # Wait for 10 seconds with animation
-    for i in range(40):  # 40 * 0.25s = 10s
-        time.sleep(0.25)
-        print(f"\rStarting mmrelay service {chars[i % len(chars)]}", end="")
-        sys.stdout.flush()
+        # Update progress over 10 seconds
+        for i in range(10):
+            time.sleep(1)
+            progress.update(task, completed=10 * (i + 1))
 
-    print("\rStarting mmrelay service... done!")
-    sys.stdout.flush()
+            # Check if service is active after 5 seconds to potentially finish early
+            if i >= 5 and is_service_active():
+                progress.update(task, completed=100)
+                break
 
 
 def read_service_file():
@@ -67,45 +83,108 @@ def read_service_file():
     return None
 
 
-def create_service_file():
-    """Create the systemd user service file."""
-    executable_path = get_executable_path()
-    if not executable_path:
-        print("Error: Could not find mmrelay executable in PATH")
-        return False
-
-    # Create service directory if it doesn't exist
-    service_dir = get_user_service_path().parent
-    service_dir.mkdir(parents=True, exist_ok=True)
-
-    # Create logs directory if it doesn't exist
-    logs_dir = Path.home() / ".mmrelay" / "logs"
-    logs_dir.mkdir(parents=True, exist_ok=True)
+def get_template_service_path():
+    """Find the path to the template service file.
 
+    Returns:
+        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
+    # 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
+    # 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
+    # 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):
-        print(f"Error: Could not find service template at {template_path}")
-        return False
+        return None
+
+    return template_path
+
+
+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.
+    """
+    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
+
+
+def is_service_enabled():
+    """Check if the service is enabled.
+
+    Returns:
+        bool: True if the service is enabled, False otherwise.
+    """
+    try:
+        result = subprocess.run(
+            ["/usr/bin/systemctl", "--user", "is-enabled", "mmrelay.service"],
+            check=False,  # Don't raise an exception if the service is not enabled
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0 and result.stdout.strip() == "enabled"
+    except Exception:
+        return False
+
+
+def is_service_active():
+    """Check if the service is active (running).
+
+    Returns:
+        bool: True if the service is active, False otherwise.
+    """
+    try:
+        result = subprocess.run(
+            ["/usr/bin/systemctl", "--user", "is-active", "mmrelay.service"],
+            check=False,  # Don't raise an exception if the service is not active
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0 and result.stdout.strip() == "active"
+    except Exception:
+        return False
+
+
+def create_service_file():
+    """Create the systemd user service file."""
+    executable_path = get_executable_path()
+    if not executable_path:
+        print("Error: Could not find mmrelay executable in PATH")
+        return False
+
+    # Create service directory if it doesn't exist
+    service_dir = get_user_service_path().parent
+    service_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create logs directory if it doesn't exist
+    logs_dir = Path.home() / ".mmrelay" / "logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get the template service content
+    service_template = get_template_service_content()
+    if not service_template:
+        print("Error: Could not find service template file")
+        return False
+
     # Replace placeholders with actual values
     service_content = (
         service_template.replace(
@@ -147,74 +226,158 @@ def reload_daemon():
         return False
 
 
-def install_service():
-    """Install or update the MMRelay user service."""
+def service_needs_update():
+    """Check if the service file needs to be updated.
+
+    Returns:
+        tuple: (needs_update, reason) where needs_update is a boolean and reason is a string
+    """
     # Check if service already exists
     existing_service = read_service_file()
+    if not existing_service:
+        return True, "No existing service file found"
 
-    if existing_service:
-        print(f"A service file already exists at {get_user_service_path()}")
-        if (
-            not input("Do you want to reinstall/update the service? (y/n): ")
-            .lower()
-            .startswith("y")
-        ):
-            print("Service installation cancelled.")
-            print_service_commands()
-            return True
+    # Get the template service path
+    template_path = get_template_service_path()
+    if not template_path:
+        return False, "Could not find template service file"
 
-    # Create or update service file
-    if not create_service_file():
-        return False
+    # Get the executable path
+    executable_path = get_executable_path()
+    if not executable_path:
+        return False, "Could not find mmrelay executable"
 
-    # Reload daemon
-    if not reload_daemon():
-        return False
+    # Check if the ExecStart line in the existing service file contains the correct executable
+    if executable_path not in existing_service:
+        return (
+            True,
+            f"Service file does not use the current executable: {executable_path}",
+        )
+
+    # Check if the PATH environment includes pipx paths
+    if "%h/.local/pipx/venvs/mmrelay/bin" not in existing_service:
+        return True, "Service file does not include pipx paths in PATH environment"
+
+    # Check if the service file has been modified recently
+    template_mtime = os.path.getmtime(template_path)
+    service_path = get_user_service_path()
+    if os.path.exists(service_path):
+        service_mtime = os.path.getmtime(service_path)
+        if template_mtime > service_mtime:
+            return True, "Template service file is newer than installed service file"
+
+    return False, "Service file is up to date"
+
+
+def install_service():
+    """Install or update the MMRelay user service."""
+    # Check if service already exists
+    existing_service = read_service_file()
+    service_path = get_user_service_path()
+
+    # Check if the service needs to be updated
+    update_needed, reason = service_needs_update()
 
+    # Check if the service is already installed and if it needs updating
     if existing_service:
-        print("Service updated successfully")
+        print(f"A service file already exists at {service_path}")
+
+        if update_needed:
+            print(f"The service file needs to be updated: {reason}")
+            if (
+                not input("Do you want to update the service file? (y/n): ")
+                .lower()
+                .startswith("y")
+            ):
+                print("Service update cancelled.")
+                print_service_commands()
+                return True
+        else:
+            print(f"No update needed for the service file: {reason}")
     else:
-        print("Service installed successfully")
+        print(f"No service file found at {service_path}")
+        print("A new service file will be created.")
 
-    # Check if config is valid before starting the service
-    from mmrelay.cli import check_config
+    # Create or update service file if needed
+    if not existing_service or update_needed:
+        if not create_service_file():
+            return False
 
-    if not check_config():
-        print(
-            "\nWarning: Configuration is not valid. Service is installed but not started."
-        )
-        print("Please fix your configuration and then start the service manually.")
-        print_service_commands()
-        return True
+        # Reload daemon
+        if not reload_daemon():
+            return False
 
-    # Ask if user wants to enable and start the service
-    if (
-        input("Do you want to enable the service to start at boot? (y/n): ")
-        .lower()
-        .startswith("y")
-    ):
-        try:
-            subprocess.run(
-                ["/usr/bin/systemctl", "--user", "enable", "mmrelay.service"],
-                check=True,
-            )
-            print("Service enabled successfully")
-        except subprocess.CalledProcessError as e:
-            print(f"Error enabling service: {e}")
-        except OSError as e:
-            print(f"Error: {e}")
-
-    if input("Do you want to start the service now? (y/n): ").lower().startswith("y"):
-        if start_service():
-            # Wait for the service to start
-            wait_for_service_start()
-
-            # Show service status
-            show_service_status()
-            print("Service started successfully")
+        if existing_service:
+            print("Service file updated successfully")
         else:
-            print("\nWarning: Failed to start the service. Please check the logs.")
+            print("Service file created successfully")
+
+    # We don't need to validate the config here as it will be validated when the service starts
 
+    # Check if the service is already enabled
+    service_enabled = is_service_enabled()
+    if service_enabled:
+        print("The service is already enabled to start at boot.")
+    else:
+        print("The service is not currently enabled to start at boot.")
+        if (
+            input("Do you want to enable the service to start at boot? (y/n): ")
+            .lower()
+            .startswith("y")
+        ):
+            try:
+                subprocess.run(
+                    ["/usr/bin/systemctl", "--user", "enable", "mmrelay.service"],
+                    check=True,
+                )
+                print("Service enabled successfully")
+                service_enabled = True
+            except subprocess.CalledProcessError as e:
+                print(f"Error enabling service: {e}")
+            except OSError as e:
+                print(f"Error: {e}")
+
+    # Check if the service is already running
+    service_active = is_service_active()
+    if service_active:
+        print("The service is already running.")
+        if input("Do you want to restart the service? (y/n): ").lower().startswith("y"):
+            try:
+                subprocess.run(
+                    ["/usr/bin/systemctl", "--user", "restart", "mmrelay.service"],
+                    check=True,
+                )
+                print("Service restarted successfully")
+                # Wait for the service to restart
+                wait_for_service_start()
+                # Show service status
+                show_service_status()
+            except subprocess.CalledProcessError as e:
+                print(f"Error restarting service: {e}")
+            except OSError as e:
+                print(f"Error: {e}")
+    else:
+        print("The service is not currently running.")
+        if (
+            input("Do you want to start the service now? (y/n): ")
+            .lower()
+            .startswith("y")
+        ):
+            if start_service():
+                # Wait for the service to start
+                wait_for_service_start()
+                # Show service status
+                show_service_status()
+                print("Service started successfully")
+            else:
+                print("\nWarning: Failed to start the service. Please check the logs.")
+
+    # Print a summary of the service status
+    print("\nService Status Summary:")
+    print(f"  Service File: {service_path}")
+    print(f"  Enabled at Boot: {'Yes' if service_enabled else 'No'}")
+    print(f"  Currently Running: {'Yes' if is_service_active() else 'No'}")
+    print("\nService Management Commands:")
     print_service_commands()
 
     return True

{mmrelay-1.0.dist-info → mmrelay-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.0
+Version: 1.0.1
 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
@@ -15,19 +15,32 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: meshtastic
-Requires-Dist: Pillow==11.1.0
+Requires-Dist: Pillow==11.2.1
 Requires-Dist: matrix-nio==0.25.2
 Requires-Dist: matplotlib==3.10.1
 Requires-Dist: requests==2.32.3
-Requires-Dist: markdown==3.7
+Requires-Dist: markdown==3.8
 Requires-Dist: haversine==2.9.0
 Requires-Dist: schedule==1.2.2
-Requires-Dist: platformdirs==4.2.0
+Requires-Dist: platformdirs==4.3.7
 Requires-Dist: py-staticmaps>=0.4.0
+Requires-Dist: rich==14.0.0
 Dynamic: license-file
 
 # M<>M Relay
 
+## ✨ Version 1.0 Released! ✨
+
+**We're excited to announce MMRelay v1.0 with improved packaging, standardized directories, and enhanced CLI!**
+
+**Existing users:** Version 1.0 requires a few quick migration steps:
+
+1. Follow the [UPGRADE_TO_V1.md](UPGRADE_TO_V1.md) guide for a smooth transition
+2. Move your configuration to the new standard location (`~/.mmrelay/config.yaml`)
+3. See [ANNOUNCEMENT.md](ANNOUNCEMENT.md) for all the exciting new features
+
+Not ready to upgrade yet? No problem! Run `git checkout 0.10.1` to continue using the previous version.
+
 ## (Meshtastic <=> Matrix Relay)
 
 A powerful and easy-to-use relay between Meshtastic devices and Matrix chat rooms, allowing seamless communication across platforms. This opens the door for bridging Meshtastic devices to [many other platforms](https://matrix.org/bridges/).
@@ -41,17 +54,19 @@ MMRelay runs on Linux, macOS, and Windows.
 ### Quick Installation
 
 ```bash
-# Install using pip
-pip install mmrelay
-
-# Or use pipx for isolated installation (recommended)
+# Install using pipx for isolated installation (recommended)
 pipx install mmrelay
+
+# Pip will also work if you prefer
+pip install mmrelay
 ```
 
+For pipx installation instructions, see: [pipx installation guide](https://pipx.pypa.io/stable/installation/#on-linux)
+
 ### Resources
 
 - **New Users**: See [INSTRUCTIONS.md](INSTRUCTIONS.md) for setup and configuration
-- **Existing Users**: Check [UPGRADE_TO_V1.md](UPGRADE_TO_V1.md) for migration guidance
+- **Existing Users**: See [UPGRADE_TO_V1.md](UPGRADE_TO_V1.md) for migration guidance
 - **Configuration**: Review [sample_config.yaml](sample_config.yaml) for examples
 
 ### Command-Line Options

{mmrelay-1.0.dist-info → mmrelay-1.0.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
-mmrelay/__init__.py,sha256=tY9iMcQ9e8IhGjiSjukqcNujnqqf7_OTORo7JvRDWvU,278
-mmrelay/cli.py,sha256=H-h-hvrFiOr9gTY5o21snBNiHJCDJx_HLR8JxTs1M-o,12273
-mmrelay/config.py,sha256=epH-xOOIMblG5w_fk86r8JgJK-70bLbX5CfMTWOfPmo,7064
+mmrelay/__init__.py,sha256=rJqoGfYDKTqEyyzrpQDpwRPfFCDG90XnhGUSHzttjPo,440
+mmrelay/cli.py,sha256=yBYOkCwGYDJ2gRKPoPltxB_PydX1CPNUerVJHcNuHTo,12355
+mmrelay/config.py,sha256=OIDxQStuVHyWxsDfnKqt0rr26ETEoZPqHVXReEH3IG8,7006
 mmrelay/config_checker.py,sha256=UnoHVTXzfdTfFkbmXv9r_Si76v-sxXLb5FOaQSOM45E,4909
 mmrelay/db_utils.py,sha256=DP2YuKBZtV771wo9X-Z7Ww5txfaIR0inWh1K_oVZ7cA,11430
-mmrelay/log_utils.py,sha256=-ItwMnxa-t2ZKBIp6wzCkq19dk7A0MofsvjS_ilTSlQ,3808
-mmrelay/main.py,sha256=a_ZLDiGcBtrZgTlJq8gqGSW8YCduDgAOEDxzwy4AiXE,10097
+mmrelay/log_utils.py,sha256=FXhaq4WSDHwlqiG3k1BbSxiOl5be4P4Kyr1gsIThOBw,4572
+mmrelay/main.py,sha256=Okiat89uWiOrn5wq7lvJinYP3C6wzKdlQsyLxB8cCmI,11084
 mmrelay/matrix_utils.py,sha256=GkIVj2bbPHtx1emFMwhEhc1SWHcv4UvkuyZYdb-Wnwo,30511
-mmrelay/meshtastic_utils.py,sha256=7Q6mQ2gLLc_yjlGCmakPgGRoBB9znRWOCGMW0MgoZ-w,21414
+mmrelay/meshtastic_utils.py,sha256=ha6wRYeU16wT8jkZlr7RjnsB1b9e276cgu0jw4vmdbw,23270
 mmrelay/plugin_loader.py,sha256=QfSXu4nxxBL_pGttLJGzGki8kRtWbFdtSoD_Qnx2iqU,12758
-mmrelay/setup_utils.py,sha256=iFHEGnrop3Lv2j-MDmOGT4oQYuAm_5YHAc16O2rpkew,8022
+mmrelay/setup_utils.py,sha256=MWBrpf9lNlw21yOoyFhzz1DSJx2KMTzZIMcHS3MwcdM,14090
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
 mmrelay/plugins/base_plugin.py,sha256=7tBIARWp9Qc4iAEMcsKiUJh1cbqXHcXAk4dlu1b8SBg,7524
 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.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
-mmrelay-1.0.dist-info/METADATA,sha256=NCTfzxMnJjPpgBtOP0oGD7ZPYQBHA6CiUkvarmYzrGk,6219
-mmrelay-1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mmrelay-1.0.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.0.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.0.dist-info/RECORD,,
+mmrelay-1.0.1.dist-info/licenses/LICENSE,sha256=yceWauM1c0-FHxVplsD7W1-AbSeRaUNlmqT4UO1msBU,1073
+mmrelay-1.0.1.dist-info/METADATA,sha256=WziSMZeJluF69VwTLtCuxGvGtFxbAcumZV4iOAEWWTg,6953
+mmrelay-1.0.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+mmrelay-1.0.1.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.0.1.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.0.1.dist-info/RECORD,,

{mmrelay-1.0.dist-info → mmrelay-1.0.1.dist-info}/WHEEL

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