fetchtastic 0.1.0__py3-none-any.whl

app/cli.py

@@ -0,0 +1,57 @@
+# app/cli.py
+
+import argparse
+from . import downloader
+from . import setup_config
+
+def main():
+    parser = argparse.ArgumentParser(description="Fetchtastic - Meshtastic Firmware and APK Downloader")
+    subparsers = parser.add_subparsers(dest='command')
+
+    # Command to run setup
+    subparsers.add_parser('setup', help='Run the setup process')
+
+    # Command to download firmware and APKs
+    subparsers.add_parser('download', help='Download firmware and APKs')
+
+    # Command to display NTFY topic
+    subparsers.add_parser('topic', help='Display the current NTFY topic')
+
+    # Command to clean/remove Fetchtastic files and settings
+    subparsers.add_parser('clean', help='Remove Fetchtastic configuration, downloads, and cron jobs')
+
+    args = parser.parse_args()
+
+    if args.command == 'setup':
+        # Run the setup process
+        setup_config.run_setup()
+    elif args.command == 'download':
+        # Check if configuration exists
+        if not setup_config.config_exists():
+            print("No configuration found. Running setup.")
+            setup_config.run_setup()
+        # Run the downloader
+        downloader.main()
+    elif args.command == 'topic':
+        # Display the NTFY topic
+        config = setup_config.load_config()
+        if config and config.get('NTFY_SERVER') and config.get('NTFY_TOPIC'):
+            ntfy_server = config['NTFY_SERVER'].rstrip('/')
+            ntfy_topic = config['NTFY_TOPIC']
+            full_url = f"{ntfy_server}/{ntfy_topic}"
+            print(f"Current NTFY topic URL: {full_url}")
+            print(f"Topic name: {ntfy_topic}")
+        else:
+            print("Notifications are not set up. Run 'fetchtastic setup' to configure notifications.")
+    elif args.command == 'clean':
+        # Run the clean process
+        setup_config.run_clean()
+    elif args.command is None:
+        # No command provided
+        print("No command provided.")
+        print("For help and available commands, run 'fetchtastic --help'.")
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

app/downloader.py

