esp-batch-uploader 1.0.0__tar.gz

esp_batch_uploader-1.0.0/MANIFEST.in

@@ -0,0 +1,16 @@
+# MANIFEST.in
+
+# Include the README and requirements
+include README.md
+include requirements.txt
+
+# Include the entire package source code
+recursive-include esp_batch_uploader *
+
+# Exclude unnecessary files (safety)
+exclude *.log
+exclude *.zip
+exclude *.pyc
+exclude __pycache__/
+exclude logs/
+exclude uploads/

esp_batch_uploader-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: esp-batch-uploader
+Version: 1.0.0
+Summary: Batch file uploader to ESP32 devices over HTTP with UDP discovery
+Author: Abdullah Bajwa
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Requires-Dist: aiohttp
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

esp_batch_uploader-1.0.0/README.md

@@ -0,0 +1,72 @@
+# ESP32 Batch File Uploader
+
+This tool discovers multiple ESP32 devices on the network via UDP and uploads files to them over HTTP. Each ESP32 acts as a file upload server.
+
+## Features
+
+- Automatically discovers ESP32 devices via UDP broadcast
+- Organizes devices into configurable batches
+- Uploads files to each device sequentially, but uploads to devices in parallel
+- Logs detailed and high-level status to file and console
+- Modular and extensible design
+
+## Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. ESP32 Server
+
+Each ESP32 should expose an HTTP endpoint like:
+
+```
+POST /upload/<filename>
+Body: Raw binary data
+```
+
+Respond with HTTP 200 on success.
+
+### 3. Run the Script
+
+```bash
+python -m esp_batch_uploader
+```
+
+You'll be prompted to configure:
+
+- Verbose logging
+- Batch size
+- HTTP and UDP ports
+
+The tool will:
+
+1. Discover ESP32s
+2. Split them into batches
+3. Upload files from your current working directory
+
+## Logs
+
+Two log files are generated in `./logs/`:
+- `traceback-*.txt` – Detailed logs and errors
+- `status-*.txt` – High-level status of uploads
+
+## File Structure
+
+```
+esp_batch_uploader/
+├── __main__.py
+├── config.py
+├── logger.py
+├── uploader/
+│   ├── batch_manager.py
+│   ├── discovery.py
+│   ├── upload_client.py
+│   └── upload_runner.py
+```
+
+## License
+
+MIT

esp_batch_uploader-1.0.0/esp_batch_uploader/__main__.py

@@ -0,0 +1,32 @@
+# esp_batch_uploader/__main__.py
+
+import asyncio
+from esp_batch_uploader.uploader.batch_manager import run_batches
+from esp_batch_uploader.config import parse_args
+from esp_batch_uploader.logger import setup_logger
+
+async def main():
+    args, files_dir = parse_args()
+    logger, status_logger = setup_logger(args.verbose)
+
+    logger.info("Starting ESP32 batch uploader")
+    status_logger.info("Starting ESP32 batch uploader")
+
+    try:
+        await run_batches(
+            files_dir=files_dir,
+            batch_size=args.batch_size,
+            udp_port=args.udp_port,
+            logger=logger,
+            status_logger=status_logger
+        )
+    except Exception as e:
+        logger.exception("Unexpected error during batch upload")
+        status_logger.error(f"Unexpected error: {e}")
+
+# 👇 This is the entry point for CLI installation
+def main_entry():
+    asyncio.run(main())
+
+if __name__ == "__main__":
+    main_entry()

esp_batch_uploader-1.0.0/esp_batch_uploader/config.py

@@ -0,0 +1,52 @@
+import os
+import sys
+
+def prompt_yes_no(prompt):
+    while True:
+        response = input(f"{prompt} (y/N): ").strip().lower()
+        if response == "":
+            return False  # default to 'n'
+        if response in ("y", "n"):
+            return response == "y"
+        print("Please enter 'y' or 'n'.")
+
+def prompt_int(prompt, default, min_val, max_val):
+    while True:
+        response = input(f"{prompt} [{default}]: ").strip()
+        if not response:
+            return default
+        if response.isdigit():
+            val = int(response)
+            if min_val <= val <= max_val:
+                return val
+        print(f"Please enter a number between {min_val} and {max_val}.")
+
+def prompt_port(prompt, default):
+    while True:
+        response = input(f"{prompt} [{default}]: ").strip()
+        if not response:
+            return default
+        if response.isdigit() and 1 <= int(response) <= 65535:
+            return int(response)
+        print("Please enter a valid port number (1–65535).")
+
+def parse_args():
+    files_dir = os.getcwd()  # Current working directory
+    print(f"[INFO] Serving files from: {files_dir}")
+
+    verbose = prompt_yes_no("Enable verbose logging?")
+    batch_size = prompt_int("Enter batch size", default=5, min_val=1, max_val=20)
+    http_port = prompt_port("HTTP port", default=8000)
+    udp_port = prompt_port("UDP port", default=5757)
+
+    class Args:
+        pass
+
+    args = Args()
+    args.verbose = verbose
+    args.batch_size = batch_size
+    args.http_port = http_port
+    args.udp_port = udp_port
+    args.directory = files_dir
+
+    return args, files_dir

