you know breezy stuff

RaspberryPI/FlashDrive/info.json

@@ -0,0 +1,4 @@
+{
+    "port": 19054,
+    "LastFMKey":""
+}

RaspberryPI/startup.py

@@ -0,0 +1,12 @@
+"""
+Assume that this file is being run at startup, and should do all the things needed
+    ()  Check USB for new mp3's
+    ()  Check USB for updated data files (api keys, ports, )
+    ()  Copy them to correct directory
+    ()  Make sure the audio device is set to the 3.5mm jack
+    ()  Run database updater if new files were found
+    ()  Run Server
+    ()  Run http module to host client
+    ()  Generate a qr code and display it somehow (maybe)
+"""
+import threading, os, shutil, 

Server/webbyBits.py

@@ -1,7 +1,7 @@
 from flask import Flask
 from flask import request
 from flask_cors import CORS
-import json,vlc,csv,threading,time,random, argparse
+import json,vlc,threading,time,random, argparse
 parser=argparse.ArgumentParser(description="Options for the Webby Bits")
 parser.add_argument('-p','--port',help="Pick a port to host on, not the same as the web (client) port",default='19054')
 porttheuserpicked=parser.parse_args().port

plan.md

@@ -0,0 +1,79 @@
+# Self Running Part
+
+To design a self-running app for your Raspberry Pi based on your requirements, here’s a step-by-step plan that you can follow. I'll guide you through the steps without giving the full solution, so you can piece it together.
+
+### Steps to Implement
+
+1. **Automating Raspberry Pi Startup Actions:**
+   - **Systemd Service**: Use `systemd` to create a service that will automatically run when the Pi starts. This can manage your app’s startup logic.
+   - **Startup Script**: Alternatively, you can create a simple shell script that runs on boot, either placed in `/etc/rc.local` or managed by `cron` with the `@reboot` directive.
+
+2. **Detect USB Flash Drive on Boot:**
+   - **Automounting USB**: Set up the Raspberry Pi to automount flash drives when plugged in. Look into editing `/etc/fstab` or using the `usbmount` package.
+   - **Checking for MP3s**: Write Python logic that checks the mounted drives for files with `.mp3` extension. Use libraries like `os` or `pathlib` to scan directories.
+
+3. **Copying MP3s to a Directory:**
+   - You can use the `shutil` library in Python to handle file copying.
+   - Ensure this logic only triggers when new files are found (so you don’t overwrite your existing directory unnecessarily).
+
+4. **Running the Database Generator:**
+   - Since you only want the database generator to run when needed, you can add a condition to check whether the MP3s were updated. For example, store a checksum or file modification time, and if there's a change, trigger the generator.
+
+5. **Running the Flask Web Server:**
+   - After copying the files and running the database generator (if needed), the script should launch your Flask web server.
+   - Flask can be run as part of your startup service as well, once the other tasks are complete.
+
+### Suggested Order of Operations
+- On boot, run your startup script.
+- Check for connected USB drives.
+- If MP3s are found, copy them to the designated folder.
+- Run the database generator only if new files are detected.
+- Launch the Flask web server.
+
+### Things to Consider:
+- **Timing**: If there’s a delay for the USB drive to mount, you might want to add a short wait period or a retry loop when checking for the flash drive.
+- **Combining Files**: You can combine the MP3-checking, copying, and database generation logic into a single Python script. Then, it can conditionally call the database generator only when new files are added, before starting the Flask server.
+
+# Raspberry Pi Image
+
+To create a distributable Raspberry Pi image of your project, here's how you can go about it:
+
+### Steps to Create a Distributable Image
+
+1. **Set Up and Configure Your Raspberry Pi:**
+   - Start with a clean installation of **Raspberry Pi OS (32-bit)** since you're testing on 32-bit devices.
+   - Install and configure your jukebox project (ensure everything works correctly on the hardware).
+   - Set up any additional packages or dependencies that your project needs.
+
+2. **Make Your Application Auto-Start:**
+   - Ensure your application (including the USB drive detection, MP3 copying, database generation, and Flask server) starts automatically on boot using `systemd` or another method like `cron` or `/etc/rc.local`.
+   - Test this setup by rebooting the Pi and checking if your application behaves as expected.
+
+3. **Install Any Required Packages:**
+   - Install any third-party libraries or software required by your Python scripts (e.g., Flask, `shutil`, `usbmount`).
+   - Use a `requirements.txt` file (if using Python’s `pip`) to track the dependencies.
+
+4. **Prepare the Image for Distribution:**
+   - Remove unnecessary files or software to make the image smaller and more efficient.
+   - Make sure all scripts, services, and permissions are set up properly for non-root users if required.
+   - Disable any development tools or services that shouldn't be included in the final image.
+
+5. **Create a Backup of Your Raspberry Pi SD Card:**
+   - **Shutdown the Pi** after everything is set up and working.
+   - Remove the SD card and connect it to your PC or Mac using an SD card reader.
+   - Use a tool like `Raspberry Pi Imager`, `Win32DiskImager` (on Windows), or `dd` (on Linux/Mac) to create a backup of your SD card. This will allow you to create an image file (`.img`).
+
+6. **Compress the Image:**
+   - Since SD card images can be large, compress the `.img` file using a tool like `gzip` or `7zip`. This will make it easier to distribute.
+
+7. **Test the Image:**
+   - Flash the `.img` file back onto a new SD card and test it on another Raspberry Pi to ensure it boots up and runs your application properly without requiring additional configuration.
+   
+8. **Distribute the Image:**
+   - Once the image works as expected, you can distribute it by uploading it to a platform like Google Drive or Dropbox, where others can download it and flash it onto their Raspberry Pis.
+   
+### Things to Keep in Mind:
+- **Image Size**: If your image is too large, users might need SD cards with more capacity. Trim down unnecessary files to reduce the size.
+- **Updates**: Consider how users will receive future updates. You could include a mechanism in your app to check for updates or distribute new versions of the image as needed.
+
+This should give you a distributable image that can be easily flashed and run on other Raspberry Pi devices!