@@ -0,0 +1,256 @@
+# app/downloader.py
+
+import os
+import requests
+import zipfile
+import time
+from datetime import datetime
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from . import setup_config
+
+def main():
+    # Load configuration
+    config = setup_config.load_config()
+    if not config:
+        print("Configuration not found. Please run 'fetchtastic setup' first.")
+        return
+
+    # Get configuration values
+    save_apks = config.get("SAVE_APKS", False)
+    save_firmware = config.get("SAVE_FIRMWARE", False)
+    ntfy_server = config.get("NTFY_SERVER", "")
+    ntfy_topic = config.get("NTFY_TOPIC", "")
+    android_versions_to_keep = config.get("ANDROID_VERSIONS_TO_KEEP", 2)
+    firmware_versions_to_keep = config.get("FIRMWARE_VERSIONS_TO_KEEP", 2)
+    auto_extract = config.get("AUTO_EXTRACT", False)
+    extract_patterns = config.get("EXTRACT_PATTERNS", [])
+
+    selected_apk_assets = config.get('SELECTED_APK_ASSETS', [])
+    selected_firmware_assets = config.get('SELECTED_FIRMWARE_ASSETS', [])
+
+    download_dir = config.get('DOWNLOAD_DIR', os.path.join(os.path.expanduser("~"), "storage", "downloads", "Meshtastic"))
+    firmware_dir = os.path.join(download_dir, "firmware")
+    apks_dir = os.path.join(download_dir, "apks")
+    latest_android_release_file = os.path.join(apks_dir, "latest_android_release.txt")
+    latest_firmware_release_file = os.path.join(firmware_dir, "latest_firmware_release.txt")
+
+    # Create necessary directories
+    for dir_path in [download_dir, firmware_dir, apks_dir]:
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
+
+    # Logging setup
+    log_file = os.path.join(download_dir, "fetchtastic.log")
+
+    def log_message(message):
+        with open(log_file, "a") as log:
+            log.write(f"{datetime.now()}: {message}\n")
+        print(message)
+
+    def send_ntfy_notification(message):
+        if ntfy_server and ntfy_topic:
+            try:
+                ntfy_url = f"{ntfy_server.rstrip('/')}/{ntfy_topic}"
+                response = requests.post(ntfy_url, data=message.encode('utf-8'))
+                response.raise_for_status()
+            except requests.exceptions.RequestException as e:
+                log_message(f"Error sending notification: {e}")
+        else:
+            log_message("Notifications are not configured.")
+
+    # Function to get the latest releases and sort by date
+    def get_latest_releases(url, versions_to_keep, scan_count=5):
+        response = requests.get(url)
+        response.raise_for_status()
+        releases = response.json()
+        # Sort releases by published date, descending order
+        sorted_releases = sorted(releases, key=lambda r: r['published_at'], reverse=True)
+        # Limit the number of releases to be scanned and downloaded
+        return sorted_releases[:scan_count][:versions_to_keep]
+
+    # Function to download a file with retry mechanism
+    def download_file(url, download_path):
+        session = requests.Session()
+        retry = Retry(connect=3, backoff_factor=1, status_forcelist=[502, 503, 504])
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount('https://', adapter)
+        session.mount('http://', adapter)
+        
+        try:
+            if not os.path.exists(download_path):
+                log_message(f"Downloading {url}")
+                response = session.get(url, stream=True)
+                response.raise_for_status()
+                with open(download_path, 'wb') as file:
+                    for chunk in response.iter_content(1024):
+                        file.write(chunk)
+                log_message(f"Downloaded {download_path}")
+            else:
+                log_message(f"{download_path} already exists, skipping download.")
+        except requests.exceptions.RequestException as e:
+            log_message(f"Error downloading {url}: {e}")
+
+    # Updated extract_files function
+    def extract_files(zip_path, extract_dir, patterns):
+        try:
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                matched_files = []
+                for file_info in zip_ref.infolist():
+                    file_name = file_info.filename
+                    base_name = os.path.basename(file_name)
+                    log_message(f"Checking file: {base_name}")
+                    for pattern in patterns:
+                        if pattern in base_name:
+                            # Extract and flatten directory structure
+                            source = zip_ref.open(file_info)
+                            target_path = os.path.join(extract_dir, base_name)
+                            with open(target_path, 'wb') as target_file:
+                                target_file.write(source.read())
+                            log_message(f"Extracted {base_name} to {extract_dir}")
+                            matched_files.append(base_name)
+                            break  # Stop checking patterns for this file
+                if not matched_files:
+                    log_message(f"No files matched the extraction patterns in {zip_path}.")
+        except zipfile.BadZipFile:
+            log_message(f"Error: {zip_path} is a bad zip file and cannot be opened.")
+        except Exception as e:
+            log_message(f"Error: An unexpected error occurred while extracting files from {zip_path}: {e}")
+
+    # Cleanup function to keep only a specific number of versions
+    def cleanup_old_versions(directory, keep_count):
+        versions = sorted(
+            (os.path.join(directory, d) for d in os.listdir(directory) if os.path.isdir(os.path.join(directory, d))),
+            key=os.path.getmtime
+        )
+        old_versions = versions[:-keep_count]
+        for version in old_versions:
+            for root, dirs, files in os.walk(version, topdown=False):
+                for name in files:
+                    os.remove(os.path.join(root, name))
+                    log_message(f"Removed file: {os.path.join(root, name)}")
+                for name in dirs:
+                    os.rmdir(os.path.join(root, name))
+            os.rmdir(version)
+            log_message(f"Removed directory: {version}")
+
+    # Function to check for missing releases and download them if necessary
+    def check_and_download(releases, latest_release_file, release_type, download_dir, versions_to_keep, extract_patterns, selected_assets=None):
+        downloaded_versions = []
+
+        if not os.path.exists(download_dir):
+            os.makedirs(download_dir)
+
+        # Load the latest release tag from file if available
+        saved_release_tag = None
+        if os.path.exists(latest_release_file):
+            with open(latest_release_file, 'r') as f:
+                saved_release_tag = f.read().strip()
+
+        # Determine which releases to download
+        for release in releases:
+            release_tag = release['tag_name']
+            release_dir = os.path.join(download_dir, release_tag)
+
+            if os.path.exists(release_dir) or release_tag == saved_release_tag:
+                log_message(f"Skipping version {release_tag}, already exists.")
+            else:
+                # Proceed to download this version
+                os.makedirs(release_dir, exist_ok=True)
+                log_message(f"Downloading new version: {release_tag}")
+                for asset in release['assets']:
+                    file_name = asset['name']
+                    if selected_assets:
+                        if file_name not in selected_assets:
+                            continue
+                    download_path = os.path.join(release_dir, file_name)
+                    download_file(asset['browser_download_url'], download_path)
+                    if auto_extract and file_name.endswith('.zip') and release_type == "Firmware":
+                        extract_files(download_path, release_dir, extract_patterns)
+                downloaded_versions.append(release_tag)
+
+        # Update latest_release_file with the most recent tag
+        if releases:
+            with open(latest_release_file, 'w') as f:
+                f.write(releases[0]['tag_name'])
+
+        # Clean up old versions
+        cleanup_old_versions(download_dir, versions_to_keep)
+        return downloaded_versions
+
+    start_time = time.time()
+    log_message("Starting Fetchtastic...")
+
+    downloaded_firmwares = []
+    downloaded_apks = []
+
+    # URLs for releases
+    android_releases_url = "https://api.github.com/repos/meshtastic/Meshtastic-Android/releases"
+    firmware_releases_url = "https://api.github.com/repos/meshtastic/firmware/releases"
+
+    # Scan for the last 5 releases, download the latest versions_to_download
+    releases_to_scan = 5
+
+    latest_firmware_releases = []
+    latest_android_releases = []
+
+    if save_firmware and selected_firmware_assets:
+        versions_to_download = firmware_versions_to_keep
+        latest_firmware_releases = get_latest_releases(firmware_releases_url, versions_to_download, releases_to_scan)
+        downloaded_firmwares = check_and_download(
+            latest_firmware_releases,
+            latest_firmware_release_file,
+            "Firmware",
+            firmware_dir,
+            firmware_versions_to_keep,
+            extract_patterns,
+            selected_assets=selected_firmware_assets
+        )
+        log_message(f"Latest Firmware releases: {', '.join(release['tag_name'] for release in latest_firmware_releases)}")
+    elif not selected_firmware_assets:
+        log_message("No firmware assets selected. Skipping firmware download.")
+
+    if save_apks and selected_apk_assets:
+        versions_to_download = android_versions_to_keep
+        latest_android_releases = get_latest_releases(android_releases_url, versions_to_download, releases_to_scan)
+        downloaded_apks = check_and_download(
+            latest_android_releases,
+            latest_android_release_file,
+            "Android APK",
+            apks_dir,
+            android_versions_to_keep,
+            extract_patterns,
+            selected_assets=selected_apk_assets
+        )
+        log_message(f"Latest Android APK releases: {', '.join(release['tag_name'] for release in latest_android_releases)}")
+    elif not selected_apk_assets:
+        log_message("No APK assets selected. Skipping APK download.")
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    log_message(f"Finished the Meshtastic downloader. Total time taken: {total_time:.2f} seconds")
+
+    # Send notification if there are new downloads
+    if downloaded_firmwares or downloaded_apks:
+        message = ""
+        if downloaded_firmwares:
+            message += f"New Firmware releases {', '.join(downloaded_firmwares)} downloaded.\n"
+        if downloaded_apks:
+            message += f"New Android APK releases {', '.join(downloaded_apks)} downloaded.\n"
+        message += f"{datetime.now()}"
+        send_ntfy_notification(message)
+    else:
+        if latest_firmware_releases or latest_android_releases:
+            message = (
+                f"All Firmware and Android APK versions are up to date.\n"
+                f"Latest Firmware releases: {', '.join(release['tag_name'] for release in latest_firmware_releases)}\n"
+                f"Latest Android APK releases: {', '.join(release['tag_name'] for release in latest_android_releases)}\n"
+                f"{datetime.now()}"
+            )
+            send_ntfy_notification(message)
+        else:
+            log_message("No releases found to check for updates.")
+
+if __name__ == "__main__":
+    main()