esp_batch_uploader-1.0.0/esp_batch_uploader/logger.py

@@ -0,0 +1,30 @@
+import logging
+import datetime
+import os
+
+def setup_logger(verbose=False):
+    timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+    logs_dir = os.path.join(os.getcwd(), 'logs')
+    os.makedirs(logs_dir, exist_ok=True)
+
+    traceback_log = os.path.join(logs_dir, f"traceback-file-transfer-{timestamp}.txt")
+    status_log = os.path.join(logs_dir, f"status-file-transfer-{timestamp}.txt")
+
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
+        handlers=[
+            logging.FileHandler(traceback_log, encoding='utf-8'),
+            logging.StreamHandler()
+        ]
+    )
+
+    status_logger = logging.getLogger("StatusLogger")
+    status_handler = logging.FileHandler(status_log, encoding='utf-8')
+    status_handler.setLevel(logging.INFO)
+    status_handler.setFormatter(logging.Formatter("%(asctime)s [STATUS] %(message)s"))
+    status_logger.addHandler(status_handler)
+    status_logger.propagate = False
+    status_logger.setLevel(logging.INFO)
+
+    return logging.getLogger("ESP32BatchServer"), status_logger

esp_batch_uploader-1.0.0/esp_batch_uploader/uploader/batch_manager.py

@@ -0,0 +1,42 @@
+# esp_batch_uploader/uploader/batch_manager.py
+
+import os
+from esp_batch_uploader.uploader.discovery import discover_esp32_devices
+from esp_batch_uploader.uploader.upload_runner import upload_to_batch
+
+
+def split_batches(devices, batch_size):
+    return [devices[i:i + batch_size] for i in range(0, len(devices), batch_size)]
+
+
+async def run_batches(files_dir, batch_size, udp_port, logger, status_logger):
+    logger.info("Discovering ESP32 devices...")
+    devices = await discover_esp32_devices(udp_port)
+    if not devices:
+        logger.error("No devices found.")
+        status_logger.info("No devices found during discovery")
+        return
+
+    logger.info(f"Discovered {len(devices)} device(s): {devices}")
+    status_logger.info(f"Devices discovered: {devices}")
+
+    file_paths = [
+        os.path.join(files_dir, f)
+        for f in os.listdir(files_dir)
+        if os.path.isfile(os.path.join(files_dir, f))
+    ]
+
+    if not file_paths:
+        logger.error("No files to upload.")
+        return
+
+    batches = split_batches(devices, batch_size)
+    logger.info(f"Split into {len(batches)} batch(es) of size {batch_size}")
+
+    for i, batch in enumerate(batches, 1):
+        logger.info(f"Processing batch {i}/{len(batches)}: {batch}")
+        status_logger.info(f"Uploading to batch {i}: {batch}")
+        await upload_to_batch(batch, file_paths, logger, status_logger)
+
+    logger.info("All batches processed.")
+    status_logger.info("✅ All uploads completed")

esp_batch_uploader-1.0.0/esp_batch_uploader/uploader/discovery.py

@@ -0,0 +1,52 @@
+import asyncio
+import socket
+import logging
+
+logger = logging.getLogger("ESP32BatchServer.Discovery")
+
+class UDPProtocol(asyncio.DatagramProtocol):
+    def __init__(self, queue):
+        self.queue = queue
+
+    def datagram_received(self, data, addr):
+        ip, _ = addr
+        msg = data.decode().strip()
+        logger.debug(f"Received UDP from {ip}: {msg}")
+        self.queue.put_nowait((ip, msg))
+
+
+async def discover_esp32_devices(udp_port, timeout=5.0, http_port=8000):
+    loop = asyncio.get_running_loop()
+    queue = asyncio.Queue()
+
+    # Start UDP listener
+    transport, _ = await loop.create_datagram_endpoint(
+        lambda: UDPProtocol(queue),
+        local_addr=("0.0.0.0", udp_port)
+    )
+
+    # === Broadcast discovery message ===
+    broadcast_msg = f"SERVER:{socket.gethostbyname(socket.gethostname())}:{http_port}"
+    logger.info(f"Broadcasting: {broadcast_msg}")
+
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.sendto(broadcast_msg.encode(), ("<broadcast>", udp_port))
+
+    logger.info(f"Listening for ESP32 responses on UDP port {udp_port} for {timeout}s")
+
+    discovered = set()
+    try:
+        start = loop.time()
+        while loop.time() - start < timeout:
+            try:
+                ip, msg = await asyncio.wait_for(queue.get(), timeout=timeout - (loop.time() - start))
+                if msg.startswith("ESP32_RESPONSE"):
+                    discovered.add(ip)
+                    logger.info(f"Discovered ESP32 at {ip}")
+            except asyncio.TimeoutError:
+                break
+    finally:
+        transport.close()
+
+    return list(discovered)

