esp-batch-uploader 1.0.0__py3-none-any.whl

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/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/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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+esp_batch_uploader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+esp_batch_uploader/__main__.py,sha256=zRoC4qGBY-SIrFcelLk51p_ZnmRTNGViMc3HIY3a-iA,939
+esp_batch_uploader/config.py,sha256=mAGATYcVsHMpKSLaEV-nkya_e_9rpUhowQA3chgUWsM,1619
+esp_batch_uploader/logger.py,sha256=ZOaQYVN6uAKGNSlloWqO2OCTXOVCrfW3VIV-HLm7LxY,1132
+esp_batch_uploader/uploader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+esp_batch_uploader/uploader/batch_manager.py,sha256=IF8RrEOC0vEceTDruAN2auv0DMFpd93x8jjAeEldvrs,1523
+esp_batch_uploader/uploader/discovery.py,sha256=L2Af2PylFAuydZbRnRFAMKO9fYDqljZS4KHm5BD3tfY,1696
+esp_batch_uploader/uploader/upload_client.py,sha256=-9DPrZS9eVT_cmQ80TWKCvCTxaGUo_7SqM8RA3-O698,2262
+esp_batch_uploader/uploader/upload_runner.py,sha256=_zpJeVqrIoLxhppITFfZyNsoVRmmH-ny3_IzZqAPXuA,381
+esp_batch_uploader-1.0.0.dist-info/METADATA,sha256=I-itsu1y_me93zNHsJwEmBejv_ogx8fs7keAPWikLr8,416
+esp_batch_uploader-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+esp_batch_uploader-1.0.0.dist-info/entry_points.txt,sha256=vfXlI_I2WrLcCX2az__iMQSSLZYhdYxhAIJwqj_1AfQ,70
+esp_batch_uploader-1.0.0.dist-info/top_level.txt,sha256=atphBgAqEAQs-qumkBOCkhfGBeq3E1paULvOqcjnbDM,19
+esp_batch_uploader-1.0.0.dist-info/RECORD,,

esp_batch_uploader-1.0.0.dist-info/WHEEL

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

esp_batch_uploader-1.0.0.dist-info/entry_points.txt

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

esp_batch_uploader-1.0.0.dist-info/top_level.txt

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