app/menu_apk.py

@@ -0,0 +1,40 @@
+# fetchtastic/menu_apk.py
+
+import re
+import requests
+from pick import pick
+
+def fetch_apk_assets():
+    apk_releases_url = "https://api.github.com/repos/meshtastic/Meshtastic-Android/releases"
+    response = requests.get(apk_releases_url)
+    response.raise_for_status()
+    releases = response.json()
+    # Get the latest release
+    latest_release = releases[0]
+    assets = latest_release['assets']
+    asset_names = [asset['name'] for asset in assets if asset['name'].endswith('.apk')]
+    return asset_names
+
+def select_assets(assets):
+    title = '''Select the APK files you want to download (press SPACE to select, ENTER to confirm):
+Note: These are files from the latest release. Version numbers may change in other releases.'''
+    options = assets
+    selected_options = pick(options, title, multiselect=True, min_selection_count=0, indicator='*')
+    selected_assets = [option[0] for option in selected_options]
+    if not selected_assets:
+        print("No APK files selected. APKs will not be downloaded.")
+        return None
+    return selected_assets
+
+def run_menu():
+    try:
+        assets = fetch_apk_assets()
+        selected_assets = select_assets(assets)
+        if selected_assets is None:
+            return None
+        return {
+            'selected_assets': selected_assets
+        }
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None