esp_batch_uploader-1.0.0/esp_batch_uploader/uploader/upload_client.py

@@ -0,0 +1,51 @@
+import os
+import time
+import aiohttp
+import asyncio
+
+class UploadClient:
+    def __init__(self, ip, logger, status_logger):
+        self.ip = ip
+        self.logger = logger
+        self.status_logger = status_logger
+
+    async def upload_file(self, session, file_path, remote_name):
+        if not os.path.exists(file_path):
+            self.logger.error(f"File does not exist: {file_path}")
+            return False
+
+        url = f"http://{self.ip}/upload/{remote_name}"
+        file_size = os.path.getsize(file_path)
+
+        self.logger.info(f"Uploading to {url} ({file_size / 1024:.2f} KB)")
+        self.status_logger.info(f"Start upload {remote_name} to {self.ip}")
+
+        try:
+            start_time = time.time()
+            with open(file_path, 'rb') as f:
+                async with session.post(url, data=f) as resp:
+                    duration = time.time() - start_time
+                    if resp.status == 200:
+                        speed = file_size / duration if duration > 0 else 0
+                        self.logger.info(f"✅ Uploaded {remote_name} to {self.ip} in {duration:.2f}s ({speed/1024/1024:.2f} MB/s)")
+                        self.status_logger.info(f"✅ {self.ip} <- {remote_name} OK")
+                        return True
+                    else:
+                        text = await resp.text()
+                        self.logger.error(f"❌ Upload failed: {resp.status} - {text}")
+                        self.status_logger.info(f"❌ {self.ip} <- {remote_name} FAILED")
+                        return False
+        except Exception as e:
+            self.logger.exception(f"Upload error to {self.ip}: {e}")
+            self.status_logger.info(f"❌ {self.ip} <- {remote_name} ERROR")
+            return False
+
+    async def upload_files(self, file_paths):
+        async with aiohttp.ClientSession() as session:
+            for path in file_paths:
+                remote_name = os.path.basename(path)
+                success = await self.upload_file(session, path, remote_name)
+                if not success:
+                    self.logger.warning(f"Retrying {remote_name} to {self.ip} after failure")
+                    await asyncio.sleep(2)
+                    await self.upload_file(session, path, remote_name)

esp_batch_uploader-1.0.0/esp_batch_uploader/uploader/upload_runner.py

@@ -0,0 +1,10 @@
+import asyncio
+from esp_batch_uploader.uploader.upload_client import UploadClient
+
+async def upload_to_batch(batch_ips, file_paths, logger, status_logger):
+    tasks = []
+    for ip in batch_ips:
+        client = UploadClient(ip, logger, status_logger)
+        task = asyncio.create_task(client.upload_files(file_paths))
+        tasks.append(task)
+    await asyncio.gather(*tasks)

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: esp-batch-uploader
+Version: 1.0.0
+Summary: Batch file uploader to ESP32 devices over HTTP with UDP discovery
+Author: Abdullah Bajwa
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Requires-Dist: aiohttp
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+esp_batch_uploader/__init__.py
+esp_batch_uploader/__main__.py
+esp_batch_uploader/config.py
+esp_batch_uploader/logger.py
+esp_batch_uploader.egg-info/PKG-INFO
+esp_batch_uploader.egg-info/SOURCES.txt
+esp_batch_uploader.egg-info/dependency_links.txt
+esp_batch_uploader.egg-info/entry_points.txt
+esp_batch_uploader.egg-info/requires.txt
+esp_batch_uploader.egg-info/top_level.txt
+esp_batch_uploader/uploader/__init__.py
+esp_batch_uploader/uploader/batch_manager.py
+esp_batch_uploader/uploader/discovery.py
+esp_batch_uploader/uploader/upload_client.py
+esp_batch_uploader/uploader/upload_runner.py

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+esp-upload = esp_batch_uploader.__main__:main_entry

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

esp_batch_uploader-1.0.0/esp_batch_uploader.egg-info/top_level.txt

@@ -0,0 +1 @@
+esp_batch_uploader

esp_batch_uploader-1.0.0/requirements.txt

@@ -0,0 +1 @@
+aiohttp

esp_batch_uploader-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

esp_batch_uploader-1.0.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='esp-batch-uploader',
+    version='1.0.0',
+    description='Batch file uploader to ESP32 devices over HTTP with UDP discovery',
+    author='Abdullah Bajwa',  # Optional but good practice
+    packages=find_packages(exclude=["tests*", "examples*"]),  # Avoid packaging examples/tests
+    install_requires=[
+        'aiohttp'
+    ],
+    entry_points={
+        'console_scripts': [
+            'esp-upload = esp_batch_uploader.__main__:main_entry'
+        ],
+    },
+    python_requires='>=3.7',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'Operating System :: OS Independent',
+    ],
+)