app/menu_firmware.py

@@ -0,0 +1,39 @@
+# app/menu_firmware.py
+
+import requests
+from pick import pick
+
+def fetch_firmware_assets():
+    firmware_releases_url = "https://api.github.com/repos/meshtastic/firmware/releases"
+    response = requests.get(firmware_releases_url)
+    response.raise_for_status()
+    releases = response.json()
+    # Get the latest release
+    latest_release = releases[0]
+    assets = latest_release['assets']
+    asset_names = [asset['name'] for asset in assets]
+    return asset_names
+
+def select_assets(assets):
+    title = '''Select the firmware files you want to download (press SPACE to select, ENTER to confirm):
+Note: These are files from the latest release. Version numbers may change in other releases.'''
+    options = assets
+    selected_options = pick(options, title, multiselect=True, min_selection_count=0, indicator='*')
+    selected_assets = [option[0] for option in selected_options]
+    if not selected_assets:
+        print("No firmware files selected. Firmware will not be downloaded.")
+        return None
+    return selected_assets
+
+def run_menu():
+    try:
+        assets = fetch_firmware_assets()
+        selected_assets = select_assets(assets)
+        if selected_assets is None:
+            return None
+        return {
+            'selected_assets': selected_assets
+        }
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None

app/setup_config.py

@@ -0,0 +1,288 @@
+# app/setup_config.py
+
+import os
+import yaml
+import subprocess
+import random
+import string
+import shutil  # Added for shutil.which()
+from . import menu_apk
+from . import menu_firmware
+from . import downloader  # Import downloader to perform first run
+
+def get_downloads_dir():
+    # For Termux, use ~/storage/downloads
+    if 'com.termux' in os.environ.get('PREFIX', ''):
+        storage_downloads = os.path.expanduser("~/storage/downloads")
+        if os.path.exists(storage_downloads):
+            return storage_downloads
+    # For other environments, use standard Downloads directories
+    home_dir = os.path.expanduser("~")
+    downloads_dir = os.path.join(home_dir, 'Downloads')
+    if os.path.exists(downloads_dir):
+        return downloads_dir
+    downloads_dir = os.path.join(home_dir, 'Download')
+    if os.path.exists(downloads_dir):
+        return downloads_dir
+    # Fallback to home directory
+    return home_dir
+
+DOWNLOADS_DIR = get_downloads_dir()
+DEFAULT_CONFIG_DIR = os.path.join(DOWNLOADS_DIR, 'Meshtastic')
+CONFIG_FILE = os.path.join(DEFAULT_CONFIG_DIR, 'fetchtastic.yaml')
+
+def config_exists():
+    return os.path.exists(CONFIG_FILE)
+
+def run_setup():
+    # Check if running in Termux
+    if not is_termux():
+        print("Warning: Fetchtastic is designed to run in Termux on Android.")
+        print("For more information, visit https://github.com/jeremiah-k/fetchtastic/")
+        return
+
+    print("Running Fetchtastic Setup...")
+    if not os.path.exists(DEFAULT_CONFIG_DIR):
+        os.makedirs(DEFAULT_CONFIG_DIR)
+
+    config = {}
+
+    # Prompt to save APKs, firmware, or both
+    save_choice = input("Do you want to save APKs, firmware, or both? [a/f/b] (default: b): ").strip().lower() or 'b'
+    if save_choice == 'a':
+        save_apks = True
+        save_firmware = False
+    elif save_choice == 'f':
+        save_apks = False
+        save_firmware = True
+    else:
+        save_apks = True
+        save_firmware = True
+    config['SAVE_APKS'] = save_apks
+    config['SAVE_FIRMWARE'] = save_firmware
+
+    # Run the menu scripts based on user choices
+    if save_apks:
+        apk_selection = menu_apk.run_menu()
+        if not apk_selection:
+            print("No APK assets selected. APKs will not be downloaded.")
+            save_apks = False
+            config['SAVE_APKS'] = False
+        else:
+            config['SELECTED_APK_ASSETS'] = apk_selection['selected_assets']
+    if save_firmware:
+        firmware_selection = menu_firmware.run_menu()
+        if not firmware_selection:
+            print("No firmware assets selected. Firmware will not be downloaded.")
+            save_firmware = False
+            config['SAVE_FIRMWARE'] = False
+        else:
+            config['SELECTED_FIRMWARE_ASSETS'] = firmware_selection['selected_assets']
+
+    # If both save_apks and save_firmware are False, inform the user and exit setup
+    if not save_apks and not save_firmware:
+        print("You must select at least one asset to download (APK or firmware).")
+        print("Please run 'fetchtastic setup' again and select at least one asset.")
+        return
+
+    # Prompt for number of versions to keep
+    if save_apks:
+        android_versions_to_keep = input("Enter the number of different versions of the Android app to keep (default: 2): ").strip() or '2'
+        config['ANDROID_VERSIONS_TO_KEEP'] = int(android_versions_to_keep)
+    if save_firmware:
+        firmware_versions_to_keep = input("Enter the number of different versions of the firmware to keep (default: 2): ").strip() or '2'
+        config['FIRMWARE_VERSIONS_TO_KEEP'] = int(firmware_versions_to_keep)
+
+        # Prompt for automatic extraction
+        auto_extract = input("Do you want to automatically extract specific files from firmware zips? [y/n] (default: n): ").strip().lower() or 'n'
+        if auto_extract == 'y':
+            print("Enter the strings to match for extraction from the firmware .zip files, separated by spaces.")
+            print("Example: rak4631- tbeam-2 t1000-e- tlora-v2-1-1_6-")
+            extract_patterns = input("Extraction patterns: ").strip()
+            if extract_patterns:
+                config['AUTO_EXTRACT'] = True
+                config['EXTRACT_PATTERNS'] = extract_patterns.split()
+            else:
+                config['AUTO_EXTRACT'] = False
+        else:
+            config['AUTO_EXTRACT'] = False
+
+    # Set the download directory to the same as the config directory
+    download_dir = DEFAULT_CONFIG_DIR
+    config['DOWNLOAD_DIR'] = download_dir
+
+    # Save configuration to YAML file before proceeding
+    with open(CONFIG_FILE, 'w') as f:
+        yaml.dump(config, f)
+
+    # Ask if the user wants to set up a cron job
+    setup_cron = input("Do you want to add a cron job to run Fetchtastic daily at 3 AM? [y/n] (default: y): ").strip().lower() or 'y'
+    if setup_cron == 'y':
+        # Install crond if not already installed
+        install_crond()
+        # Call function to set up cron job
+        setup_cron_job()
+    else:
+        print("Skipping cron job setup.")
+
+    # Prompt for NTFY server configuration
+    notifications = input("Do you want to set up notifications via NTFY? [y/n] (default: y): ").strip().lower() or 'y'
+    if notifications == 'y':
+        ntfy_server = input("Enter the NTFY server (default: ntfy.sh): ").strip() or 'ntfy.sh'
+        if not ntfy_server.startswith('http://') and not ntfy_server.startswith('https://'):
+            ntfy_server = 'https://' + ntfy_server
+
+        # Generate a random topic name if the user doesn't provide one
+        default_topic = 'fetchtastic-' + ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
+        topic_name = input(f"Enter a unique topic name (default: {default_topic}): ").strip() or default_topic
+        # Save only the topic name in the config
+        config['NTFY_TOPIC'] = topic_name
+        config['NTFY_SERVER'] = ntfy_server
+
+        # Save updated configuration
+        with open(CONFIG_FILE, 'w') as f:
+            yaml.dump(config, f)
+
+        full_topic_url = f"{ntfy_server.rstrip('/')}/{topic_name}"
+        print(f"Notifications have been set up using the topic: {topic_name}")
+        print(f"You can subscribe to this topic in the ntfy app easily by pasting the topic name.")
+        print(f"Full topic URL: {full_topic_url}")
+        # Ask if the user wants to copy the topic name to the clipboard
+        copy_to_clipboard = input("Do you want to copy the topic name to the clipboard? [y/n] (default: y): ").strip().lower() or 'y'
+        if copy_to_clipboard == 'y':
+            copy_to_clipboard_termux(topic_name)
+            print("Topic name copied to clipboard.")
+        else:
+            print("You can copy the topic name from above.")
+
+        print("You can view your current topic at any time by running 'fetchtastic topic'.")
+        print("You can change the topic by running 'fetchtastic setup' again or editing the YAML file.")
+    else:
+        config['NTFY_TOPIC'] = ''
+        config['NTFY_SERVER'] = ''
+        # Save updated configuration
+        with open(CONFIG_FILE, 'w') as f:
+            yaml.dump(config, f)
+        print("Notifications have not been set up.")
+
+    # Ask if the user wants to perform a first run
+    perform_first_run = input("Do you want to perform a first run now? [y/n] (default: y): ").strip().lower() or 'y'
+    if perform_first_run == 'y':
+        print("Performing first run, this may take a few minutes...")
+        downloader.main()
+    else:
+        print("Setup complete. You can run 'fetchtastic download' to start downloading.")
+
+def is_termux():
+    return 'com.termux' in os.environ.get('PREFIX', '')
+
+def copy_to_clipboard_termux(text):
+    try:
+        subprocess.run(['termux-clipboard-set'], input=text.encode('utf-8'), check=True)
+    except Exception as e:
+        print(f"An error occurred while copying to clipboard: {e}")
+
+def install_crond():
+    try:
+        # Check if crond is installed
+        crond_path = shutil.which('crond')
+        if crond_path is None:
+            print("Installing crond...")
+            subprocess.run(['pkg', 'install', 'termux-services', '-y'], check=True)
+            subprocess.run(['sv-enable', 'crond'], check=True)
+            print("crond installed and started.")
+        else:
+            print("crond is already installed.")
+    except Exception as e:
+        print(f"An error occurred while installing crond: {e}")
+
+def setup_cron_job():
+    try:
+        # Get current crontab entries
+        result = subprocess.run(['crontab', '-l'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.returncode != 0:
+            existing_cron = ''
+        else:
+            existing_cron = result.stdout
+
+        # Check for existing cron jobs related to fetchtastic
+        if 'fetchtastic download' in existing_cron:
+            print("An existing cron job for Fetchtastic was found:")
+            print(existing_cron)
+            keep_cron = input("Do you want to keep the existing crontab entry? [y/n] (default: y): ").strip().lower() or 'y'
+            if keep_cron == 'n':
+                # Remove existing fetchtastic cron jobs
+                new_cron = '\n'.join([line for line in existing_cron.split('\n') if 'fetchtastic download' not in line])
+                # Update crontab
+                process = subprocess.Popen(['crontab', '-'], stdin=subprocess.PIPE, text=True)
+                process.communicate(input=new_cron)
+                print("Existing Fetchtastic cron job removed.")
+                # Ask if they want to add a new cron job
+                add_cron = input("Do you want to add a new crontab entry to run Fetchtastic daily at 3 AM? [y/n] (default: y): ").strip().lower() or 'y'
+                if add_cron == 'y':
+                    # Add new cron job
+                    new_cron += f"\n0 3 * * * fetchtastic download\n"
+                    # Update crontab
+                    process = subprocess.Popen(['crontab', '-'], stdin=subprocess.PIPE, text=True)
+                    process.communicate(input=new_cron)
+                    print("New cron job added.")
+                else:
+                    print("Skipping cron job installation.")
+            else:
+                print("Keeping existing crontab entry.")
+        else:
+            # No existing fetchtastic cron job
+            add_cron = input("Do you want to add a crontab entry to run Fetchtastic daily at 3 AM? [y/n] (default: y): ").strip().lower() or 'y'
+            if add_cron == 'y':
+                # Add new cron job
+                new_cron = existing_cron.strip() + f"\n0 3 * * * fetchtastic download\n"
+                # Update crontab
+                process = subprocess.Popen(['crontab', '-'], stdin=subprocess.PIPE, text=True)
+                process.communicate(input=new_cron)
+                print("Cron job added to run Fetchtastic daily at 3 AM.")
+            else:
+                print("Skipping cron job installation.")
+    except Exception as e:
+        print(f"An error occurred while setting up the cron job: {e}")
+
+def run_clean():
+    print("This will remove Fetchtastic configuration files, downloaded files, and cron job entries.")
+    confirm = input("Are you sure you want to proceed? [y/n] (default: n): ").strip().lower() or 'n'
+    if confirm != 'y':
+        print("Clean operation cancelled.")
+        return
+
+    # Remove configuration file
+    if os.path.exists(CONFIG_FILE):
+        os.remove(CONFIG_FILE)
+        print(f"Removed configuration file: {CONFIG_FILE}")
+
+    # Remove download directory
+    if os.path.exists(DEFAULT_CONFIG_DIR):
+        shutil.rmtree(DEFAULT_CONFIG_DIR)
+        print(f"Removed download directory: {DEFAULT_CONFIG_DIR}")
+
+    # Remove cron job entries
+    try:
+        # Get current crontab entries
+        result = subprocess.run(['crontab', '-l'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.returncode == 0:
+            existing_cron = result.stdout
+            # Remove existing fetchtastic cron jobs
+            new_cron = '\n'.join([line for line in existing_cron.split('\n') if 'fetchtastic download' not in line])
+            # Update crontab
+            process = subprocess.Popen(['crontab', '-'], stdin=subprocess.PIPE, text=True)
+            process.communicate(input=new_cron)
+            print("Removed Fetchtastic cron job entries.")
+    except Exception as e:
+        print(f"An error occurred while removing cron jobs: {e}")
+
+    print("Fetchtastic has been cleaned from your system.")
+    print("If you installed Fetchtastic via pip and wish to uninstall it, run 'pip uninstall fetchtastic'.")
+
+def load_config():
+    if not config_exists():
+        return None
+    with open(CONFIG_FILE, 'r') as f:
+        config = yaml.safe_load(f)
+    return config

fetchtastic-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jeremiah K
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fetchtastic-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: fetchtastic
+Version: 0.1.0
+Summary: Meshtastic Firmware and APK Downloader
+Home-page: https://github.com/jeremiah-k/fetchtastic
+Author: Jeremiah K
+Author-email: jeremiahk@gmx.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pick
+Requires-Dist: PyYAML
+Requires-Dist: urllib3
+
+# Fetchtastic Termux Setup
+
+Fetchtastic is a tool to download the latest Meshtastic Android app and Firmware releases to your phone via Termux. It also provides optional notifications via an NTFY server. This guide will help you set up and run Fetchtastic on your device.
+
+## Prerequisites
+
+### Install Termux and Add-ons
+
+1. **Install Termux**: Download and install [Termux](https://f-droid.org/en/packages/com.termux/) from F-Droid.
+2. **Install Termux Boot**: Download and install [Termux Boot](https://f-droid.org/en/packages/com.termux.boot/) from F-Droid.
+3. **Install Termux API**: Download and install [Termux API](https://f-droid.org/en/packages/com.termux.api/) from F-Droid.
+4. *(Optional)* **Install ntfy**: Download and install [ntfy](https://f-droid.org/en/packages/io.heckel.ntfy/) from F-Droid.
+
+### Request Storage Access for Termux
+
+Open Termux and run the following command to grant storage access:
+
+```bash
+termux-setup-storage
+```
+## Installation
+
+### Step 1: Install Python
+
+```bash
+pkg install python -y
+```
+
+### Step 2: Install Fetchtastic
+
+```bash
+pip install fetchtastic
+```
+
+## Usage
+
+### Run the Setup Process
+
+Run the setup command and follow the prompts to configure Fetchtastic:
+
+```bash
+fetchtastic setup
+```
+
+During setup, you will be able to:
+
+- Choose whether to download APKs, firmware, or both.
+- Select specific assets to download.
+- Set the number of versions to keep.
+- Configure automatic extraction of firmware files. (Optional)
+- Set up notifications via NTFY. (Optional)
+- Add a cron job to run Fetchtastic regularly. (Optional)
+
+### Perform Downloads
+
+To manually start the download process, run:
+
+```bash
+fetchtastic download
+```
+
+This will download the latest versions of the selected assets and store them in the specified directories.
+
+### Command list
+
+- **setup**: Run the setup process.
+- **download**: Download firmware and APKs.
+- **topic**: Display the current NTFY topic.
+- **clean**: Remove configuration, downloads, and cron jobs.
+- **--help**: Show help and usage instructions.
+
+### Files and Directories
+
+By default, Fetchtastic saves files and configuration in the `Downloads/Fetchtastic` directory:
+
+ - **Configuration File**: `Downloads/Fetchtastic/fetchtastic.yaml`
+ - **Log File**: `Downloads/Fetchtastic/fetchtastic.log`
+ - **APKs**: `Downloads/Fetchtastic/apks`
+ - **Firmware**: `Downloads/Fetchtastic/firmware`
+
+You can manually edit the configuration file to change the settings.
+
+
+### Scheduling with Cron
+
+During setup, you have the option to add a cron job that runs Fetchtastic daily at 3 AM.
+
+To modify cron job, you can run:
+```bash
+crontab -e
+```
+
+### Notifications via NTFY
+
+If you choose to set up notifications, Fetchtastic will send updates to your specified NTFY topic.
+
+### Contributing
+
+Contributions are welcome! Feel free to open issues or submit pull requests.

fetchtastic-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/cli.py,sha256=0MXDY-WKgQSg3ndFsAY9EItBfrEabvevT6Z1Ey39R0s,2065
+app/downloader.py,sha256=djXk9zkbkTr407bKDcrT9l-j3yOXRz0KZ_Unc64W6O8,11509
+app/menu_apk.py,sha256=IzMQyvFLp9_LJCbeDK09cKkrnQ5iqaCVZhdvRlpoeyg,1399
+app/menu_firmware.py,sha256=sKfgrpk-NN4mIhmNcklTBR33uHzMae8s3Y4NP-4sl_8,1376
+app/setup_config.py,sha256=QGexpQVuRKZfoh4Dy83TxHMRRico5LsyUeezwqpeBVA,12780
+fetchtastic-0.1.0.dist-info/LICENSE,sha256=spPlGh4STUWH8_Wge3VdIWSjXw8Kiroctn19wOrniMI,1067
+fetchtastic-0.1.0.dist-info/METADATA,sha256=PjjSjfUuSjRQkB7_RVHrzyD9ISTKyWNfGRtj2o--O78,3365
+fetchtastic-0.1.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+fetchtastic-0.1.0.dist-info/entry_points.txt,sha256=U_eZT-XoZI0JWwSus3520FnSoe4ux6F6BsRSJ-nuiZQ,45
+fetchtastic-0.1.0.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+fetchtastic-0.1.0.dist-info/RECORD,,

fetchtastic-0.1.0.dist-info/WHEEL

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

fetchtastic-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fetchtastic = app.cli:main

fetchtastic-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+app