Disable parts of add_job UI when missing critical project data instead of crashing

.github/workflows/create-executables.yml

@@ -1,38 +0,0 @@
-name: Create Executables
-            
-on:
-  workflow_dispatch:
-  release:
-    - types: [created]
-
-jobs:
-  pyinstaller-build-windows:
-    runs-on: windows-latest
-    steps:
-      - name: Create Executables (Windows)
-        uses: sayyid5416/pyinstaller@v1
-        with:
-          python_ver: '3.11'
-          spec: 'main.spec'
-          requirements: 'requirements.txt'
-          upload_exe_with_name: 'Zordon'
-  pyinstaller-build-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Create Executables (Linux)
-        uses: sayyid5416/pyinstaller@v1
-        with:
-          python_ver: '3.11'
-          spec: 'main.spec'
-          requirements: 'requirements.txt'
-          upload_exe_with_name: 'Zordon'
-  pyinstaller-build-macos:
-    runs-on: macos-latest
-    steps:
-      - name: Create Executables (macOS)
-        uses: sayyid5416/pyinstaller@v1
-        with:
-          python_ver: '3.11'
-          spec: 'main.spec'
-          requirements: 'requirements.txt'
-          upload_exe_with_name: 'Zordon'

.github/workflows/pylint.yml

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')

README.md

@@ -1,46 +1,14 @@
-![Zordon Screenshot](docs/screenshot.png)
+# 🎬 Zordon - Render Management Tools
 
----
+Welcome to Zordon! It's a local network render farm manager, aiming to streamline and simplify the rendering process across multiple home computers.
 
-# Zordon
+## 📦 Installation
 
-A lightweight, zero-install, distributed rendering and management tool designed to streamline and optimize rendering workflows across multiple machines
+Install the necessary dependencies: `pip3 install -r requirements.txt`
 
-## What is Zordon?
+## 🎨 Supported Renderers
 
-Zordon is tool designed for small render farms, such as those used in home studios or small businesses, to efficiently manage and run render jobs for Blender, FFMPEG, and other video renderers. It simplifies the process of distributing rendering tasks across multiple available machines, optimizing the rendering workflow for artists, animators, and video professionals.
+Zordon currently supports the following renderers:
-
-
-Notice: This should be considered a beta and is meant for casual / hobbiest use. Do not use in mission critical environments!
-
-## Supported Renderers
-
-Zordon supports or plans to support the following renderers:
 
 - **Blender**
 - **FFMPEG**
-- **Adobe After Effects** ([coming soon](https://github.com/blw1138/Zordon/issues/84))
-- **Cinema 4D** ([planned](https://github.com/blw1138/Zordon/issues/105))
-- **Autodesk Maya** ([planned](https://github.com/blw1138/Zordon/issues/106))
-
-## System Requirements
-
-- Windows 10 or later
-- macOS Ventura (13.0) or later
-- Linux (Supported versions TBD)
-
-## Build using Pyinstaller
-
-Zordon is regularly tested with Python 3.11 and later. It's packaged and distributed with pyinstaller. It is supported on Windows, macOS and Linux.
-
-```
-git clone https://github.com/blw1138/Zordon.git
-pip3 install -r requirements.txt
-pip3 install pyinstaller
-pip3 install pyinstaller_versionfile
-pyinstaller main.spec
-```
-
-## License
-
-Zordon is licensed under the MIT License. See the [LICENSE](LICENSE.txt) file for more details.

config/config.yaml

@@ -3,7 +3,7 @@ update_engines_on_launch: true
 max_content_path: 100000000
 server_log_level: info
 log_buffer_length: 250
-worker_process_timeout: 120
+subjob_connection_timeout: 120
 flask_log_level: error
 flask_debug_enable: false
 queue_eval_seconds: 1

dashboard.py

@@ -1,279 +0,0 @@
-#!/usr/bin/env python3
-import datetime
-import os.path
-import socket
-import threading
-import time
-import traceback
-
-from rich import box
-from rich.console import Console
-from rich.layout import Layout
-from rich.live import Live
-from rich.panel import Panel
-from rich.table import Column
-from rich.table import Table
-from rich.text import Text
-from rich.tree import Tree
-
-from src.engines.core.base_worker import RenderStatus, string_to_status
-from src.api.server_proxy import RenderServerProxy
-from src.utilities.misc_helper import get_time_elapsed
-from start_server import start_server
-
-"""
-The RenderDashboard is designed to be run on a remote machine or on the local server
-This provides a detailed status of all jobs running on the server
-"""
-
-status_colors = {RenderStatus.ERROR: "red", RenderStatus.CANCELLED: 'orange1', RenderStatus.COMPLETED: 'green',
-                 RenderStatus.NOT_STARTED: "yellow", RenderStatus.SCHEDULED: 'purple',
-                 RenderStatus.RUNNING: 'cyan'}
-
-categories = [RenderStatus.RUNNING, RenderStatus.ERROR, RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED,
-              RenderStatus.COMPLETED, RenderStatus.CANCELLED, RenderStatus.UNDEFINED]
-
-renderer_colors = {'ffmpeg': '[magenta]', 'blender': '[orange1]', 'aerender': '[purple]'}
-
-local_hostname = socket.gethostname()
-
-
-def status_string_to_color(status_string):
-    job_status = string_to_status(status_string)
-    job_color = '[{}]'.format(status_colors[job_status])
-    return job_color
-
-
-def sorted_jobs(all_jobs):
-
-    sort_by_date = True
-    if not sort_by_date:
-        sorted_job_list = []
-        if all_jobs:
-            for status_category in categories:
-                found_jobs = [x for x in all_jobs if x['status'] == status_category.value]
-                if found_jobs:
-                    sorted_found_jobs = sorted(found_jobs, key=lambda d: datetime.datetime.fromisoformat(d['date_created']), reverse=True)
-                    sorted_job_list.extend(sorted_found_jobs)
-    else:
-        sorted_job_list = sorted(all_jobs, key=lambda d: datetime.datetime.fromisoformat(d['date_created']), reverse=True)
-    return sorted_job_list
-
-
-def create_node_tree(all_server_data) -> Tree:
-    main_tree = Tree("[magenta]Server Cluster")
-
-    for server_host, server_data in all_server_data['servers'].items():
-
-        node_title_local = f"[cyan bold]{server_host}[/] [yellow](This Computer)[default]"
-        node_title_remote = f"[cyan]{server_host} [magenta](Remote)[default]"
-        node_tree_text = node_title_local if (server_host == local_hostname) else node_title_remote
-
-        if server_data.get('is_online', False):
-
-            node_tree_text = node_tree_text + " - [green]Running"
-            node_tree = Tree(node_tree_text)
-
-            stats_text = f"CPU: [yellow]{server_data['status']['cpu_percent']}% [default]| RAM: " \
-                         f"[yellow]{server_data['status']['memory_percent']}% [default]| Cores: " \
-                         f"[yellow]{server_data['status']['cpu_count']} [default]| " \
-                         f"{server_data['status']['platform'].split('-')[0]}"
-
-            node_tree.add(Tree(stats_text))
-
-            running_jobs = [job for job in server_data['jobs'] if job['status'] == RenderStatus.RUNNING.value]
-            not_started = [job for job in server_data['jobs'] if job['status'] == RenderStatus.NOT_STARTED.value]
-            scheduled = [job for job in server_data['jobs'] if job['status'] == RenderStatus.SCHEDULED.value]
-            jobs_to_display = running_jobs + not_started + scheduled
-
-            jobs_tree = Tree(f"Running: [green]{len(running_jobs)} [default]| Queued: [cyan]{len(not_started)}"
-                             f"[default] | Scheduled: [cyan]{len(scheduled)}")
-
-            for job in jobs_to_display:
-                renderer = f"{renderer_colors[job['renderer']]}{job['renderer']}[default]"
-                filename = os.path.basename(job['input_path']).split('.')[0]
-                if job['status'] == RenderStatus.RUNNING.value:
-                    jobs_tree.add(f"[bold]{renderer} {filename} ({job['id']}) - {status_string_to_color(job['status'])}{(float(job['percent_complete']) * 100):.1f}%")
-                else:
-                    jobs_tree.add(f"{filename} ({job['id']}) - {status_string_to_color(job['status'])}{job['status'].title()}")
-
-            if not jobs_to_display:
-                jobs_tree.add("[italic]No running jobs")
-
-            node_tree.add(jobs_tree)
-            main_tree.add(node_tree)
-        else:
-            # if server is offline
-            node_tree_text = node_tree_text + " - [red]Offline"
-            node_tree = Tree(node_tree_text)
-            main_tree.add(node_tree)
-    return main_tree
-
-
-def create_jobs_table(all_server_data) -> Table:
-    table = Table("ID", "Name", "Renderer", Column(header="Priority", justify="center"),
-                  Column(header="Status", justify="center"), Column(header="Time Elapsed", justify="right"),
-                  Column(header="# Frames", justify="right"), "Client", show_lines=True,
-                  box=box.HEAVY_HEAD)
-
-    all_jobs = []
-    for server_name, server_data in all_server_data['servers'].items():
-        for job in server_data['jobs']:
-            #todo: clean this up
-            all_jobs.append(job)
-
-    all_jobs = sorted_jobs(all_jobs)
-
-    for job in all_jobs:
-
-        job_status = string_to_status(job['status'])
-        job_color = '[{}]'.format(status_colors[job_status])
-        job_text = f"{job_color}" + job_status.value.title()
-
-        if job_status == RenderStatus.ERROR and job['errors']:
-            job_text = job_text + "\n" + "\n".join(job['errors'])
-
-        # Project name
-        project_name = job_color + (job['name'] or os.path.basename(job['input_path']))
-        elapsed_time = get_time_elapsed(datetime.datetime.fromisoformat(job['start_time']),
-                                        datetime.datetime.fromisoformat(job['end_time']))
-
-        if job_status == RenderStatus.RUNNING:
-            job_text = f"{job_color}[bold]Running - {float(job['percent_complete']) * 100:.1f}%"
-            elapsed_time = "[bold]" + elapsed_time
-            project_name = "[bold]" + project_name
-        elif job_status == RenderStatus.CANCELLED or job_status == RenderStatus.ERROR:
-            project_name = "[strike]" + project_name
-
-        # Priority
-        priority_color = ["red", "yellow", "cyan"][(job['priority'] - 1)]
-
-        client_name = job['client'] or 'unknown'
-        client_colors = {'unknown': '[red]', local_hostname: '[yellow]'}
-        client_title = client_colors.get(client_name, '[magenta]') + client_name
-
-        table.add_row(
-            job['id'],
-            project_name,
-            renderer_colors.get(job['renderer'], '[cyan]') + job['renderer'] + '[default]-' + job['renderer_version'],
-            f"[{priority_color}]{job['priority']}",
-            job_text,
-            elapsed_time,
-            str(max(int(job['total_frames']), 1)),
-            client_title
-        )
-
-    return table
-
-
-def create_status_panel(all_server_data):
-    for key, value in all_server_data['servers'].items():
-        if key == local_hostname:
-            return str(value['status'])
-    return "no status"
-
-
-class KeyboardThread(threading.Thread):
-
-    def __init__(self, input_cbk = None, name='keyboard-input-thread'):
-        self.input_cbk = input_cbk
-        super(KeyboardThread, self).__init__(name=name)
-        self.start()
-
-    def run(self):
-        while True:
-            self.input_cbk(input()) #waits to get input + Return
-
-
-def my_callback(inp):
-    #evaluate the keyboard input
-    print('You Entered:', inp)
-
-
-if __name__ == '__main__':
-
-    get_server_ip = input("Enter server IP or None for local: ") or local_hostname
-
-    server_proxy = RenderServerProxy(get_server_ip, "8080")
-
-    if not server_proxy.connect():
-        if server_proxy.hostname == local_hostname:
-            start_server_input = input("Local server not running. Start server? (y/n) ")
-            if start_server_input and start_server_input[0].lower() == "y":
-                # Startup the local server
-                start_server()
-                test = server_proxy.connect()
-                print(f"connected? {test}")
-        else:
-            print(f"\nUnable to connect to server: {server_proxy.hostname}")
-            print("\nVerify IP address is correct and server is running")
-            exit(1)
-
-    # start the Keyboard thread
-    # kthread = KeyboardThread(my_callback)
-
-    # Console Layout
-    console = Console()
-    layout = Layout()
-
-    # Divide the "screen" in to three parts
-    layout.split(
-        Layout(name="header", size=3),
-        Layout(ratio=1, name="main")
-        # Layout(size=10, name="footer"),
-    )
-    # Divide the "main" layout in to "side" and "body"
-    layout["main"].split_row(
-        Layout(name="side"),
-        Layout(name="body",
-               ratio=3))
-    # Divide the "side" layout in to two
-    layout["side"].split(Layout(name="side_top"), Layout(name="side_bottom"))
-
-    # Server connection header
-    header_text = Text(f"Connected to server: ")
-    header_text.append(f"{server_proxy.hostname} ", style="green")
-    if server_proxy.hostname == local_hostname:
-        header_text.append("(This Computer)", style="yellow")
-    else:
-        header_text.append("(Remote)", style="magenta")
-
-    # background process to update server data independent of the UI
-    def fetch_server_data(server):
-        while True:
-            fetched_data = server.get_data(timeout=5)
-            if fetched_data:
-                server.fetched_status_data = fetched_data
-            time.sleep(1)
-
-    x = threading.Thread(target=fetch_server_data, args=(server_proxy,))
-    x.daemon = True
-    x.start()
-
-    # draw and update the UI
-    with Live(console=console, screen=False, refresh_per_second=1, transient=True) as live:
-        while True:
-            try:
-                if server_proxy.fetched_status_data:
-
-                    server_online = False
-                    if server_proxy.fetched_status_data.get('timestamp', None):
-                        timestamp = datetime.datetime.fromisoformat(server_proxy.fetched_status_data['timestamp'])
-                        time_diff = datetime.datetime.now() - timestamp
-                        server_online = time_diff.seconds < 10  # client is offline if not updated in certain time
-
-                    layout["body"].update(create_jobs_table(server_proxy.fetched_status_data))
-                    layout["side_top"].update(Panel(create_node_tree(server_proxy.fetched_status_data)))
-                    layout["side_bottom"].update(Panel(create_status_panel(server_proxy.fetched_status_data)))
-
-                    online_text = "Online" if server_online else "Offline"
-                    online_color = "green" if server_online else "red"
-                    layout["header"].update(Panel(Text(f"Zordon Render Client - Version 0.0.1 alpha - {online_text}",
-                                                       justify="center", style=online_color)))
-                    live.update(layout, refresh=False)
-            except Exception as e:
-                print(f"Exception updating table: {e}")
-                traceback.print_exception(e)
-            time.sleep(1)
-    #     #     # todo: Add input prompt to manage running jobs (ie add, cancel, get info, etc)
-

main.spec

@@ -1,121 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-
-from PyInstaller.utils.hooks import collect_all
-
-# - get version from version file
-import os
-import sys
-import platform
-src_path = os.path.abspath("src")
-sys.path.insert(0, src_path)
-from version import APP_NAME, APP_VERSION, APP_AUTHOR
-sys.path.insert(0, os.path.abspath('.'))
-
-datas = [('resources', 'resources'), ('src/engines/blender/scripts/', 'src/engines/blender/scripts')]
-binaries = []
-hiddenimports = ['zeroconf']
-tmp_ret = collect_all('zeroconf')
-datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
-
-
-a = Analysis(
-    ['main.py'],
-    pathex=[],
-    binaries=binaries,
-    datas=datas,
-    hiddenimports=hiddenimports,
-    hookspath=[],
-    hooksconfig={},
-    runtime_hooks=[],
-    excludes=[],
-    noarchive=False,
-    optimize=1,  # fyi: optim level 2 breaks on windows
-)
-pyz = PYZ(a.pure)
-
-if platform.system() == 'Darwin':  # macOS
-
-    exe = EXE(
-        pyz,
-        a.scripts,
-        [],
-        exclude_binaries=True,
-        name=APP_NAME,
-        debug=False,
-        bootloader_ignore_signals=False,
-        strip=True,
-        upx=True,
-        console=False,
-        disable_windowed_traceback=False,
-        argv_emulation=False,
-        target_arch=None,
-        codesign_identity=None,
-        entitlements_file=None,
-    )
-    app = BUNDLE(
-        exe,
-        a.binaries,
-        a.datas,
-        strip=True,
-        name=f'{APP_NAME}.app',
-        icon='resources/Server.png',
-        bundle_identifier=None,
-        version=APP_VERSION
-    )
-
-elif platform.system() == 'Windows':
-
-    import pyinstaller_versionfile
-    import tempfile
-
-    version_file_path = os.path.join(tempfile.gettempdir(), 'versionfile.txt')
-
-    pyinstaller_versionfile.create_versionfile(
-        output_file=version_file_path,
-        version=APP_VERSION,
-        company_name=APP_AUTHOR,
-        file_description=APP_NAME,
-        internal_name=APP_NAME,
-        legal_copyright=f"© {APP_AUTHOR}",
-        original_filename=f"{APP_NAME}.exe",
-        product_name=APP_NAME
-    )
-
-    exe = EXE(
-        pyz,
-        a.scripts,
-        a.binaries,
-        a.datas,
-        [],
-        name=APP_NAME,
-        debug=False,
-        bootloader_ignore_signals=False,
-        strip=True,
-        upx=True,
-        console=False,
-        disable_windowed_traceback=False,
-        argv_emulation=False,
-        target_arch=None,
-        codesign_identity=None,
-        entitlements_file=None,
-        version=version_file_path
-    )
-
-else:  # linux
-    exe = EXE(
-        pyz,
-        a.scripts,
-        a.binaries,
-        a.datas,
-        [],
-        name=APP_NAME,
-        debug=False,
-        bootloader_ignore_signals=False,
-        strip=True,
-        upx=True,
-        console=False,
-        disable_windowed_traceback=False,
-        argv_emulation=False,
-        target_arch=None,
-        codesign_identity=None,
-        entitlements_file=None
-    )

requirements.txt

@@ -35,7 +35,3 @@ attrs>=23.2.0
 lxml>=5.1.0
 click>=8.1.7
 requests_toolbelt>=1.0.0
-pyinstaller_versionfile>=2.1.1
-py-cpuinfo~=9.0.0
-requests-toolbelt~=1.0.0
-ifaddr~=0.2.0

server.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from src.init import run
+from src.api.api_server import start_server
 
 if __name__ == '__main__':
-    run(server_only=True)
+    start_server()

setup.py

@@ -0,0 +1,28 @@
+"""
+This is a setup.py script generated by py2applet
+
+Usage:
+    python setup.py py2app
+"""
+import glob
+
+from setuptools import setup
+
+APP = ['main.py']
+DATA_FILES = [('config', glob.glob('config/*.*')),
+              ('resources', glob.glob('resources/*.*'))]
+OPTIONS = {
+    'excludes': ['PySide6'],
+    'includes': ['zeroconf', 'zeroconf._services.info'],
+    'plist': {
+        'LSMinimumSystemVersion': '10.15',  # Specify minimum macOS version
+    },
+}
+
+setup(
+    app=APP,
+    data_files=DATA_FILES,
+    options={'py2app': OPTIONS},
+    setup_requires=['py2app'],
+    name='Zordon'
+)

src/api/add_job_helpers.py

@@ -49,11 +49,12 @@ def handle_uploaded_project_files(request, jobs_list, upload_directory):
             raise ValueError(f"Error downloading file from URL: {project_url}")
     elif local_path and os.path.exists(local_path):
         referred_name = os.path.basename(local_path)
+
     else:
         raise ValueError("Cannot find any valid project paths")
 
     # Prepare the local filepath
-    cleaned_path_name = jobs_list[0].get('name', os.path.splitext(referred_name)[0]).replace(' ', '-')
+    cleaned_path_name = os.path.splitext(referred_name)[0].replace(' ', '_')
     job_dir = os.path.join(upload_directory, '-'.join(
         [datetime.now().strftime("%Y.%m.%d_%H.%M.%S"), renderer, cleaned_path_name]))
     os.makedirs(job_dir, exist_ok=True)

src/api/api_server.py

@@ -2,88 +2,72 @@
 import concurrent.futures
 import json
 import logging
+import multiprocessing
 import os
 import pathlib
 import shutil
 import socket
 import ssl
 import tempfile
+import threading
 import time
 from datetime import datetime
+from zipfile import ZipFile
 
-import cpuinfo
 import psutil
 import yaml
-from flask import Flask, request, send_file, after_this_request, Response, redirect, url_for
+from flask import Flask, request, send_file, after_this_request, Response, redirect, url_for, abort
-from sqlalchemy.orm.exc import DetachedInstanceError
 
 from src.api.add_job_helpers import handle_uploaded_project_files, process_zipped_project
-from src.api.preview_manager import PreviewManager
+from src.api.serverproxy_manager import ServerProxyManager
 from src.distributed_job_manager import DistributedJobManager
+from src.engines.core.base_worker import string_to_status, RenderStatus
 from src.engines.engine_manager import EngineManager
 from src.render_queue import RenderQueue, JobNotFoundError
 from src.utilities.config import Config
 from src.utilities.misc_helper import system_safe_path, current_system_os, current_system_cpu, \
     current_system_os_version, num_to_alphanumeric
-from src.utilities.status_utils import string_to_status
+from src.utilities.server_helper import generate_thumbnail_for_job
-from src.version import APP_VERSION
+from src.utilities.zeroconf_server import ZeroconfServer
+from src.utilities.benchmark import cpu_benchmark, disk_io_benchmark
 
 logger = logging.getLogger()
 server = Flask(__name__)
 ssl._create_default_https_context = ssl._create_unverified_context  # disable SSL for downloads
 
-API_VERSION = "1"
+categories = [RenderStatus.RUNNING, RenderStatus.ERROR, RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED,
-
+              RenderStatus.COMPLETED, RenderStatus.CANCELLED]
-def start_server(hostname=None):
-
-    # get hostname
-    if not hostname:
-        local_hostname = socket.gethostname()
-        hostname = local_hostname + (".local" if not local_hostname.endswith(".local") else "")
-
-    # load flask settings
-    server.config['HOSTNAME'] = hostname
-    server.config['PORT'] = int(Config.port_number)
-    server.config['UPLOAD_FOLDER'] = system_safe_path(os.path.expanduser(Config.upload_folder))
-    server.config['MAX_CONTENT_PATH'] = Config.max_content_path
-    server.config['enable_split_jobs'] = Config.enable_split_jobs
-
-    # disable most Flask logging
-    flask_log = logging.getLogger('werkzeug')
-    flask_log.setLevel(Config.flask_log_level.upper())
-
-    logger.debug('Starting API server')
-    try:
-        server.run(host=hostname, port=server.config['PORT'], debug=Config.flask_debug_enable, use_reloader=False,
-                   threaded=True)
-    finally:
-        logger.debug('Stopping API server')
 
 
-# --------------------------------------------
+def sorted_jobs(all_jobs, sort_by_date=True):
-# Get All Jobs
+    if not sort_by_date:
-# --------------------------------------------
+        sorted_job_list = []
+        if all_jobs:
+            for status_category in categories:
+                found_jobs = [x for x in all_jobs if x.status == status_category.value]
+                if found_jobs:
+                    sorted_found_jobs = sorted(found_jobs, key=lambda d: d.date_created, reverse=True)
+                    sorted_job_list.extend(sorted_found_jobs)
+    else:
+        sorted_job_list = sorted(all_jobs, key=lambda d: d.date_created, reverse=True)
+    return sorted_job_list
+
 
 @server.get('/api/jobs')
 def jobs_json():
-    """Retrieves all jobs from the render queue in JSON format.
+    try:
-
-    This endpoint fetches all jobs currently in the render queue, converts them to JSON format,
-    and returns them along with a cache token that represents the current state of the job list.
-
-    Returns:
-        dict: A dictionary containing:
-            - 'jobs' (list[dict]): A list of job dictionaries, each representing a job in the queue.
-            - 'token' (str): A cache token generated from the hash of the job list.
-    """
         all_jobs = [x.json() for x in RenderQueue.all_jobs()]
         job_cache_int = int(json.dumps(all_jobs).__hash__())
         job_cache_token = num_to_alphanumeric(job_cache_int)
         return {'jobs': all_jobs, 'token': job_cache_token}
+    except Exception as e:
+        logger.exception(f"Exception fetching jobs_json: {e}")
+    return {}, 500
 
 
 @server.get('/api/jobs_long_poll')
 def long_polling_jobs():
+    try:
         hash_token = request.args.get('token', None)
         start_time = time.time()
         while True:
@@ -94,6 +78,62 @@ def long_polling_jobs():
             if time.time() - start_time > 30:
                 return {}, 204
             time.sleep(1)
+    except Exception as e:
+        logger.exception(f"Exception fetching long_polling_jobs: {e}")
+    return {}, 500
+
+
+@server.route('/api/job/<job_id>/thumbnail')
+def job_thumbnail(job_id):
+    big_thumb = request.args.get('size', False) == "big"
+    video_ok = request.args.get('video_ok', False)
+    found_job = RenderQueue.job_with_id(job_id, none_ok=True)
+    if found_job:
+
+        os.makedirs(server.config['THUMBS_FOLDER'], exist_ok=True)
+        thumb_video_path = os.path.join(server.config['THUMBS_FOLDER'], found_job.id + '.mp4')
+        thumb_image_path = os.path.join(server.config['THUMBS_FOLDER'], found_job.id + '.jpg')
+        big_video_path = os.path.join(server.config['THUMBS_FOLDER'], found_job.id + '_big.mp4')
+        big_image_path = os.path.join(server.config['THUMBS_FOLDER'], found_job.id + '_big.jpg')
+
+        # generate regular thumb if it doesn't exist
+        if not os.path.exists(thumb_video_path) and not os.path.exists(thumb_video_path + '_IN-PROGRESS') and \
+                found_job.status not in [RenderStatus.CANCELLED, RenderStatus.ERROR]:
+            generate_thumbnail_for_job(found_job, thumb_video_path, thumb_image_path, max_width=240)
+
+        # generate big thumb if it doesn't exist
+        if not os.path.exists(big_video_path) and not os.path.exists(big_image_path + '_IN-PROGRESS') and \
+                found_job.status not in [RenderStatus.CANCELLED, RenderStatus.ERROR]:
+            generate_thumbnail_for_job(found_job, big_video_path, big_image_path, max_width=800)
+
+        # generated videos
+        if video_ok:
+            if big_thumb and os.path.exists(big_video_path) and not os.path.exists(
+                    big_video_path + '_IN-PROGRESS'):
+                return send_file(big_video_path, mimetype="video/mp4")
+            elif os.path.exists(thumb_video_path) and not os.path.exists(thumb_video_path + '_IN-PROGRESS'):
+                return send_file(thumb_video_path, mimetype="video/mp4")
+
+        # Generated thumbs
+        if big_thumb and os.path.exists(big_image_path):
+            return send_file(big_image_path, mimetype='image/jpeg')
+        elif os.path.exists(thumb_image_path):
+            return send_file(thumb_image_path, mimetype='image/jpeg')
+
+        return found_job.status.value, 200
+    return found_job.status.value, 404
+
+
+# Get job file routing
+@server.route('/api/job/<job_id>/file/<filename>', methods=['GET'])
+def get_job_file(job_id, filename):
+    found_job = RenderQueue.job_with_id(job_id)
+    try:
+        for full_path in found_job.file_list():
+            if filename in full_path:
+                return send_file(path_or_file=full_path)
+    except FileNotFoundError:
+        abort(404)
 
 
 @server.get('/api/jobs/<status_val>')
@@ -106,33 +146,29 @@ def filtered_jobs_json(status_val):
         return f'Cannot find jobs with status {status_val}', 400
 
 
-# --------------------------------------------
+@server.post('/api/job/<job_id>/notify_parent_of_status_change')
-# Job Details / File Handling
+def subjob_status_change(job_id):
-# --------------------------------------------
+    try:
+        subjob_details = request.json
+        logger.info(f"Subjob to job id: {job_id} is now {subjob_details['status']}")
+        DistributedJobManager.handle_subjob_status_change(RenderQueue.job_with_id(job_id), subjob_data=subjob_details)
+        return Response(status=200)
+    except JobNotFoundError:
+        return "Job not found", 404
+
+
+@server.errorhandler(JobNotFoundError)
+def handle_job_not_found(job_error):
+    return f'Cannot find job with ID {job_error.job_id}', 400
+
 
 @server.get('/api/job/<job_id>')
-def get_job_details(job_id):
+def get_job_status(job_id):
-    """Retrieves the details of a requested job in JSON format
-
-    Args:
-        job_id (str): The ID of the render job.
-
-    Returns:
-        dict: A JSON representation of the job's details.
-    """
     return RenderQueue.job_with_id(job_id).json()
 
 
 @server.get('/api/job/<job_id>/logs')
 def get_job_logs(job_id):
-    """Retrieves the log file for a specific render job.
-
-    Args:
-        job_id (str): The ID of the render job.
-
-    Returns:
-        Response: The log file's content as plain text, or an empty response if the log file is not found.
-    """
     found_job = RenderQueue.job_with_id(job_id)
     log_path = system_safe_path(found_job.log_path())
     log_data = None
@@ -144,26 +180,11 @@ def get_job_logs(job_id):
 
 @server.get('/api/job/<job_id>/file_list')
 def get_file_list(job_id):
-    return [os.path.basename(x) for x in RenderQueue.job_with_id(job_id).file_list()]
+    return RenderQueue.job_with_id(job_id).file_list()
-
-
-@server.route('/api/job/<job_id>/download')
-def download_requested_file(job_id):
-
-    requested_filename = request.args.get('filename')
-    if not requested_filename:
-        return 'Filename required', 400
-
-    found_job = RenderQueue.job_with_id(job_id)
-    for job_filename in found_job.file_list():
-        if os.path.basename(job_filename).lower() == requested_filename.lower():
-            return send_file(job_filename, as_attachment=True, )
-
-    return f"File '{requested_filename}' not found", 404
 
 
 @server.route('/api/job/<job_id>/download_all')
-def download_all_files(job_id):
+def download_all(job_id):
     zip_filename = None
 
     @after_this_request
@@ -178,7 +199,6 @@ def download_all_files(job_id):
     found_job = RenderQueue.job_with_id(job_id)
     output_dir = os.path.dirname(found_job.output_path)
     if os.path.exists(output_dir):
-        from zipfile import ZipFile
         zip_filename = system_safe_path(os.path.join(tempfile.gettempdir(),
                                                      pathlib.Path(found_job.input_path).stem + '.zip'))
         with ZipFile(zip_filename, 'w') as zipObj:
@@ -190,10 +210,6 @@ def download_all_files(job_id):
         return f'Cannot find project files for job {job_id}', 500
 
 
-# --------------------------------------------
-# System Environment / Status
-# --------------------------------------------
-
 @server.get('/api/presets')
 def presets():
     presets_path = system_safe_path('config/presets.yaml')
@@ -225,31 +241,13 @@ def snapshot():
     return server_data
 
 
-@server.route('/api/status')
+@server.get('/api/_detected_clients')
-def status():
+def detected_clients():
-    return {"timestamp": datetime.now().isoformat(),
+    # todo: dev/debug only. Should not ship this - probably.
-            "system_os": current_system_os(),
+    return ZeroconfServer.found_hostnames()
-            "system_os_version": current_system_os_version(),
-            "system_cpu": current_system_cpu(),
-            "system_cpu_brand": cpuinfo.get_cpu_info()['brand_raw'],
-            "cpu_percent": psutil.cpu_percent(percpu=False),
-            "cpu_percent_per_cpu": psutil.cpu_percent(percpu=True),
-            "cpu_count": psutil.cpu_count(logical=False),
-            "memory_total": psutil.virtual_memory().total,
-            "memory_available": psutil.virtual_memory().available,
-            "memory_percent": psutil.virtual_memory().percent,
-            "job_counts": RenderQueue.job_counts(),
-            "hostname": server.config['HOSTNAME'],
-            "port": server.config['PORT'],
-            "app_version": APP_VERSION,
-            "api_version": API_VERSION
-            }
 
 
-# --------------------------------------------
+# New version
-# Job Lifecyle (Create, Cancel, Delete)
-# --------------------------------------------
-
 @server.post('/api/add_job')
 def add_job_handler():
     # Process request data
@@ -303,84 +301,104 @@ def delete_job(job_id):
 
         # Check if we can remove the 'output' directory
         found_job = RenderQueue.job_with_id(job_id)
-        project_dir = os.path.dirname(os.path.dirname(found_job.input_path))
         output_dir = os.path.dirname(found_job.output_path)
-        found_job.stop()
-
-        try:
-            PreviewManager.delete_previews_for_job(found_job)
-        except Exception as e:
-            logger.error(f"Error deleting previews for {found_job}: {e}")
-
-        # finally delete the job
-        RenderQueue.delete_job(found_job)
-
-        # delete the output_dir
         if server.config['UPLOAD_FOLDER'] in output_dir and os.path.exists(output_dir):
             shutil.rmtree(output_dir)
 
-        # See if we own the project_dir (i.e. was it uploaded) - if so delete the directory
+        # Remove any thumbnails
-        try:
+        for filename in os.listdir(server.config['THUMBS_FOLDER']):
+            if job_id in filename:
+                os.remove(os.path.join(server.config['THUMBS_FOLDER'], filename))
+
+        thumb_path = os.path.join(server.config['THUMBS_FOLDER'], found_job.id + '.mp4')
+        if os.path.exists(thumb_path):
+            os.remove(thumb_path)
+
+        # See if we own the project_dir (i.e. was it uploaded)
+        project_dir = os.path.dirname(os.path.dirname(found_job.input_path))
         if server.config['UPLOAD_FOLDER'] in project_dir and os.path.exists(project_dir):
             # check to see if any other projects are sharing the same project file
             project_dir_files = [f for f in os.listdir(project_dir) if not f.startswith('.')]
             if len(project_dir_files) == 0 or (len(project_dir_files) == 1 and 'source' in project_dir_files[0]):
                 logger.info(f"Removing project directory: {project_dir}")
                 shutil.rmtree(project_dir)
-        except Exception as e:
-            logger.error(f"Error removing project files: {e}")
 
+        RenderQueue.delete_job(found_job)
+        if request.args.get('redirect', False):
+            return redirect(url_for('index'))
+        else:
             return "Job deleted", 200
+
     except Exception as e:
         logger.error(f"Error deleting job: {e}")
         return f"Error deleting job: {e}", 500
 
 
-# --------------------------------------------
+@server.get('/api/clear_history')
-# Engine Info and Management:
+def clear_history():
-# --------------------------------------------
+    RenderQueue.clear_history()
+    return 'success'
+
+
+@server.route('/api/status')
+def status():
+
+    # Get system info
+    return {"timestamp": datetime.now().isoformat(),
+            "system_os": current_system_os(),
+            "system_os_version": current_system_os_version(),
+            "system_cpu": current_system_cpu(),
+            "cpu_percent": psutil.cpu_percent(percpu=False),
+            "cpu_percent_per_cpu": psutil.cpu_percent(percpu=True),
+            "cpu_count": psutil.cpu_count(logical=False),
+            "memory_total": psutil.virtual_memory().total,
+            "memory_available": psutil.virtual_memory().available,
+            "memory_percent": psutil.virtual_memory().percent,
+            "job_counts": RenderQueue.job_counts(),
+            "hostname": server.config['HOSTNAME'],
+            "port": server.config['PORT']
+            }
+
 
 @server.get('/api/renderer_info')
 def renderer_info():
+
     response_type = request.args.get('response_type', 'standard')
-    if response_type not in ['full', 'standard']:
-        raise ValueError(f"Invalid response_type: {response_type}")
 
     def process_engine(engine):
         try:
             # Get all installed versions of the engine
             installed_versions = EngineManager.all_versions_for_engine(engine.name())
-            if not installed_versions:
+            if installed_versions:
-                return None
+                # Use system-installed versions to avoid permission issues
-
+                system_installed_versions = [x for x in installed_versions if x['type'] == 'system']
-            system_installed_versions = [v for v in installed_versions if v['type'] == 'system']
+                install_path = system_installed_versions[0]['path'] if system_installed_versions else \
-            install_path = system_installed_versions[0]['path'] if system_installed_versions else installed_versions[0]['path']
+                installed_versions[0]['path']
 
                 en = engine(install_path)
-            engine_name = en.name()
+
-            result = {
+                if response_type == 'full':  # Full dataset - Can be slow
-                engine_name: {
+                    return {
-                    'is_available': RenderQueue.is_available_for_job(engine_name),
+                        en.name(): {
-                    'versions': installed_versions
+                            'is_available': RenderQueue.is_available_for_job(en.name()),
+                            'versions': installed_versions,
+                            'supported_extensions': engine.supported_extensions(),
+                            'supported_export_formats': en.get_output_formats(),
+                            'system_info': en.system_info()
                         }
                     }
-
+                elif response_type == 'standard':  # Simpler dataset to reduce response times
-            if response_type == 'full':
+                    return {
-                with concurrent.futures.ThreadPoolExecutor() as executor:
+                        en.name(): {
-                    future_results = {
+                            'is_available': RenderQueue.is_available_for_job(en.name()),
-                        'supported_extensions': executor.submit(en.supported_extensions),
+                            'versions': installed_versions,
-                        'supported_export_formats': executor.submit(en.get_output_formats),
-                        'system_info': executor.submit(en.system_info)
                         }
-
+                    }
-                    for key, future in future_results.items():
+                else:
-                        result[engine_name][key] = future.result()
+                    raise AttributeError(f"Invalid response_type: {response_type}")
-
-            return result
-
         except Exception as e:
             logger.error(f'Error fetching details for {engine.name()} renderer: {e}')
-            raise e
+            return {}
 
     renderer_data = {}
     with concurrent.futures.ThreadPoolExecutor() as executor:
@@ -445,6 +463,7 @@ def delete_engine_download():
 @server.get('/api/renderer/<renderer>/args')
 def get_renderer_args(renderer):
     try:
+        # todo: possibly deprecate
         renderer_engine_class = EngineManager.engine_with_name(renderer)
         return renderer_engine_class().get_arguments()
     except LookupError:
@@ -460,95 +479,71 @@ def get_renderer_help(renderer):
         return f"Cannot find renderer '{renderer}'", 400
 
 
-# --------------------------------------------
-# Miscellaneous:
-# --------------------------------------------
-@server.post('/api/job/<job_id>/send_subjob_update_notification')
-def subjob_update_notification(job_id):
-    subjob_details = request.json
-    DistributedJobManager.handle_subjob_update_notification(RenderQueue.job_with_id(job_id), subjob_data=subjob_details)
-    return Response(status=200)
-
-
-@server.route('/api/job/<job_id>/thumbnail')
-def job_thumbnail(job_id):
-
-    try:
-        big_thumb = request.args.get('size', False) == "big"
-        video_ok = request.args.get('video_ok', False)
-        found_job = RenderQueue.job_with_id(job_id, none_ok=False)
-
-        # trigger a thumbnail update - just in case
-        PreviewManager.update_previews_for_job(found_job, wait_until_completion=True, timeout=60)
-        previews = PreviewManager.get_previews_for_job(found_job)
-        all_previews_list = previews.get('output', previews.get('input', []))
-
-        video_previews = [x for x in all_previews_list if x['kind'] == 'video']
-        image_previews = [x for x in all_previews_list if x['kind'] == 'image']
-        filtered_list = video_previews if video_previews and video_ok else image_previews
-
-        # todo - sort by size or other metrics here
-        if filtered_list:
-            preview_to_send = filtered_list[0]
-            mime_types = {'image': 'image/jpeg', 'video': 'video/mp4'}
-            file_mime_type = mime_types.get(preview_to_send['kind'], 'unknown')
-            return send_file(preview_to_send['filename'], mimetype=file_mime_type)
-    except Exception as e:
-        logger.error(f'Error getting thumbnail: {e}')
-        return f'Error getting thumbnail: {e}', 500
-    return "No thumbnail available", 404
-
-
-# --------------------------------------------
-# System Benchmarks:
-# --------------------------------------------
-
 @server.get('/api/cpu_benchmark')
 def get_cpu_benchmark_score():
-    from src.utilities.benchmark import cpu_benchmark
     return str(cpu_benchmark(10))
 
 
 @server.get('/api/disk_benchmark')
 def get_disk_benchmark():
-    from src.utilities.benchmark import disk_io_benchmark
     results = disk_io_benchmark()
     return {'write_speed': results[0], 'read_speed': results[-1]}
 
 
-# --------------------------------------------
+def start_server():
-# Error Handlers:
+    def eval_loop(delay_sec=1):
-# --------------------------------------------
+        while True:
+            RenderQueue.evaluate_queue()
+            time.sleep(delay_sec)
 
-@server.errorhandler(JobNotFoundError)
+    # get hostname
-def handle_job_not_found(job_error):
+    local_hostname = socket.gethostname()
-    return str(job_error), 400
+    local_hostname = local_hostname + (".local" if not local_hostname.endswith(".local") else "")
 
+    # load flask settings
+    server.config['HOSTNAME'] = local_hostname
+    server.config['PORT'] = int(Config.port_number)
+    server.config['UPLOAD_FOLDER'] = system_safe_path(os.path.expanduser(Config.upload_folder))
+    server.config['THUMBS_FOLDER'] = system_safe_path(os.path.join(os.path.expanduser(Config.upload_folder), 'thumbs'))
+    server.config['MAX_CONTENT_PATH'] = Config.max_content_path
+    server.config['enable_split_jobs'] = Config.enable_split_jobs
 
-@server.errorhandler(DetachedInstanceError)
+    # Setup directory for saving engines to
-def handle_detached_instance(_):
+    EngineManager.engines_path = system_safe_path(os.path.join(os.path.join(os.path.expanduser(Config.upload_folder),
-    return "Unavailable", 503
+                                                                            'engines')))
+    os.makedirs(EngineManager.engines_path, exist_ok=True)
 
+    # Debug info
+    logger.debug(f"Upload directory: {server.config['UPLOAD_FOLDER']}")
+    logger.debug(f"Thumbs directory: {server.config['THUMBS_FOLDER']}")
+    logger.debug(f"Engines directory: {EngineManager.engines_path}")
 
-@server.errorhandler(Exception)
+    # disable most Flask logging
-def handle_general_error(general_error):
+    flask_log = logging.getLogger('werkzeug')
-    err_msg = f"Server error: {general_error}"
+    flask_log.setLevel(Config.flask_log_level.upper())
-    logger.error(err_msg)
-    return err_msg, 500
 
+    # check for updates for render engines if configured or on first launch
+    if Config.update_engines_on_launch or not EngineManager.get_engines():
+        EngineManager.update_all_engines()
 
-# --------------------------------------------
+    # Set up the RenderQueue object
-# Debug / Development Only:
+    RenderQueue.load_state(database_directory=server.config['UPLOAD_FOLDER'])
-# --------------------------------------------
+    ServerProxyManager.subscribe_to_listener()
+    DistributedJobManager.subscribe_to_listener()
 
-@server.get('/api/_debug/detected_clients')
+    thread = threading.Thread(target=eval_loop, kwargs={'delay_sec': Config.queue_eval_seconds}, daemon=True)
-def detected_clients():
+    thread.start()
-    # todo: dev/debug only. Should not ship this - probably.
-    from src.utilities.zeroconf_server import ZeroconfServer
-    return ZeroconfServer.found_hostnames()
 
+    logger.info(f"Starting Zordon Render Server - Hostname: '{server.config['HOSTNAME']}:'")
+    ZeroconfServer.configure("_zordon._tcp.local.", server.config['HOSTNAME'], server.config['PORT'])
+    ZeroconfServer.properties = {'system_cpu': current_system_cpu(), 'system_cpu_cores': multiprocessing.cpu_count(),
+                                 'system_os': current_system_os(),
+                                 'system_os_version': current_system_os_version()}
+    ZeroconfServer.start()
 
-@server.get('/api/_debug/clear_history')
+    try:
-def clear_history():
+        server.run(host='0.0.0.0', port=server.config['PORT'], debug=Config.flask_debug_enable,
-    RenderQueue.clear_history()
+                   use_reloader=False, threaded=True)
-    return 'success'
+    finally:
+        RenderQueue.save_state()
+        ZeroconfServer.stop()

src/api/preview_manager.py

@@ -1,113 +0,0 @@
-import logging
-import os
-import subprocess
-import threading
-from pathlib import Path
-
-from src.utilities.ffmpeg_helper import generate_thumbnail, save_first_frame
-
-logger = logging.getLogger()
-supported_video_formats = ['.mp4', '.mov', '.avi', '.mpg', '.mpeg', '.mxf', '.m4v', '.mkv', '.webm']
-supported_image_formats = ['.jpg', '.png', '.exr', '.tif', '.tga', '.bmp', '.webp']
-
-
-class PreviewManager:
-
-    storage_path = None
-    _running_jobs = {}
-
-    @classmethod
-    def __generate_job_preview_worker(cls, job, replace_existing=False, max_width=480):
-
-        # Determine best source file to use for thumbs
-        job_file_list = job.file_list()
-        source_files = job_file_list if job_file_list else [job.input_path]
-        preview_label = "output" if job_file_list else "input"
-
-        # filter by type
-        found_image_files = [f for f in source_files if os.path.splitext(f)[-1].lower() in supported_image_formats]
-        found_video_files = [f for f in source_files if os.path.splitext(f)[-1].lower() in supported_video_formats]
-
-        # check if we even have any valid files to work from
-        if source_files and not found_video_files and not found_image_files:
-            logger.warning(f"No valid image or video files found in files from job: {job}")
-            return
-
-        os.makedirs(cls.storage_path, exist_ok=True)
-        base_path = os.path.join(cls.storage_path, f"{job.id}-{preview_label}-{max_width}")
-        preview_video_path = base_path + '.mp4'
-        preview_image_path = base_path + '.jpg'
-
-        if replace_existing:
-            for x in [preview_image_path, preview_video_path]:
-                try:
-                    os.remove(x)
-                except OSError:
-                    pass
-
-        # Generate image previews
-        if (found_video_files or found_image_files) and not os.path.exists(preview_image_path):
-            try:
-                path_of_source = found_image_files[-1] if found_image_files else found_video_files[-1]
-                logger.debug(f"Generating image preview for {path_of_source}")
-                save_first_frame(source_path=path_of_source, dest_path=preview_image_path, max_width=max_width)
-                logger.debug(f"Successfully created image preview for {path_of_source}")
-            except Exception as e:
-                logger.error(f"Error generating image preview for {job}: {e}")
-
-        # Generate video previews
-        if found_video_files and not os.path.exists(preview_video_path):
-            try:
-                path_of_source = found_video_files[0]
-                logger.debug(f"Generating video preview for {path_of_source}")
-                generate_thumbnail(source_path=path_of_source, dest_path=preview_video_path, max_width=max_width)
-                logger.debug(f"Successfully created video preview for {path_of_source}")
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Error generating video preview for {job}: {e}")
-
-    @classmethod
-    def update_previews_for_job(cls, job, replace_existing=False, wait_until_completion=False, timeout=None):
-        job_thread = cls._running_jobs.get(job.id)
-        if job_thread and job_thread.is_alive():
-            logger.debug(f'Preview generation job already running for {job}')
-        else:
-            job_thread = threading.Thread(target=cls.__generate_job_preview_worker, args=(job, replace_existing,))
-            job_thread.start()
-            cls._running_jobs[job.id] = job_thread
-
-        if wait_until_completion:
-            job_thread.join(timeout=timeout)
-
-    @classmethod
-    def get_previews_for_job(cls, job):
-
-        results = {}
-        try:
-            directory_path = Path(cls.storage_path)
-            preview_files_for_job = [f for f in directory_path.iterdir() if f.is_file() and f.name.startswith(job.id)]
-
-            for preview_filename in preview_files_for_job:
-                try:
-                    pixel_width = str(preview_filename).split('-')[-1]
-                    preview_label = str(os.path.basename(preview_filename)).split('-')[1]
-                    extension = os.path.splitext(preview_filename)[-1].lower()
-                    kind = 'video' if extension in supported_video_formats else \
-                        'image' if extension in supported_image_formats else 'unknown'
-                    results[preview_label] = results.get(preview_label, [])
-                    results[preview_label].append({'filename': str(preview_filename), 'width': pixel_width, 'kind': kind})
-                except IndexError:  # ignore invalid filenames
-                    pass
-        except FileNotFoundError:
-            pass
-        return results
-
-    @classmethod
-    def delete_previews_for_job(cls, job):
-        all_previews = cls.get_previews_for_job(job)
-        flattened_list = [item for sublist in all_previews.values() for item in sublist]
-        for preview in flattened_list:
-            try:
-                logger.debug(f"Removing preview: {preview['filename']}")
-                os.remove(preview['filename'])
-            except OSError as e:
-                logger.error(f"Error removing preview '{preview.get('filename')}': {e}")

src/api/server_proxy.py

@@ -10,6 +10,7 @@ from urllib.parse import urljoin
 
 from src.utilities.misc_helper import is_localhost
 from src.utilities.status_utils import RenderStatus
+from src.utilities.zeroconf_server import ZeroconfServer
 
 status_colors = {RenderStatus.ERROR: "red", RenderStatus.CANCELLED: 'orange1', RenderStatus.COMPLETED: 'green',
                  RenderStatus.NOT_STARTED: "yellow", RenderStatus.SCHEDULED: 'purple',
@@ -25,8 +26,15 @@ LOOPBACK = '127.0.0.1'
 
 
 class RenderServerProxy:
-    """The ServerProxy class is responsible for interacting with a remote server.
+    """
-    It provides convenience methods to request data from the server and store the status of the server.
+    The ServerProxy class is responsible for interacting with a remote server.
+    It provides methods to request data from the server and store the status of the server.
+
+    Attributes:
+        system_cpu (str): The CPU type of the system.
+        system_cpu_count (int): The number of CPUs in the system.
+        system_os (str): The operating system of the system.
+        system_os_version (str): The version of the operating system.
     """
     
     def __init__(self, hostname, server_port="8080"):
@@ -46,11 +54,6 @@ class RenderServerProxy:
         self.system_cpu_count = None
         self.system_os = None
         self.system_os_version = None
-        self.system_api_version = None
-
-    # --------------------------------------------
-    # Basics / Connection:
-    # --------------------------------------------
 
     def __repr__(self):
         return f"<RenderServerProxy - {self.hostname}>"
@@ -70,10 +73,6 @@ class RenderServerProxy:
         running_jobs = [x for x in self.__jobs_cache if x['status'] == 'running'] if self.__jobs_cache else []
         return f"{len(running_jobs)} running" if running_jobs else "Ready"
 
-    # --------------------------------------------
-    # Requests:
-    # --------------------------------------------
-
     def request_data(self, payload, timeout=5):
         try:
             req = self.request(payload, timeout)
@@ -101,14 +100,8 @@ class RenderServerProxy:
         return None
 
     def request(self, payload, timeout=5):
-        from src.api.api_server import API_VERSION
         hostname = LOOPBACK if self.is_localhost else self.hostname
-        return requests.get(f'http://{hostname}:{self.port}/api/{payload}', timeout=timeout,
+        return requests.get(f'http://{hostname}:{self.port}/api/{payload}', timeout=timeout)
-                            headers={"X-API-Version": str(API_VERSION)})
-
-    # --------------------------------------------
-    # Background Updates:
-    # --------------------------------------------
 
     def start_background_update(self):
         if self.__update_in_background:
@@ -126,6 +119,17 @@ class RenderServerProxy:
         self.__background_thread.daemon = True
         self.__background_thread.start()
 
+    def stop_background_update(self):
+        self.__update_in_background = False
+
+    def get_job_info(self, job_id, timeout=5):
+        return self.request_data(f'job/{job_id}', timeout=timeout)
+
+    def get_all_jobs(self, timeout=5, ignore_token=False):
+        if not self.__update_in_background or ignore_token:
+            self.__update_job_cache(timeout, ignore_token)
+        return self.__jobs_cache.copy() if self.__jobs_cache else None
+
     def __update_job_cache(self, timeout=40, ignore_token=False):
 
         if self.__offline_flags:  # if we're offline, don't bother with the long poll
@@ -143,21 +147,15 @@ class RenderServerProxy:
             self.__jobs_cache = sorted_jobs
             self.__jobs_cache_token = status_result['token']
 
-    def stop_background_update(self):
-        self.__update_in_background = False
-
-    # --------------------------------------------
-    # Get System Info:
-    # --------------------------------------------
-
-    def get_all_jobs(self, timeout=5, ignore_token=False):
-        if not self.__update_in_background or ignore_token:
-            self.__update_job_cache(timeout, ignore_token)
-        return self.__jobs_cache.copy() if self.__jobs_cache else None
-
     def get_data(self, timeout=5):
         return self.request_data('full_status', timeout=timeout)
 
+    def cancel_job(self, job_id, confirm=False):
+        return self.request_data(f'job/{job_id}/cancel?confirm={confirm}')
+
+    def delete_job(self, job_id, confirm=False):
+        return self.request_data(f'job/{job_id}/delete?confirm={confirm}')
+
     def get_status(self):
         status = self.request_data('status')
         if status and not self.system_cpu:
@@ -165,22 +163,28 @@ class RenderServerProxy:
             self.system_cpu_count = status['cpu_count']
             self.system_os = status['system_os']
             self.system_os_version = status['system_os_version']
-            self.system_api_version = status['api_version']
         return status
 
-    # --------------------------------------------
+    def is_engine_available(self, engine_name):
-    # Get Job Info:
+        return self.request_data(f'{engine_name}/is_available')
-    # --------------------------------------------
 
-    def get_job_info(self, job_id, timeout=5):
+    def get_all_engines(self):
-        return self.request_data(f'job/{job_id}', timeout=timeout)
+        return self.request_data('all_engines')
 
-    def get_job_files_list(self, job_id):
+    def notify_parent_of_status_change(self, parent_id, subjob):
-        return self.request_data(f"job/{job_id}/file_list")
+        """
+        Notifies the parent job of a status change in a subjob.
 
-    # --------------------------------------------
+        Args:
-    # Job Lifecycle:
+            parent_id (str): The ID of the parent job.
-    # --------------------------------------------
+            subjob (Job): The subjob that has changed status.
+
+        Returns:
+            Response: The response from the server.
+        """
+        hostname = LOOPBACK if self.is_localhost else self.hostname
+        return requests.post(f'http://{hostname}:{self.port}/api/job/{parent_id}/notify_parent_of_status_change',
+                             json=subjob.json())
 
     def post_job_to_server(self, file_path, job_list, callback=None):
         """
@@ -228,36 +232,21 @@ class RenderServerProxy:
         except Exception as e:
             logger.error(f"An error occurred: {e}")
 
-    def cancel_job(self, job_id, confirm=False):
+    def get_job_files(self, job_id, save_path):
-        return self.request_data(f'job/{job_id}/cancel?confirm={confirm}')
-
-    def delete_job(self, job_id, confirm=False):
-        return self.request_data(f'job/{job_id}/delete?confirm={confirm}')
-
-    def send_subjob_update_notification(self, parent_id, subjob):
-        """
-        Notifies the parent job of an update in a subjob.
-
-        Args:
-            parent_id (str): The ID of the parent job.
-            subjob (Job): The subjob that has updated.
-
-        Returns:
-            Response: The response from the server.
-        """
         hostname = LOOPBACK if self.is_localhost else self.hostname
-        return requests.post(f'http://{hostname}:{self.port}/api/job/{parent_id}/send_subjob_update_notification',
+        url = f"http://{hostname}:{self.port}/api/job/{job_id}/download_all"
-                             json=subjob.json())
+        return self.download_file(url, filename=save_path)
 
-    # --------------------------------------------
+    @staticmethod
-    # Renderers:
+    def download_file(url, filename):
-    # --------------------------------------------
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            with open(filename, 'wb') as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+        return filename
 
-    def is_engine_available(self, engine_name):
+    # --- Renderer --- #
-        return self.request_data(f'{engine_name}/is_available')
-
-    def get_all_engines(self):
-        return self.request_data('all_engines')
 
     def get_renderer_info(self, response_type='standard', timeout=5):
         """
@@ -288,26 +277,3 @@ class RenderServerProxy:
         form_data = {'engine': engine, 'version': version, 'system_cpu': system_cpu}
         hostname = LOOPBACK if self.is_localhost else self.hostname
         return requests.post(f'http://{hostname}:{self.port}/api/delete_engine', json=form_data)
-
-    # --------------------------------------------
-    # Download Files:
-    # --------------------------------------------
-
-    def download_all_job_files(self, job_id, save_path):
-        hostname = LOOPBACK if self.is_localhost else self.hostname
-        url = f"http://{hostname}:{self.port}/api/job/{job_id}/download_all"
-        return self.__download_file_from_url(url, output_filepath=save_path)
-
-    def download_job_file(self, job_id, job_filename, save_path):
-        hostname = LOOPBACK if self.is_localhost else self.hostname
-        url = f"http://{hostname}:{self.port}/api/job/{job_id}/download?filename={job_filename}"
-        return self.__download_file_from_url(url, output_filepath=save_path)
-
-    @staticmethod
-    def __download_file_from_url(url, output_filepath):
-        with requests.get(url, stream=True) as r:
-            r.raise_for_status()
-            with open(output_filepath, 'wb') as f:
-                for chunk in r.iter_content(chunk_size=8192):
-                    f.write(chunk)
-        return output_filepath

src/distributed_job_manager.py

@@ -3,16 +3,17 @@ import os
 import socket
 import threading
 import time
+import zipfile
+from concurrent.futures import ThreadPoolExecutor
 
+import requests
 from plyer import notification
 from pubsub import pub
 
-from src.api.preview_manager import PreviewManager
 from src.api.server_proxy import RenderServerProxy
 from src.engines.engine_manager import EngineManager
 from src.render_queue import RenderQueue
-from src.utilities.config import Config
+from src.utilities.misc_helper import get_file_size_human
-from src.utilities.server_helper import download_missing_frames_from_subjob, distribute_server_work
 from src.utilities.status_utils import RenderStatus, string_to_status
 from src.utilities.zeroconf_server import ZeroconfServer
 
@@ -31,43 +32,6 @@ class DistributedJobManager:
           This should be called once, typically during the initialization phase.
         """
         pub.subscribe(cls.__local_job_status_changed, 'status_change')
-        pub.subscribe(cls.__local_job_frame_complete, 'frame_complete')
-
-    @classmethod
-    def __local_job_frame_complete(cls, job_id, frame_number, update_interval=5):
-
-        """
-        Responds to the 'frame_complete' pubsub message for local jobs.
-
-        Args:
-            job_id (str): The ID of the job that has changed status.
-            old_status (str): The previous status of the job.
-            new_status (str): The new (current) status of the job.
-
-        Note: Do not call directly. Instead, call via the 'frame_complete' pubsub message.
-        """
-
-        render_job = RenderQueue.job_with_id(job_id, none_ok=True)
-        if not render_job:  # ignore jobs not in the queue
-            return
-
-        logger.debug(f"Job {job_id} has completed frame #{frame_number}")
-        replace_existing_previews = (frame_number % update_interval) == 0
-        cls.__job_update_shared(render_job, replace_existing_previews)
-
-    @classmethod
-    def __job_update_shared(cls, render_job, replace_existing_previews=False):
-        # update previews
-        PreviewManager.update_previews_for_job(job=render_job, replace_existing=replace_existing_previews)
-
-        # notify parent to allow individual frames to be copied instead of waiting until the end
-        if render_job.parent:
-            parent_id, parent_hostname = render_job.parent.split('@')[0], render_job.parent.split('@')[-1]
-            try:
-                logger.debug(f'Job {render_job.id} updating parent {parent_id}@{parent_hostname}')
-                RenderServerProxy(parent_hostname).send_subjob_update_notification(parent_id, render_job)
-            except Exception as e:
-                logger.error(f"Error notifying parent {parent_hostname} about update in subjob {render_job.id}: {e}")
 
     @classmethod
     def __local_job_status_changed(cls, job_id, old_status, new_status):
@@ -75,7 +39,7 @@ class DistributedJobManager:
         Responds to the 'status_change' pubsub message for local jobs.
         If it's a child job, it notifies the parent job about the status change.
 
-        Args:
+        Parameters:
         job_id (str): The ID of the job that has changed status.
         old_status (str): The previous status of the job.
         new_status (str): The new (current) status of the job.
@@ -88,15 +52,15 @@ class DistributedJobManager:
             return
 
         logger.debug(f"Job {job_id} status change: {old_status} -> {new_status}")
+        if render_job.parent:  # If local job is a subjob from a remote server
+            parent_id, hostname = render_job.parent.split('@')[0], render_job.parent.split('@')[-1]
+            RenderServerProxy(hostname).notify_parent_of_status_change(parent_id=parent_id, subjob=render_job)
 
-        cls.__job_update_shared(render_job, replace_existing_previews=(render_job.status == RenderStatus.COMPLETED))
+        # handle cancelling all the children
-
+        elif render_job.children and new_status in [RenderStatus.CANCELLED, RenderStatus.ERROR]:
-        # Handle children
-        if render_job.children:
-            if new_status in [RenderStatus.CANCELLED, RenderStatus.ERROR]:  # Cancel children if necessary
             for child in render_job.children:
-                    child_id, child_hostname = child.split('@')
+                child_id, hostname = child.split('@')
-                    RenderServerProxy(child_hostname).cancel_job(child_id, confirm=True)
+                RenderServerProxy(hostname).cancel_job(child_id, confirm=True)
 
         # UI Notifications
         try:
@@ -129,12 +93,15 @@ class DistributedJobManager:
     # --------------------------------------------
 
     @classmethod
-    def create_render_job(cls, new_job_attributes, loaded_project_local_path):
+    def create_render_job(cls, job_data, loaded_project_local_path):
-        """Creates render jobs. Pass in dict of job_data and the local path to the project. It creates and returns a new
+        """
-        render job.
+        Creates render jobs.
+
+        This method takes a list of job data, a local path to a loaded project, and a job directory. It creates a render
+        job for each job data in the list and appends the result to a list. The list of results is then returned.
 
         Args:
-            new_job_attributes (dict): Dict of desired attributes for new job (frame count, renderer, output path, etc)
+            job_data (dict): Job data.
             loaded_project_local_path (str): The local path to the loaded project.
 
         Returns:
@@ -142,7 +109,7 @@ class DistributedJobManager:
         """
 
         # get new output path in output_dir
-        output_path = new_job_attributes.get('output_path')
+        output_path = job_data.get('output_path')
         if not output_path:
             loaded_project_filename = os.path.basename(loaded_project_local_path)
             output_filename = os.path.splitext(loaded_project_filename)[0]
@@ -156,28 +123,26 @@ class DistributedJobManager:
         logger.debug(f"New job output path: {output_path}")
 
         # create & configure jobs
-        worker = EngineManager.create_worker(renderer=new_job_attributes['renderer'],
+        worker = EngineManager.create_worker(renderer=job_data['renderer'],
                                              input_path=loaded_project_local_path,
                                              output_path=output_path,
-                                             engine_version=new_job_attributes.get('engine_version'),
+                                             engine_version=job_data.get('engine_version'),
-                                             args=new_job_attributes.get('args', {}),
+                                             args=job_data.get('args', {}),
-                                             parent=new_job_attributes.get('parent'),
+                                             parent=job_data.get('parent'),
-                                             name=new_job_attributes.get('name'))
+                                             name=job_data.get('name'))
-        worker.status = new_job_attributes.get("initial_status", worker.status)  # todo: is this necessary?
+        worker.status = job_data.get("initial_status", worker.status)  # todo: is this necessary?
-        worker.priority = int(new_job_attributes.get('priority', worker.priority))
+        worker.priority = int(job_data.get('priority', worker.priority))
-        worker.start_frame = int(new_job_attributes.get("start_frame", worker.start_frame))
+        worker.start_frame = int(job_data.get("start_frame", worker.start_frame))
-        worker.end_frame = int(new_job_attributes.get("end_frame", worker.end_frame))
+        worker.end_frame = int(job_data.get("end_frame", worker.end_frame))
-        worker.watchdog_timeout = Config.worker_process_timeout
         worker.hostname = socket.gethostname()
 
         # determine if we can / should split the job
-        if new_job_attributes.get("enable_split_jobs", False) and (worker.total_frames > 1) and not worker.parent:
+        if job_data.get("enable_split_jobs", False) and (worker.total_frames > 1) and not worker.parent:
-            cls.split_into_subjobs_async(worker, new_job_attributes, loaded_project_local_path)
+            cls.split_into_subjobs_async(worker, job_data, loaded_project_local_path)
         else:
-            worker.status = RenderStatus.NOT_STARTED
+            logger.debug("Not splitting into subjobs")
 
-        RenderQueue.add_to_render_queue(worker, force_start=new_job_attributes.get('force_start', False))
+        RenderQueue.add_to_render_queue(worker, force_start=job_data.get('force_start', False))
-        PreviewManager.update_previews_for_job(worker)
 
         return worker
 
@@ -186,8 +151,9 @@ class DistributedJobManager:
     # --------------------------------------------
 
     @classmethod
-    def handle_subjob_update_notification(cls, local_job, subjob_data):
+    def handle_subjob_status_change(cls, local_job, subjob_data):
-        """Responds to a notification from a remote subjob and the host requests any subsequent updates from the subjob.
+        """
+        Responds to a status change from a remote subjob and triggers the creation or modification of subjobs as needed.
 
         Args:
             local_job (BaseRenderWorker): The local parent job worker.
@@ -196,44 +162,82 @@ class DistributedJobManager:
 
         subjob_status = string_to_status(subjob_data['status'])
         subjob_id = subjob_data['id']
-        subjob_hostname = subjob_data['hostname']
+        subjob_hostname = next((hostname.split('@')[1] for hostname in local_job.children if
-        subjob_key = f'{subjob_id}@{subjob_hostname}'
+                                hostname.split('@')[0] == subjob_id), None)
-        old_status = local_job.children.get(subjob_key, {}).get('status')
+        local_job.children[f'{subjob_id}@{subjob_hostname}'] = subjob_data
-        local_job.children[subjob_key] = subjob_data
 
-        logname = f"<Parent: {local_job.id} | Child: {subjob_key}>"
+        logname = f"{local_job.id}:{subjob_id}@{subjob_hostname}"
-        if old_status != subjob_status.value:
         logger.debug(f"Subjob status changed: {logname} -> {subjob_status.value}")
 
-        download_success = download_missing_frames_from_subjob(local_job, subjob_id, subjob_hostname)
+        # Download complete or partial render jobs
-        if subjob_data['status'] == 'completed' and download_success:
+        if subjob_status in [RenderStatus.COMPLETED, RenderStatus.CANCELLED, RenderStatus.ERROR] and \
-            local_job.children[subjob_key]['download_status'] = 'completed'
+                subjob_data['file_count']:
+            download_result = cls.download_from_subjob(local_job, subjob_id, subjob_hostname)
+            if not download_result:
+                # todo: handle error
+                logger.error(f"Unable to download subjob files from {logname} with status {subjob_status.value}")
 
-    @classmethod
+        if subjob_status == RenderStatus.CANCELLED or subjob_status == RenderStatus.ERROR:
-    def wait_for_subjobs(cls, parent_job):
+            # todo: determine missing frames and schedule new job
-        """Check the status of subjobs and waits until they are all finished. Download rendered frames from subjobs
+            pass
-        when they are completed.
 
-        Args:
+    @staticmethod
-            parent_job: Worker object that has child jobs
+    def download_from_subjob(local_job, subjob_id, subjob_hostname):
+        """
+        Downloads and extracts files from a completed subjob on a remote server.
+
+        Parameters:
+        local_job (BaseRenderWorker): The local parent job worker.
+        subjob_id (str or int): The ID of the subjob.
+        subjob_hostname (str): The hostname of the remote server where the subjob is located.
 
         Returns:
+        bool: True if the files have been downloaded and extracted successfully, False otherwise.
         """
-        logger.debug(f"Waiting for subjobs for job {parent_job}")
+
-        parent_job.status = RenderStatus.WAITING_FOR_SUBJOBS
+        child_key = f'{subjob_id}@{subjob_hostname}'
+        logname = f"{local_job.id}:{child_key}"
+        zip_file_path = local_job.output_path + f'_{subjob_hostname}_{subjob_id}.zip'
+
+        # download zip file from server
+        try:
+            local_job.children[child_key]['download_status'] = 'working'
+            logger.info(f"Downloading completed subjob files from {subjob_hostname} to localhost")
+            RenderServerProxy(subjob_hostname).get_job_files(subjob_id, zip_file_path)
+            logger.info(f"File transfer complete for {logname} - Transferred {get_file_size_human(zip_file_path)}")
+        except Exception as e:
+            logger.error(f"Error downloading files from remote server: {e}")
+            local_job.children[child_key]['download_status'] = 'failed'
+            return False
+
+        # extract zip
+        try:
+            logger.debug(f"Extracting zip file: {zip_file_path}")
+            extract_path = os.path.dirname(zip_file_path)
+            with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+                zip_ref.extractall(extract_path)
+                logger.info(f"Successfully extracted zip to: {extract_path}")
+            os.remove(zip_file_path)
+            local_job.children[child_key]['download_status'] = 'complete'
+        except Exception as e:
+            logger.exception(f"Exception extracting zip file: {e}")
+            local_job.children[child_key]['download_status'] = 'failed'
+
+        return local_job.children[child_key].get('download_status', None) == 'complete'
+
+    @classmethod
+    def wait_for_subjobs(cls, local_job):
+        logger.debug(f"Waiting for subjobs for job {local_job}")
+        local_job.status = RenderStatus.WAITING_FOR_SUBJOBS
         statuses_to_download = [RenderStatus.CANCELLED, RenderStatus.ERROR, RenderStatus.COMPLETED]
 
         def subjobs_not_downloaded():
-            return {k: v for k, v in parent_job.children.items() if 'download_status' not in v or
+            return {k: v for k, v in local_job.children.items() if 'download_status' not in v or
                     v['download_status'] == 'working' or v['download_status'] is None}
 
-        logger.info(f'Waiting on {len(subjobs_not_downloaded())} subjobs for {parent_job.id}')
+        logger.info(f'Waiting on {len(subjobs_not_downloaded())} subjobs for {local_job.id}')
 
-        server_delay = 10
+        while len(subjobs_not_downloaded()):
-        sleep_counter = 0
-        while parent_job.status == RenderStatus.WAITING_FOR_SUBJOBS:
-
-            if sleep_counter % server_delay == 0:  # only ping servers every x seconds
             for child_key, subjob_cached_data in subjobs_not_downloaded().items():
 
                 subjob_id = child_key.split('@')[0]
@@ -242,58 +246,56 @@ class DistributedJobManager:
                 # Fetch info from server and handle failing case
                 subjob_data = RenderServerProxy(subjob_hostname).get_job_info(subjob_id)
                 if not subjob_data:
-                        logger.warning(f"No response from {subjob_hostname}")
+                    logger.warning(f"No response from: {subjob_hostname}")
-                        # timeout / missing server situations
+                    # todo: handle timeout / missing server situations
-                        parent_job.children[child_key]['download_status'] = f'error: No response from {subjob_hostname}'
                     continue
 
                 # Update parent job cache but keep the download status
-                    download_status = parent_job.children[child_key].get('download_status', None)
+                download_status = local_job.children[child_key].get('download_status', None)
-                    parent_job.children[child_key] = subjob_data
+                local_job.children[child_key] = subjob_data
-                    parent_job.children[child_key]['download_status'] = download_status
+                local_job.children[child_key]['download_status'] = download_status
 
                 status = string_to_status(subjob_data.get('status', ''))
                 status_msg = f"Subjob {child_key} | {status} | " \
                              f"{float(subjob_data.get('percent_complete')) * 100.0}%"
                 logger.debug(status_msg)
 
+                # Still working in another thread - keep waiting
+                if download_status == 'working':
+                    continue
+
                 # Check if job is finished, but has not had files copied yet over yet
                 if download_status is None and subjob_data['file_count'] and status in statuses_to_download:
-                        try:
+                    download_result = cls.download_from_subjob(local_job, subjob_id, subjob_hostname)
-                            download_missing_frames_from_subjob(parent_job, subjob_id, subjob_hostname)
+                    if not download_result:
-                            parent_job.children[child_key]['download_status'] = 'complete'
+                        logger.error("Failed to download from subjob")
-                        except Exception as e:
+                        # todo: error handling here
-                            logger.error(f"Error downloading missing frames from subjob: {e}")
-                            parent_job.children[child_key]['download_status'] = 'error: {}'
 
                 # Any finished jobs not successfully downloaded at this point are skipped
-                    if parent_job.children[child_key].get('download_status', None) is None and \
+                if local_job.children[child_key].get('download_status', None) is None and \
                         status in statuses_to_download:
                     logger.warning(f"Skipping waiting on downloading from subjob: {child_key}")
-                        parent_job.children[child_key]['download_status'] = 'skipped'
+                    local_job.children[child_key]['download_status'] = 'skipped'
 
             if subjobs_not_downloaded():
                 logger.debug(f"Waiting on {len(subjobs_not_downloaded())} subjobs on "
                              f"{', '.join(list(subjobs_not_downloaded().keys()))}")
-                time.sleep(1)
+                time.sleep(5)
-                sleep_counter += 1
-            else:  # exit the loop
-                parent_job.status = RenderStatus.RUNNING
 
     # --------------------------------------------
     # Creating Subjobs
     # --------------------------------------------
 
     @classmethod
-    def split_into_subjobs_async(cls, parent_worker, new_job_attributes, project_path, system_os=None):
+    def split_into_subjobs_async(cls, parent_worker, job_data, project_path, system_os=None):
         # todo: I don't love this
         parent_worker.status = RenderStatus.CONFIGURING
-        cls.background_worker = threading.Thread(target=cls.split_into_subjobs, args=(parent_worker, new_job_attributes,
+        cls.background_worker = threading.Thread(target=cls.split_into_subjobs, args=(parent_worker, job_data,
                                                                                       project_path, system_os))
         cls.background_worker.start()
 
     @classmethod
-    def split_into_subjobs(cls, parent_worker, new_job_attributes, project_path, system_os=None, specific_servers=None):
+    def split_into_subjobs(cls, parent_worker, job_data, project_path, system_os=None, specific_servers=None):
         """
         Splits a job into subjobs and distributes them among available servers.
 
@@ -302,31 +304,26 @@ class DistributedJobManager:
         subjob.
 
         Args:
-            parent_worker (Worker): The parent job what we're creating the subjobs for.
+            parent_worker (Worker): The worker that is handling the job.
-            new_job_attributes (dict): Dict of desired attributes for new job (frame count, renderer, output path, etc)
+            job_data (dict): The data for the job to be split.
-            project_path (str): The path to the project.
+            project_path (str): The path to the project associated with the job.
-            system_os (str, optional): Required OS. Default is any.
+            system_os (str, optional): The operating system of the servers. Default is any OS.
             specific_servers (list, optional): List of specific servers to split work between. Defaults to all found.
         """
 
         # Check availability
-        available_servers = specific_servers if specific_servers else cls.find_available_servers(parent_worker.renderer,
+        parent_worker.status = RenderStatus.CONFIGURING
-                                                                                                 system_os)
+        available_servers = specific_servers if specific_servers else cls.find_available_servers(parent_worker.renderer, system_os)
-        # skip if theres no external servers found
+        logger.debug(f"Splitting into subjobs - Available servers: {available_servers}")
-        external_servers = [x for x in available_servers if x['hostname'] != parent_worker.hostname]
+        all_subjob_server_data = cls.distribute_server_work(parent_worker.start_frame, parent_worker.end_frame, available_servers)
-        if not external_servers:
-            parent_worker.status = RenderStatus.NOT_STARTED
-            return
-
-        logger.debug(f"Splitting into subjobs - Available servers: {[x['hostname'] for x in available_servers]}")
-        all_subjob_server_data = distribute_server_work(parent_worker.start_frame, parent_worker.end_frame, available_servers)
 
         # Prep and submit these sub-jobs
         logger.info(f"Job {parent_worker.id} split plan: {all_subjob_server_data}")
         try:
             for subjob_data in all_subjob_server_data:
                 subjob_hostname = subjob_data['hostname']
-                post_results = cls.__create_subjob(new_job_attributes, project_path, subjob_data, subjob_hostname,
+                if subjob_hostname != parent_worker.hostname:
+                    post_results = cls.__create_subjob(job_data, project_path, subjob_data, subjob_hostname,
                                                        parent_worker)
                     if not post_results.ok:
                         ValueError(f"Failed to create subjob on {subjob_hostname}")
@@ -335,10 +332,15 @@ class DistributedJobManager:
                     submission_results = post_results.json()[0]
                     child_key = f"{submission_results['id']}@{subjob_hostname}"
                     parent_worker.children[child_key] = submission_results
+                else:
+                    # truncate parent render_job
+                    parent_worker.start_frame = max(subjob_data['frame_range'][0], parent_worker.start_frame)
+                    parent_worker.end_frame = min(subjob_data['frame_range'][-1], parent_worker.end_frame)
+                    logger.info(f"Local job now rendering from {parent_worker.start_frame} to {parent_worker.end_frame}")
 
             # start subjobs
-            logger.debug(f"Created {len(all_subjob_server_data)} subjobs successfully")
+            logger.debug(f"Created {len(all_subjob_server_data) - 1} subjobs successfully")
-            parent_worker.name = f"{parent_worker.name} (Parent)"
+            parent_worker.name = f"{parent_worker.name}[{parent_worker.start_frame}-{parent_worker.end_frame}]"
             parent_worker.status = RenderStatus.NOT_STARTED  # todo: this won't work with scheduled starts
         except Exception as e:
             # cancel all the subjobs
@@ -347,9 +349,8 @@ class DistributedJobManager:
             RenderServerProxy(parent_worker.hostname).cancel_job(parent_worker.id, confirm=True)
 
     @staticmethod
-    def __create_subjob(new_job_attributes, project_path, server_data, server_hostname, parent_worker):
+    def __create_subjob(job_data, project_path, server_data, server_hostname, parent_worker):
-        """Convenience method to create subjobs for a parent worker"""
+        subjob = job_data.copy()
-        subjob = new_job_attributes.copy()
         subjob['name'] = f"{parent_worker.name}[{server_data['frame_range'][0]}-{server_data['frame_range'][-1]}]"
         subjob['parent'] = f"{parent_worker.id}@{parent_worker.hostname}"
         subjob['start_frame'] = server_data['frame_range'][0]
@@ -365,6 +366,126 @@ class DistributedJobManager:
     # Server Handling
     # --------------------------------------------
 
+    @staticmethod
+    def distribute_server_work(start_frame, end_frame, available_servers, method='cpu_benchmark'):
+        """
+        Splits the frame range among available servers proportionally based on their performance (CPU count).
+
+        Args:
+            start_frame (int): The start frame number of the animation to be rendered.
+            end_frame (int): The end frame number of the animation to be rendered.
+            available_servers (list): A list of available server dictionaries. Each server dictionary should include
+            'hostname' and 'cpu_count' keys (see find_available_servers).
+            method (str, optional): Specifies the distribution method. Possible values are 'cpu_benchmark', 'cpu_count'
+            and 'evenly'.
+            Defaults to 'cpu_benchmark'.
+
+        Returns:
+            list: A list of server dictionaries where each dictionary includes the frame range and total number of
+            frames to be rendered by the server.
+        """
+        # Calculate respective frames for each server
+        def divide_frames_by_cpu_count(frame_start, frame_end, servers):
+            total_frames = frame_end - frame_start + 1
+            total_cpus = sum(server['cpu_count'] for server in servers)
+
+            frame_ranges = {}
+            current_frame = frame_start
+            allocated_frames = 0
+
+            for i, server in enumerate(servers):
+                if i == len(servers) - 1:  # if it's the last server
+                    # Give all remaining frames to the last server
+                    num_frames = total_frames - allocated_frames
+                else:
+                    num_frames = round((server['cpu_count'] / total_cpus) * total_frames)
+                    allocated_frames += num_frames
+
+                frame_end_for_server = current_frame + num_frames - 1
+
+                if current_frame <= frame_end_for_server:
+                    frame_ranges[server['hostname']] = (current_frame, frame_end_for_server)
+                current_frame = frame_end_for_server + 1
+
+            return frame_ranges
+
+        def divide_frames_by_benchmark(frame_start, frame_end, servers):
+
+            def fetch_benchmark(server):
+                try:
+                    benchmark = requests.get(f'http://{server["hostname"]}:{ZeroconfServer.server_port}'
+                                             f'/api/cpu_benchmark').text
+                    server['cpu_benchmark'] = benchmark
+                    logger.debug(f'Benchmark for {server["hostname"]}: {benchmark}')
+                except requests.exceptions.RequestException as e:
+                    logger.error(f'Error fetching benchmark for {server["hostname"]}: {e}')
+
+            # Number of threads to use (can adjust based on your needs or number of servers)
+            threads = len(servers)
+
+            with ThreadPoolExecutor(max_workers=threads) as executor:
+                executor.map(fetch_benchmark, servers)
+
+            total_frames = frame_end - frame_start + 1
+            total_performance = sum(int(server['cpu_benchmark']) for server in servers)
+
+            frame_ranges = {}
+            current_frame = frame_start
+            allocated_frames = 0
+
+            for i, server in enumerate(servers):
+                if i == len(servers) - 1:  # if it's the last server
+                    # Give all remaining frames to the last server
+                    num_frames = total_frames - allocated_frames
+                else:
+                    num_frames = round((int(server['cpu_benchmark']) / total_performance) * total_frames)
+                    allocated_frames += num_frames
+
+                frame_end_for_server = current_frame + num_frames - 1
+
+                if current_frame <= frame_end_for_server:
+                    frame_ranges[server['hostname']] = (current_frame, frame_end_for_server)
+                current_frame = frame_end_for_server + 1
+
+            return frame_ranges
+
+        def divide_frames_equally(frame_start, frame_end, servers):
+            frame_range = frame_end - frame_start + 1
+            frames_per_server = frame_range // len(servers)
+            leftover_frames = frame_range % len(servers)
+
+            frame_ranges = {}
+            current_start = frame_start
+            for i, server in enumerate(servers):
+                current_end = current_start + frames_per_server - 1
+                if leftover_frames > 0:
+                    current_end += 1
+                    leftover_frames -= 1
+                if current_start <= current_end:
+                    frame_ranges[server['hostname']] = (current_start, current_end)
+                current_start = current_end + 1
+
+            return frame_ranges
+
+        if len(available_servers) == 1:
+            breakdown = {available_servers[0]['hostname']: (start_frame, end_frame)}
+        else:
+            logger.debug(f'Splitting between {len(available_servers)} servers by {method} method')
+            if method == 'evenly':
+                breakdown = divide_frames_equally(start_frame, end_frame, available_servers)
+            elif method == 'cpu_benchmark':
+                breakdown = divide_frames_by_benchmark(start_frame, end_frame, available_servers)
+            elif method == 'cpu_count':
+                breakdown = divide_frames_by_cpu_count(start_frame, end_frame, available_servers)
+            else:
+                raise ValueError(f"Invalid distribution method: {method}")
+
+        server_breakdown = [server for server in available_servers if breakdown.get(server['hostname']) is not None]
+        for server in server_breakdown:
+            server['frame_range'] = breakdown[server['hostname']]
+            server['total_frames'] = breakdown[server['hostname']][-1] - breakdown[server['hostname']][0] + 1
+        return server_breakdown
+
     @staticmethod
     def find_available_servers(engine_name, system_os=None):
         """
@@ -374,11 +495,9 @@ class DistributedJobManager:
         :param system_os: str, Restrict results to servers running a specific OS
         :return: A list of dictionaries with each dict containing hostname and cpu_count of available servers
         """
-        from api.api_server import API_VERSION
         available_servers = []
         for hostname in ZeroconfServer.found_hostnames():
             host_properties = ZeroconfServer.get_hostname_properties(hostname)
-            if host_properties.get('api_version') == API_VERSION:
             if not system_os or (system_os and system_os == host_properties.get('system_os')):
                 response = RenderServerProxy(hostname).is_engine_available(engine_name)
                 if response and response.get('available', False):
@@ -396,6 +515,6 @@ if __name__ == '__main__':
     time.sleep(2)
     available_servers = DistributedJobManager.find_available_servers('blender')
     print(f"AVAILABLE SERVERS ({len(available_servers)}): {available_servers}")
-    # results = distribute_server_work(1, 100, available_servers)
+    # results = DistributedJobManager.distribute_server_work(1, 100, available_servers)
     # print(f"RESULTS: {results}")
     ZeroconfServer.stop()

src/engines/aerender/aerender_engine.py

@@ -1,22 +1,74 @@
+import glob
+import logging
+import subprocess
+
 from src.engines.core.base_engine import BaseRenderEngine
 
+logger = logging.getLogger()
+
 
 class AERender(BaseRenderEngine):
 
-    supported_extensions = ['.aep']
+    file_extensions = ['aepx']
 
     def version(self):
         version = None
         try:
             render_path = self.renderer_path()
             if render_path:
-                ver_out = subprocess.check_output([render_path, '-version'], timeout=SUBPROCESS_TIMEOUT)
+                ver_out = subprocess.run([render_path, '-version'], capture_output=True, text=True)
-                version = ver_out.decode('utf-8').split(" ")[-1].strip()
+                version = ver_out.stdout.split(" ")[-1].strip()
         except Exception as e:
             logger.error(f'Failed to get {self.name()} version: {e}')
         return version
 
+    @classmethod
+    def default_renderer_path(cls):
+        paths = glob.glob('/Applications/*After Effects*/aerender')
+        if len(paths) > 1:
+            logger.warning('Multiple After Effects installations detected')
+        elif not paths:
+            logger.error('After Effects installation not found')
+        return paths[0]
+
+    def get_project_info(self, project_path, timeout=10):
+        scene_info = {}
+        try:
+            import xml.etree.ElementTree as ET
+
+            tree = ET.parse(project_path)
+            root = tree.getroot()
+            namespace = {'ae': 'http://www.adobe.com/products/aftereffects'}
+
+            comp_names = []
+            for item in root.findall(".//ae:Item", namespace):
+                if item.find("ae:Layr", namespace) is not None:
+                    for string in item.findall("./ae:string", namespace):
+                        comp_names.append(string.text)
+            scene_info['comp_names'] = comp_names
+        except Exception as e:
+            logger.error(f'Error getting file details for .aepx file: {e}')
+        return scene_info
+
+    def run_javascript(self, script_path, project_path, timeout=None):
+        # todo: implement
+        pass
+
     @classmethod
     def get_output_formats(cls):
         # todo: create implementation
         return []
+
+    def ui_options(self, project_info):
+        from src.engines.aerender.aerender_ui import AERenderUI
+        return AERenderUI.get_options(self, project_info)
+
+    @classmethod
+    def worker_class(cls):
+        from src.engines.aerender.aerender_worker import AERenderWorker
+        return AERenderWorker
+
+
+if __name__ == "__main__":
+    x = AERender().get_project_info('/Users/brett/ae_testing/project.aepx')
+    print(x)

src/engines/aerender/aerender_ui.py

@@ -0,0 +1,8 @@
+
+class AERenderUI:
+    @staticmethod
+    def get_options(instance, project_info):
+        options = [
+            {'name': 'comp', 'options': project_info.get('comp_names', [])}
+        ]
+        return options

src/engines/aerender/aerender_worker.py

@@ -9,72 +9,39 @@ import time
 from src.engines.core.base_worker import BaseRenderWorker, timecode_to_frames
 from src.engines.aerender.aerender_engine import AERender
 
-
+logger = logging.getLogger()
-def aerender_path():
-    paths = glob.glob('/Applications/*After Effects*/aerender')
-    if len(paths) > 1:
-        logging.warning('Multiple After Effects installations detected')
-    elif not paths:
-        logging.error('After Effects installation not found')
-    else:
-        return paths[0]
 
 
 class AERenderWorker(BaseRenderWorker):
 
-    supported_extensions = ['.aep']
     engine = AERender
 
-    def __init__(self, input_path, output_path, args=None, parent=None, name=None):
+    def __init__(self, input_path, output_path, engine_path, args=None, parent=None, name=None):
-        super(AERenderWorker, self).__init__(input_path=input_path, output_path=output_path, args=args,
+        super(AERenderWorker, self).__init__(input_path=input_path, output_path=output_path, engine_path=engine_path,
-                                             parent=parent, name=name)
+                                             args=args, parent=parent, name=name)
 
-        self.comp = args.get('comp', None)
+        # temp files for processing stdout
-        self.render_settings = args.get('render_settings', None)
+        self.__progress_history = []
-        self.omsettings = args.get('omsettings', None)
+        self.__temp_attributes = {}
-
-        self.progress = 0
-        self.progress_history = []
-        self.attributes = {}
 
     def generate_worker_subprocess(self):
 
-        if os.path.exists('nexrender-cli-macos'):
+        comp = self.args.get('comp', 'Comp 1')
-            logging.info('nexrender found')
+        render_settings = self.args.get('render_settings', None)
-            # {
+        omsettings = self.args.get('omsettings', None)
-            #     "template": {
+
-            #         "src": String,
+        command = [self.renderer_path, '-project', self.input_path, '-comp', f'"{comp}"']
-            #         "composition": String,
+
-            #
+        if render_settings:
-            #         "frameStart": Number,
+            command.extend(['-RStemplate', render_settings])
-            #         "frameEnd": Number,
+
-            #         "frameIncrement": Number,
+        if omsettings:
-            #
+            command.extend(['-OMtemplate', omsettings])
-            #         "continueOnMissing": Boolean,
+
-            #         "settingsTemplate": String,
+        command.extend(['-s', self.start_frame,
-            #         "outputModule": String,
+                        '-e', self.end_frame,
-            #         "outputExt": String,
+                        '-output', self.output_path])
-            #     },
+        return command
-            #     "assets": [],
-            #     "actions": {
-            #         "prerender": [],
-            #         "postrender": [],
-            #     },
-            #     "onChange": Function,
-            #     "onRenderProgress": Function
-            # }
-            job = {'template':
-                {
-                    'src': 'file://' + self.input_path, 'composition': self.comp.replace('"', ''),
-                    'settingsTemplate': self.render_settings.replace('"', ''),
-                    'outputModule': self.omsettings.replace('"', ''), 'outputExt': 'mov'}
-            }
-            x = ['./nexrender-cli-macos', "'{}'".format(json.dumps(job))]
-        else:
-            logging.info('nexrender not found')
-            x = [aerender_path(), '-project', self.input_path, '-comp', self.comp, '-RStemplate', self.render_settings,
-                 '-OMtemplate', self.omsettings, '-output', self.output_path]
-        return x
 
     def _parse_stdout(self, line):
 
@@ -83,12 +50,12 @@ class AERenderWorker(BaseRenderWorker):
             # print 'progress'
             trimmed = line.replace('PROGRESS:', '').strip()
             if len(trimmed):
-                self.progress_history.append(line)
+                self.__progress_history.append(line)
                 if 'Seconds' in trimmed:
                     self._update_progress(line)
                 elif ': ' in trimmed:
                     tmp = trimmed.split(': ')
-                    self.attributes[tmp[0].strip()] = tmp[1].strip()
+                    self.__temp_attributes[tmp[0].strip()] = tmp[1].strip()
         elif line.startswith('WARNING:'):
             trimmed = line.replace('WARNING:', '').strip()
             self.warnings.append(trimmed)
@@ -99,28 +66,28 @@ class AERenderWorker(BaseRenderWorker):
     def _update_progress(self, line):
 
         if not self.total_frames:
-            duration_string = self.attributes.get('Duration', None)
+            duration_string = self.__temp_attributes.get('Duration', None)
-            frame_rate = self.attributes.get('Frame Rate', '0').split(' ')[0]
+            frame_rate = self.__temp_attributes.get('Frame Rate', '0').split(' ')[0]
             self.total_frames = timecode_to_frames(duration_string.split('Duration:')[-1], float(frame_rate))
 
         match = re.match(r'PROGRESS:.*\((?P<frame>\d+)\): (?P<time>\d+)', line).groupdict()
-        self.last_frame = match['frame']
+        self.current_frame = match['frame']
 
     def average_frame_duration(self):
 
         total_durations = 0
 
-        for line in self.progress_history:
+        for line in self.__progress_history:
             match = re.match(r'PROGRESS:.*\((?P<frame>\d+)\): (?P<time>\d+)', line)
             if match:
                 total_durations += int(match.group(2))
 
-        average = float(total_durations) / self.last_frame
+        average = float(total_durations) / self.current_frame
         return average
 
     def percent_complete(self):
         if self.total_frames:
-            return (float(self.last_frame) / float(self.total_frames)) * 100
+            return (float(self.current_frame) / float(self.total_frames)) * 100
         else:
             return 0
 
@@ -128,8 +95,11 @@ class AERenderWorker(BaseRenderWorker):
 if __name__ == '__main__':
     logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG)
 
-    r = AERenderWorker('/Users/brett/Desktop/Youtube_Vids/Film_Formats/Frame_Animations.aep', '"Film Pan"',
+    r = AERenderWorker(input_path='/Users/brett/ae_testing/project.aepx',
-                   '"Draft Settings"', '"ProRes"', '/Users/brett/Desktop/test_render')
+                       output_path='/Users/brett/ae_testing/project.mp4',
+                       engine_path=AERenderWorker.engine.default_renderer_path(),
+                       args={'start_frame': 1, 'end_frame': 5})
+
     r.start()
     while r.is_running():
         time.sleep(0.1)

src/engines/blender/blender_engine.py

@@ -6,39 +6,33 @@ from src.utilities.misc_helper import system_safe_path
 
 logger = logging.getLogger()
 
-_creationflags = subprocess.CREATE_NO_WINDOW if platform.system() == 'Windows' else 0
-
 
 class Blender(BaseRenderEngine):
 
     install_paths = ['/Applications/Blender.app/Contents/MacOS/Blender']
     binary_names = {'linux': 'blender', 'windows': 'blender.exe', 'macos': 'Blender'}
+    file_extensions = ['blend']
 
     @staticmethod
     def downloader():
         from src.engines.blender.blender_downloader import BlenderDownloader
         return BlenderDownloader
 
-    @staticmethod
+    @classmethod
-    def worker_class():
+    def worker_class(cls):
         from src.engines.blender.blender_worker import BlenderRenderWorker
         return BlenderRenderWorker
 
-    @staticmethod
+    def ui_options(self, project_info):
-    def ui_options(system_info):
         from src.engines.blender.blender_ui import BlenderUI
-        return BlenderUI.get_options(system_info)
+        return BlenderUI.get_options(self)
-
-    def supported_extensions(self):
-        return ['blend']
 
     def version(self):
         version = None
         try:
             render_path = self.renderer_path()
             if render_path:
-                ver_out = subprocess.check_output([render_path, '-v'], timeout=SUBPROCESS_TIMEOUT,
+                ver_out = subprocess.check_output([render_path, '-v'], timeout=SUBPROCESS_TIMEOUT)
-                                                  creationflags=_creationflags)
                 version = ver_out.decode('utf-8').splitlines()[0].replace('Blender', '').strip()
         except Exception as e:
             logger.error(f'Failed to get Blender version: {e}')
@@ -53,11 +47,9 @@ class Blender(BaseRenderEngine):
         if os.path.exists(project_path):
             try:
                 return subprocess.run([self.renderer_path(), '-b', project_path, '--python-expr', python_expression],
-                                      capture_output=True, timeout=timeout, creationflags=_creationflags)
+                                      capture_output=True, timeout=timeout)
             except Exception as e:
-                err_msg = f"Error running python expression in blender: {e}"
+                logger.error(f"Error running python expression in blender: {e}")
-                logger.error(err_msg)
-                raise ChildProcessError(err_msg)
         else:
             raise FileNotFoundError(f'Project file not found: {project_path}')
 
@@ -72,16 +64,9 @@ class Blender(BaseRenderEngine):
             command = [self.renderer_path(), '-b', '--python', script_path]
             if project_path:
                 command.insert(2, project_path)
-            result = subprocess.run(command, capture_output=True, timeout=timeout, creationflags=_creationflags)
+            return subprocess.run(command, capture_output=True, timeout=timeout)
-            return result
-        except subprocess.TimeoutExpired:
-            err_msg = f"Timed out after {timeout}s while running python script in blender: {script_path}"
-            logger.error(err_msg)
-            raise TimeoutError(err_msg)
         except Exception as e:
-            err_msg = f"Error running python script in blender: {e}"
+            logger.exception(f"Error running python script in blender: {e}")
-            logger.error(err_msg)
-            raise ChildProcessError(err_msg)
 
     def get_project_info(self, project_path, timeout=10):
         scene_info = {}
@@ -98,12 +83,10 @@ class Blender(BaseRenderEngine):
                 elif line.startswith('Error'):
                     logger.error(f"get_scene_info error: {line.strip()}")
         except Exception as e:
-            msg = f'Error getting file details for .blend file: {e}'
+            logger.error(f'Error getting file details for .blend file: {e}')
-            logger.error(msg)
-            raise ChildProcessError(msg)
         return scene_info
 
-    def pack_project_file(self, project_path, timeout=None):
+    def pack_project_file(self, project_path, timeout=30):
         # Credit to L0Lock for pack script - https://blender.stackexchange.com/a/243935
         try:
             logger.info(f"Starting to pack Blender file: {project_path}")
@@ -126,13 +109,11 @@ class Blender(BaseRenderEngine):
                 logger.info(f'Blender file packed successfully to {new_path}')
                 return new_path
         except Exception as e:
-            msg = f'Error packing .blend file: {e}'
+            logger.error(f'Error packing .blend file: {e}')
-            logger.error(msg)
-            raise ChildProcessError(msg)
         return None
 
-    def get_arguments(self):
+    def get_arguments(self):  # possibly deprecate
-        help_text = subprocess.check_output([self.renderer_path(), '-h'], creationflags=_creationflags).decode('utf-8')
+        help_text = subprocess.check_output([self.renderer_path(), '-h']).decode('utf-8')
         lines = help_text.splitlines()
 
         options = {}
@@ -180,12 +161,12 @@ class Blender(BaseRenderEngine):
 
     def supported_render_engines(self):
         engine_output = subprocess.run([self.renderer_path(), '-E', 'help'], timeout=SUBPROCESS_TIMEOUT,
-                                       capture_output=True, creationflags=_creationflags).stdout.decode('utf-8').strip()
+                                       capture_output=True).stdout.decode('utf-8').strip()
         render_engines = [x.strip() for x in engine_output.split('Blender Engine Listing:')[-1].strip().splitlines()]
         return render_engines
 
     def perform_presubmission_tasks(self, project_path):
-        packed_path = self.pack_project_file(project_path, timeout=120)
+        packed_path = self.pack_project_file(project_path, timeout=30)
         return packed_path
 
 

src/engines/blender/blender_ui.py

@@ -1,9 +1,9 @@
 
 class BlenderUI:
     @staticmethod
-    def get_options(system_info):
+    def get_options(instance):
         options = [
-            {'name': 'engine', 'options': system_info.get('engines', [])},
+            {'name': 'engine', 'options': instance.supported_render_engines()},
             {'name': 'render_device', 'options': ['Any', 'GPU', 'CPU']},
         ]
         return options

src/engines/blender/blender_worker.py

@@ -12,17 +12,12 @@ class BlenderRenderWorker(BaseRenderWorker):
     engine = Blender
 
     def __init__(self, input_path, output_path, engine_path, args=None, parent=None, name=None):
-        super(BlenderRenderWorker, self).__init__(input_path=input_path, output_path=output_path, engine_path=engine_path, args=args, parent=parent, name=name)
+        super(BlenderRenderWorker, self).__init__(input_path=input_path, output_path=output_path,
+                                                  engine_path=engine_path, args=args, parent=parent, name=name)
 
         # Stats
         self.__frame_percent_complete = 0.0
-
+        self.current_frame = -1  # todo: is this necessary?
-        # Scene Info
-        self.scene_info = Blender(engine_path).get_project_info(input_path)
-        self.start_frame = int(self.scene_info.get('start_frame', 1))
-        self.end_frame = int(self.scene_info.get('end_frame', self.start_frame))
-        self.project_length = (self.end_frame - self.start_frame) + 1
-        self.current_frame = -1
 
     def generate_worker_subprocess(self):
 
@@ -31,12 +26,6 @@ class BlenderRenderWorker(BaseRenderWorker):
             cmd.append('-b')
         cmd.append(self.input_path)
 
-        # Set Render Engine
-        blender_engine = self.args.get('engine')
-        if blender_engine:
-            blender_engine = blender_engine.upper()
-            cmd.extend(['-E', blender_engine])
-
         # Start Python expressions - # todo: investigate splitting into separate 'setup' script
         cmd.append('--python-expr')
         python_exp = 'import bpy; bpy.context.scene.render.use_overwrite = False;'
@@ -46,7 +35,8 @@ class BlenderRenderWorker(BaseRenderWorker):
         if custom_camera:
             python_exp = python_exp + f"bpy.context.scene.camera = bpy.data.objects['{custom_camera}'];"
 
-        # Set Render Device for Cycles (gpu/cpu/any)
+        # Set Render Device (gpu/cpu/any)
+        blender_engine = self.args.get('engine', 'BLENDER_EEVEE').upper()
         if blender_engine == 'CYCLES':
             render_device = self.args.get('render_device', 'any').lower()
             if render_device not in {'any', 'gpu', 'cpu'}:
@@ -67,11 +57,8 @@ class BlenderRenderWorker(BaseRenderWorker):
         # Export format
         export_format = self.args.get('export_format', None) or 'JPEG'
 
-        main_part, ext = os.path.splitext(self.output_path)
+        path_without_ext = os.path.splitext(self.output_path)[0] + "_"
-        # Remove the extension only if it is not composed entirely of digits
+        cmd.extend(['-E', blender_engine, '-o', path_without_ext, '-F', export_format])
-        path_without_ext = main_part if not ext[1:].isdigit() else self.output_path
-        path_without_ext += "_"
-        cmd.extend(['-o', path_without_ext, '-F', export_format])
 
         # set frame range
         cmd.extend(['-s', self.start_frame, '-e', self.end_frame, '-a'])
@@ -115,7 +102,6 @@ class BlenderRenderWorker(BaseRenderWorker):
                 output_file_number = output_filename_match.groups()[0]
                 try:
                     self.current_frame = int(output_file_number)
-                    self._send_frame_complete_notification()
                 except ValueError:
                     pass
             elif render_stats_match:
@@ -124,15 +110,15 @@ class BlenderRenderWorker(BaseRenderWorker):
                 logger.info(f'Frame #{self.current_frame} - '
                             f'{frame_count} of {self.total_frames} completed in {time_completed} | '
                             f'Total Elapsed Time: {datetime.now() - self.start_time}')
+            else:
+                logger.debug(f'DEBUG: {line}')
         else:
             pass
             # if len(line.strip()):
             #     logger.debug(line.strip())
 
     def percent_complete(self):
-        if self.status == RenderStatus.COMPLETED:
+        if self.total_frames <= 1:
-            return 1
-        elif self.total_frames <= 1:
             return self.__frame_percent_complete
         else:
             whole_frame_percent = (self.current_frame - self.start_frame) / self.total_frames

src/engines/blender/scripts/get_file_info.py

@@ -19,8 +19,8 @@ for cam_obj in bpy.data.cameras:
 
 data = {'cameras':  cameras,
         'engine': scene.render.engine,
-        'frame_start': scene.frame_start,
+        'start_frame': scene.frame_start,
-        'frame_end': scene.frame_end,
+        'end_frame': scene.frame_end,
         'resolution_x': scene.render.resolution_x,
         'resolution_y': scene.render.resolution_y,
         'resolution_percentage': scene.render.resolution_percentage,

src/engines/core/base_downloader.py

@@ -1,7 +1,9 @@
 import logging
 import os
 import shutil
+import tarfile
 import tempfile
+import zipfile
 
 import requests
 from tqdm import tqdm
@@ -10,150 +12,26 @@ logger = logging.getLogger()
 
 
 class EngineDownloader:
-    """A class responsible for downloading and extracting rendering engines from publicly available URLs.
-
-    Attributes:
-        supported_formats (list[str]): A list of file formats supported by the downloader.
-    """
 
     supported_formats = ['.zip', '.tar.xz', '.dmg']
 
     def __init__(self):
         pass
 
-    # --------------------------------------------
-    # Required Overrides for Subclasses:
-    # --------------------------------------------
-
     @classmethod
     def find_most_recent_version(cls, system_os=None, cpu=None, lts_only=False):
-        """
+        raise NotImplementedError  # implement this method in your engine subclass
-        Finds the most recent version of the rendering engine available for download.
-
-        This method should be overridden in a subclass to implement the logic for determining
-        the most recent version of the rendering engine, optionally filtering by long-term
-        support (LTS) versions, the operating system, and CPU architecture.
-
-        Args:
-            system_os (str, optional): Desired OS ('linux', 'macos', 'windows'). Defaults to system os.
-            cpu (str, optional): The CPU architecture for which to download the engine. Default is system cpu.
-            lts_only (bool, optional): Limit the search to LTS (long-term support) versions only. Default is False.
-
-        Returns:
-            dict: A dict with the following keys:
-                - 'cpu' (str): The CPU architecture.
-                - 'system_os' (str): The operating system.
-                - 'file' (str): The filename of the version's download file.
-                - 'url' (str): The remote URL for downloading the version.
-                - 'version' (str): The version number.
-
-        Raises:
-            NotImplementedError: If the method is not overridden in a subclass.
-        """
-        raise NotImplementedError(f"find_most_recent_version not implemented for {cls.__class__.__name__}")
 
     @classmethod
     def version_is_available_to_download(cls, version, system_os=None, cpu=None):
-        """Checks if a requested version of the rendering engine is available for download.
+        raise NotImplementedError  # implement this method in your engine subclass
-
-        This method should be overridden in a subclass to implement the logic for determining
-        whether a given version of the rendering engine is available for download, based on the
-        operating system and CPU architecture.
-
-        Args:
-            version (str): The requested renderer version to download.
-            system_os (str, optional): Desired OS ('linux', 'macos', 'windows'). Defaults to system os.
-            cpu (str, optional): The CPU architecture for which to download the engine. Default is system cpu.
-
-        Returns:
-            bool: True if the version is available for download, False otherwise.
-
-        Raises:
-            NotImplementedError: If the method is not overridden in a subclass.
-        """
-        raise NotImplementedError(f"version_is_available_to_download not implemented for {cls.__class__.__name__}")
 
     @classmethod
     def download_engine(cls, version, download_location, system_os=None, cpu=None, timeout=120):
-        """Downloads the requested version of the rendering engine to the given download location.
+        raise NotImplementedError  # implement this method in your engine subclass
-
-        This method should be overridden in a subclass to implement the logic for downloading
-        a specific version of the rendering engine. The method is intended to handle the
-        downloading process based on the version, operating system, CPU architecture, and
-        timeout parameters.
-
-        Args:
-            version (str): The requested renderer version to download.
-            download_location (str): The directory where the engine should be downloaded.
-            system_os (str, optional): Desired OS ('linux', 'macos', 'windows'). Defaults to system os.
-            cpu (str, optional): The CPU architecture for which to download the engine. Default is system cpu.
-            timeout (int, optional): The maximum time in seconds to wait for the download. Default is 120 seconds.
-
-        Raises:
-            NotImplementedError: If the method is not overridden in a subclass.
-        """
-        raise NotImplementedError(f"download_engine not implemented for {cls.__class__.__name__}")
-
-    # --------------------------------------------
-    # Optional Overrides for Subclasses:
-    # --------------------------------------------
-
-    @classmethod
-    def all_versions(cls, system_os=None, cpu=None):
-        """Retrieves a list of available versions of the software for a specific operating system and CPU architecture.
-
-        This method fetches all available versions for the given operating system and CPU type, constructing
-        a list of dictionaries containing details such as the version, CPU architecture, system OS, and the
-        remote URL for downloading each version.
-
-        Args:
-            system_os (str, optional): Desired OS ('linux', 'macos', 'windows'). Defaults to system os.
-            cpu (str, optional): The CPU architecture for which to download the engine. Default is system cpu.
-
-        Returns:
-            list[dict]: A list of dictionaries, each containing:
-                - 'cpu' (str): The CPU architecture.
-                - 'file' (str): The filename of the version's download file.
-                - 'system_os' (str): The operating system.
-                - 'url' (str): The remote URL for downloading the version.
-                - 'version' (str): The version number.
-        """
-        return []
-
-    # --------------------------------------------
-    # Do Not Override These Methods:
-    # --------------------------------------------
 
     @classmethod
     def download_and_extract_app(cls, remote_url, download_location, timeout=120):
-        """Downloads an application from the given remote URL and extracts it to the specified location.
-
-        This method handles the downloading of the application, supports multiple archive formats,
-        and extracts the contents to the specified `download_location`. It also manages temporary
-        files and logs progress throughout the process.
-
-        Args:
-            remote_url (str): The URL of the application to download.
-            download_location (str): The directory where the application should be extracted.
-            timeout (int, optional): The maximum time in seconds to wait for the download. Default is 120 seconds.
-
-        Returns:
-            str: The path to the directory where the application was extracted.
-
-        Raises:
-            Exception: Catches and logs any exceptions that occur during the download or extraction process.
-
-        Supported Formats:
-            - `.tar.xz`: Extracted using the `tarfile` module.
-            - `.zip`: Extracted using the `zipfile` module.
-            - `.dmg`: macOS disk image files, handled using the `dmglib` library.
-            - Other formats will result in an error being logged.
-
-        Notes:
-            - If the application already exists in the `download_location`, the method will log an error
-              and return without downloading or extracting.
-            - Temporary files created during the download process are cleaned up after completion.
-        """
 
         # Create a temp download directory
         temp_download_dir = tempfile.mkdtemp()
@@ -202,7 +80,6 @@ class EngineDownloader:
             # Extract the downloaded file
             # Process .tar.xz files
             if temp_downloaded_file_path.lower().endswith('.tar.xz'):
-                import tarfile
                 try:
                     with tarfile.open(temp_downloaded_file_path, 'r:xz') as tar:
                         tar.extractall(path=download_location)
@@ -216,7 +93,6 @@ class EngineDownloader:
 
             # Process .zip files
             elif temp_downloaded_file_path.lower().endswith('.zip'):
-                import zipfile
                 try:
                     with zipfile.ZipFile(temp_downloaded_file_path, 'r') as zip_ref:
                         zip_ref.extractall(download_location)

src/engines/core/base_engine.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import platform
 import subprocess
 
 logger = logging.getLogger()
@@ -8,139 +7,19 @@ SUBPROCESS_TIMEOUT = 5
 
 
 class BaseRenderEngine(object):
-    """Base class for render engines. This class provides common functionality and structure for various rendering
-    engines. Create subclasses and override the methods marked below to add additional renderers
-
-    Attributes:
-        install_paths (list): A list of default installation paths where the render engine
-        might be found. This list can be populated with common paths to help locate the
-        executable on different operating systems or environments.
-    """
 
     install_paths = []
-
+    file_extensions = []
-    # --------------------------------------------
-    # Required Overrides for Subclasses:
-    # --------------------------------------------
 
     def __init__(self, custom_path=None):
         self.custom_renderer_path = custom_path
         if not self.renderer_path() or not os.path.exists(self.renderer_path()):
-            raise FileNotFoundError(f"Cannot find path to renderer for {self.name()} instance: {self.renderer_path()}")
+            raise FileNotFoundError(f"Cannot find path ({self.renderer_path()}) for renderer '{self.name()}'")
 
         if not os.access(self.renderer_path(), os.X_OK):
             logger.warning(f"Path is not executable. Setting permissions to 755 for {self.renderer_path()}")
             os.chmod(self.renderer_path(), 0o755)
 
-    def version(self):
-        """Return the version number as a string.
-
-        Returns:
-            str: Version number.
-
-        Raises:
-            NotImplementedError: If not overridden.
-        """
-        raise NotImplementedError(f"version not implemented for {self.__class__.__name__}")
-
-    def get_project_info(self, project_path, timeout=10):
-        """Extracts detailed project information from the given project path.
-
-        Args:
-            project_path (str): The path to the project file.
-            timeout (int, optional): The maximum time (in seconds) to wait for the operation. Default is 10 seconds.
-
-        Returns:
-            dict: A dictionary containing project information (subclasses should define the structure).
-
-        Raises:
-            NotImplementedError: If the method is not overridden in a subclass.
-        """
-        raise NotImplementedError(f"get_project_info not implemented for {self.__class__.__name__}")
-
-    @classmethod
-    def get_output_formats(cls):
-        """Returns a list of available output formats supported by the renderer.
-
-        Returns:
-            list[str]: A list of strings representing the available output formats.
-        """
-        raise NotImplementedError(f"get_output_formats not implemented for {cls.__name__}")
-
-    @staticmethod
-    def worker_class():  # override when subclassing to link worker class
-        raise NotImplementedError("Worker class not implemented")
-
-    # --------------------------------------------
-    # Optional Overrides for Subclasses:
-    # --------------------------------------------
-
-    def supported_extensions(self):
-        """
-        Returns:
-            list[str]: list of supported extensions
-        """
-        return []
-
-    def get_help(self):
-        """Retrieves the help documentation for the renderer.
-
-        This method runs the renderer's help command (default: '-h') and captures the output.
-        Override this method if the renderer uses a different help flag.
-
-        Returns:
-            str: The help documentation as a string.
-
-        Raises:
-            FileNotFoundError: If the renderer path is not found.
-        """
-        path = self.renderer_path()
-        if not path:
-            raise FileNotFoundError("renderer path not found")
-        creationflags = subprocess.CREATE_NO_WINDOW if platform.system() == 'Windows' else 0
-        help_doc = subprocess.check_output([path, '-h'], stderr=subprocess.STDOUT,
-                                           timeout=SUBPROCESS_TIMEOUT, creationflags=creationflags).decode('utf-8')
-        return help_doc
-
-    def system_info(self):
-        """Return additional information about the system specfic to the engine (configured GPUs, render engines, etc)
-
-        Returns:
-            dict: A dictionary with engine-specific system information
-        """
-        return {}
-
-    def perform_presubmission_tasks(self, project_path):
-        """Perform any pre-submission tasks on a project file before uploading it to a server (pack textures, etc.)
-
-        Override this method to:
-            1. Copy the project file to a temporary location (DO NOT MODIFY ORIGINAL PATH).
-            2. Perform additional modifications or tasks.
-            3. Return the path to the modified project file.
-
-        Args:
-            project_path (str): The original project file path.
-
-        Returns:
-            str: The path to the modified project file.
-        """
-        return project_path
-
-    def get_arguments(self):
-        pass
-
-    @staticmethod
-    def downloader():  # override when subclassing if using a downloader class
-        return None
-
-    @staticmethod
-    def ui_options(system_info):  # override to return options for ui
-        return {}
-
-    # --------------------------------------------
-    # Do Not Override These Methods:
-    # --------------------------------------------
-
     def renderer_path(self):
         return self.custom_renderer_path or self.default_renderer_path()
 
@@ -160,3 +39,44 @@ class BaseRenderEngine(object):
         except Exception as e:
             logger.exception(e)
         return path
+
+    def version(self):
+        raise NotImplementedError("version not implemented")
+
+    @staticmethod
+    def downloader():  # override when subclassing if using a downloader class
+        return None
+
+    @classmethod
+    def worker_class(cls):  # override when subclassing to link worker class
+        raise NotImplementedError(f"Worker class not implemented for engine {cls.name()}")
+
+    def ui_options(self, project_info):  # override to return options for ui
+        return {}
+
+    def get_help(self):  # override if renderer uses different help flag
+        path = self.renderer_path()
+        if not path:
+            raise FileNotFoundError("renderer path not found")
+        help_doc = subprocess.run([path, '-h'], capture_output=True, text=True).stdout.strip()
+        return help_doc
+
+    def get_project_info(self, project_path, timeout=10):
+        raise NotImplementedError(f"get_project_info not implemented for {self.__name__}")
+
+    @classmethod
+    def get_output_formats(cls):
+        raise NotImplementedError(f"get_output_formats not implemented for {cls.__name__}")
+
+    @classmethod
+    def supported_extensions(cls):
+        return cls.file_extensions
+
+    def get_arguments(self):
+        pass
+
+    def system_info(self):
+        pass
+
+    def perform_presubmission_tasks(self, project_path):
+        return project_path

src/engines/core/base_worker.py

@@ -3,10 +3,8 @@ import io
 import json
 import logging
 import os
-import signal
 import subprocess
 import threading
-import time
 from datetime import datetime
 
 import psutil
@@ -48,10 +46,6 @@ class BaseRenderWorker(Base):
 
     engine = None
 
-    # --------------------------------------------
-    # Required Overrides for Subclasses:
-    # --------------------------------------------
-
     def __init__(self, input_path, output_path, engine_path, priority=2, args=None, ignore_extensions=True, parent=None,
                  name=None):
 
@@ -61,7 +55,7 @@ class BaseRenderWorker(Base):
                 logger.error(err_meg)
                 raise ValueError(err_meg)
         if not self.engine:
-            raise NotImplementedError(f"Engine not defined for {self.__class__.__name__}")
+            raise NotImplementedError("Engine not defined")
 
         def generate_id():
             import uuid
@@ -87,72 +81,26 @@ class BaseRenderWorker(Base):
         # Frame Ranges
         self.project_length = 0  # is this necessary?
         self.current_frame = 0
-        self.start_frame = 0
+
-        self.end_frame = None
+        # Get Project Info
+        self.scene_info = self.engine(engine_path).get_project_info(project_path=input_path)
+        self.start_frame = int(self.scene_info.get('start_frame', 1))
+        self.end_frame = int(self.scene_info.get('end_frame', self.start_frame))
 
         # Logging
         self.start_time = None
         self.end_time = None
 
         # History
-        self.status = RenderStatus.CONFIGURING
+        self.status = RenderStatus.NOT_STARTED
         self.warnings = []
         self.errors = []
 
         # Threads and processes
-        self.__thread = threading.Thread(target=self.__run, args=())
+        self.__thread = threading.Thread(target=self.run, args=())
         self.__thread.daemon = True
         self.__process = None
         self.last_output = None
-        self.__last_output_time = None
-        self.watchdog_timeout = 120
-
-    def generate_worker_subprocess(self):
-        """Generate a return a list of the command line arguments necessary to perform requested job
-        
-        Returns:
-            list[str]: list of command line arguments
-        """
-        raise NotImplementedError("generate_worker_subprocess not implemented")
-
-    def _parse_stdout(self, line):
-        """Parses a line of standard output from the renderer.
-
-        This method should be overridden in a subclass to implement the logic for processing
-        and interpreting a single line of output from the renderer's standard output stream.
-
-        On frame completion, the subclass should:
-            1. Update value of self.current_frame
-            2. Call self._send_frame_complete_notification()
-
-        Args:
-            line (str): A line of text from the renderer's standard output.
-
-        Raises:
-            NotImplementedError: If the method is not overridden in a subclass.
-        """
-        raise NotImplementedError(f"_parse_stdout not implemented for {self.__class__.__name__}")
-
-    # --------------------------------------------
-    # Optional Overrides for Subclasses:
-    # --------------------------------------------
-
-    def percent_complete(self):
-        # todo: fix this
-        if self.status == RenderStatus.COMPLETED:
-            return 1.0
-        return 0
-
-    def post_processing(self):
-        """Override to perform any engine-specific postprocessing"""
-        pass
-
-    # --------------------------------------------
-    # Do Not Override These Methods:
-    # --------------------------------------------
-
-    def __repr__(self):
-        return f"<Job id:{self.id} p{self.priority} {self.renderer}-{self.renderer_version} '{self.name}' status:{self.status.value}>"
 
     @property
     def total_frames(self):
@@ -176,27 +124,33 @@ class BaseRenderWorker(Base):
                 self._status = RenderStatus.CANCELLED.value
         return string_to_status(self._status)
 
-    def _send_frame_complete_notification(self):
+    def validate(self):
-        pub.sendMessage('frame_complete', job_id=self.id, frame_number=self.current_frame)
+        if not os.path.exists(self.input_path):
+            raise FileNotFoundError(f"Cannot find input path: {self.input_path}")
+        self.generate_subprocess()
 
     def generate_subprocess(self):
         # Convert raw args from string if available and catch conflicts
         generated_args = [str(x) for x in self.generate_worker_subprocess()]
         generated_args_flags = [x for x in generated_args if x.startswith('-')]
         if len(generated_args_flags) != len(set(generated_args_flags)):
-            msg = f"Cannot generate subprocess - Multiple arg conflicts detected: {generated_args}"
+            msg = "Cannot generate subprocess - Multiple arg conflicts detected"
             logger.error(msg)
+            logger.debug(f"Generated args for subprocess: {generated_args}")
             raise ValueError(msg)
         return generated_args
 
     def get_raw_args(self):
-        raw_args_string = self.args.get('raw', '')
+        raw_args_string = self.args.get('raw', None)
         raw_args = None
         if raw_args_string:
             import shlex
             raw_args = shlex.split(raw_args_string)
         return raw_args
 
+    def generate_worker_subprocess(self):
+        raise NotImplementedError("generate_worker_subprocess not implemented")
+
     def log_path(self):
         filename = (self.name or os.path.basename(self.input_path)) + '_' + \
                    self.date_created.strftime("%Y.%m.%d_%H.%M.%S") + '.log'
@@ -204,7 +158,7 @@ class BaseRenderWorker(Base):
 
     def start(self):
 
-        if self.status not in [RenderStatus.SCHEDULED, RenderStatus.NOT_STARTED, RenderStatus.CONFIGURING]:
+        if self.status not in [RenderStatus.SCHEDULED, RenderStatus.NOT_STARTED]:
             logger.error(f"Trying to start job with status: {self.status}")
             return
 
@@ -222,18 +176,27 @@ class BaseRenderWorker(Base):
             self.errors.append(msg)
             return
 
-        self.status = RenderStatus.RUNNING if not self.children else RenderStatus.WAITING_FOR_SUBJOBS
+        self.status = RenderStatus.RUNNING
         self.start_time = datetime.now()
+        logger.info(f'Starting {self.engine.name()} {self.renderer_version} Render for {self.input_path} | '
+                    f'Frame Count: {self.total_frames}')
         self.__thread.start()
 
-    # handle multiple attempts at running subprocess
+    def run(self):
-    def __run__subprocess_cycle(self, log_file):
+        # Setup logging
+        log_dir = os.path.dirname(self.log_path())
+        os.makedirs(log_dir, exist_ok=True)
+
         subprocess_cmds = self.generate_subprocess()
         initial_file_count = len(self.file_list())
         failed_attempts = 0
 
-        log_file.write(f"Running command: {subprocess_cmds}\n")
+        with open(self.log_path(), "a") as f:
-        log_file.write('=' * 80 + '\n\n')
+
+            f.write(f"{self.start_time.isoformat()} - Starting {self.engine.name()} {self.renderer_version} "
+                    f"render for {self.input_path}\n\n")
+            f.write(f"Running command: \"{' '.join(subprocess_cmds)}\"\n")
+            f.write('=' * 80 + '\n\n')
 
             while True:
                 # Log attempt #
@@ -245,195 +208,69 @@ class BaseRenderWorker(Base):
                         self.errors.append(err_msg)
                         return
                     else:
-                    log_file.write(f'\n{"=" * 20} Attempt #{failed_attempts + 1} {"=" * 20}\n\n')
+                        f.write(f'\n{"=" * 20} Attempt #{failed_attempts + 1} {"=" * 20}\n\n')
                         logger.warning(f"Restarting render - Attempt #{failed_attempts + 1}")
-                    self.status = RenderStatus.RUNNING
 
-            return_code = self.__setup_and_run_process(log_file, subprocess_cmds)
-
-            message = f"{'=' * 50}\n\n{self.engine.name()} render ended with code {return_code} " \
-                      f"after {self.time_elapsed()}\n\n"
-            log_file.write(message)
-
-            # don't try again if we've been cancelled
-            if self.status in [RenderStatus.CANCELLED, RenderStatus.ERROR]:
-                return
-
-            # if file output hasn't increased, return as error, otherwise restart process.
-            file_count_has_increased = len(self.file_list()) > initial_file_count
-            if (self.status == RenderStatus.RUNNING) and file_count_has_increased and not return_code:
-                break
-
-            if return_code:
-                err_msg = f"{self.engine.name()} render failed with code {return_code}"
-                logger.error(err_msg)
-                self.errors.append(err_msg)
-
-            # handle instances where renderer exits ok but doesnt generate files
-            if not return_code and not file_count_has_increased:
-                err_msg = (f"{self.engine.name()} render exited ok, but file count has not increased. "
-                           f"Count is still {len(self.file_list())}")
-                log_file.write(f'Error: {err_msg}\n\n')
-                self.errors.append(err_msg)
-
-            # only count the attempt as failed if renderer creates no output - reset counter on successful output
-            failed_attempts = 0 if file_count_has_increased else failed_attempts + 1
-
-    def __run__wait_for_subjobs(self, logfile):
-        from src.distributed_job_manager import DistributedJobManager
-        DistributedJobManager.wait_for_subjobs(parent_job=self)
-
-    @staticmethod
-    def log_and_print(message, log_file, level='info'):
-        if level == 'debug':
-            logger.debug(message)
-        elif level == 'error':
-            logger.error(message)
-        else:
-            logger.info(message)
-        log_file.write(f"{message}\n")
-
-    def __run(self):
-
-        # Setup logging
-        log_dir = os.path.dirname(self.log_path())
-        os.makedirs(log_dir, exist_ok=True)
-
-        with open(self.log_path(), "a") as log_file:
-
-            self.log_and_print(f"{self.start_time.isoformat()} - Starting "
-                               f"{self.engine.name()} {self.renderer_version} render job for {self.name} "
-                               f"({self.input_path})", log_file)
-            log_file.write(f"\n")
-            if not self.children:
-                self.__run__subprocess_cycle(log_file)
-            else:
-                self.__run__wait_for_subjobs(log_file)
-
-            # Validate Output - End if missing frames
-            if self.status == RenderStatus.RUNNING:
-                file_list_length = len(self.file_list())
-                expected_list_length = (self.end_frame - self.start_frame + 1) if self.end_frame else 1
-
-                msg = f"Frames: Expected ({expected_list_length}) vs actual ({file_list_length}) for {self}"
-                self.log_and_print(msg, log_file, 'debug')
-
-                if file_list_length not in (expected_list_length, 1):
-                    msg = f"Missing frames: Expected ({expected_list_length}) vs actual ({file_list_length})"
-                    self.log_and_print(msg, log_file, 'error')
-                    self.errors.append(msg)
-                    self.status = RenderStatus.ERROR
-                    # todo: create new subjob to generate missing frames
-
-            # cleanup and close if cancelled / error
-            if self.status in [RenderStatus.CANCELLED, RenderStatus.ERROR]:
-                self.end_time = datetime.now()
-                message = f"{self.engine.name()} render ended with status '{self.status.value}' " \
-                          f"after {self.time_elapsed()}"
-                self.log_and_print(message, log_file)
-                log_file.close()
-                return
-
-            # Post Render Work
-            if not self.parent:
-                logger.debug(f"Starting post-processing work for {self}")
-                self.log_and_print(f"Starting post-processing work for {self}", log_file, 'debug')
-                self.post_processing()
-                self.log_and_print(f"Completed post-processing work for {self}", log_file, 'debug')
-
-            self.status = RenderStatus.COMPLETED
-            self.end_time = datetime.now()
-            message = f"Render {self.name} completed successfully after {self.time_elapsed()}"
-            self.log_and_print(message, log_file)
-
-    def __setup_and_run_process(self, f, subprocess_cmds):
-
-        def watchdog():
-            logger.debug(f'Starting process watchdog for {self} with {self.watchdog_timeout}s timeout')
-            while self.__process.poll() is None:
-                time_since_last_update = time.time() - self.__last_output_time
-                if time_since_last_update > self.watchdog_timeout:
-                    logger.error(f"Process for {self} terminated due to exceeding timeout ({self.watchdog_timeout}s)")
-                    self.__kill_process()
-                    break
-                # logger.debug(f'Watchdog for {self} - Time since last update: {time_since_last_update}')
-                time.sleep(1)
-
-            logger.debug(f'Stopping process watchdog for {self}')
-
-        return_code = -1
-        watchdog_thread = threading.Thread(target=watchdog)
-        watchdog_thread.daemon = True
-
-        try:
                 # Start process and get updates
-            if os.name == 'posix':  # linux / mac
+                self.status = RenderStatus.RUNNING
                 self.__process = subprocess.Popen(subprocess_cmds, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                                                  universal_newlines=False, preexec_fn=os.setsid)
+                                                  universal_newlines=False)
-            else:  # windows
-                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW
-                self.__process = subprocess.Popen(subprocess_cmds, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                                                  universal_newlines=False,
-                                                  creationflags=creationflags)
-
-            # Start watchdog
-            self.__last_output_time = time.time()
-            watchdog_thread.start()
 
                 for c in io.TextIOWrapper(self.__process.stdout, encoding="utf-8"):  # or another encoding
-                self.last_output = c.strip()
-                self.__last_output_time = time.time()
-                try:
                     f.write(c)
                     f.flush()
                     os.fsync(f.fileno())
-                except Exception as e:
+                    self.last_output = c.strip()
-                    logger.error(f"Error saving log to disk: {e}")
-
-                try:
                     self._parse_stdout(c.strip())
-                except Exception as e:
-                    logger.error(f'Error parsing stdout: {e}')
 
                 f.write('\n')
 
                 # Check return codes and process
                 return_code = self.__process.wait()
-        except Exception as e:
+                self.end_time = datetime.now()
-            message = f'Uncaught error running render process: {e}'
+
+                if self.status in [RenderStatus.CANCELLED, RenderStatus.ERROR]:  # user cancelled
+                    message = f"{self.engine.name()} render ended with status '{self.status}' " \
+                              f"after {self.time_elapsed()}"
                     f.write(message)
-            logger.exception(message)
-            self.__kill_process()
-
-        # let watchdog end before continuing - prevents multiple watchdogs running when process restarts
-        if watchdog_thread.is_alive():
-            watchdog_thread.join()
-
-        return return_code
-
-    def __kill_process(self):
-        try:
-            if self.__process.poll():
                     return
-            logger.debug(f"Trying to kill process {self.__process}")
+
-            self.__process.terminate()
+                # if file output hasn't increased, return as error, otherwise restart process.
-            self.__process.kill()
+                if len(self.file_list()) <= initial_file_count:
-            if os.name == 'posix':  # linux / macos
+                    err_msg = f"File count has not increased. Count is still {len(self.file_list())}"
-                os.killpg(os.getpgid(self.__process.pid), signal.SIGTERM)
+                    f.write(f'Error: {err_msg}\n\n')
-                os.killpg(os.getpgid(self.__process.pid), signal.SIGKILL)
+                    self.errors.append(err_msg)
-            else:  # windows
+                    self.status = RenderStatus.ERROR
-                parent = psutil.Process(self.__process.pid)
+
-                for child in parent.children(recursive=True):
+                # Handle completed - All else counts as failed attempt
-                    child.kill()
+                if (self.status == RenderStatus.COMPLETED) and not return_code:
-            self.__process.wait(timeout=5)
+                    message = (f"{'=' * 50}\n\n{self.engine.name()} render completed successfully in "
-            logger.debug(f"Process ended with status {self.__process.poll()}")
+                               f"{self.time_elapsed()}\n")
-        except (ProcessLookupError, AttributeError, psutil.NoSuchProcess):
+                    f.write(message)
+                    break
+
+                # Handle non-zero return codes
+                message = f"{'=' * 50}\n\n{self.engine.name()} render failed with code {return_code} " \
+                          f"after {self.time_elapsed()}\n\n"
+                f.write(message)
+                self.errors.append(message)
+                failed_attempts += 1
+
+        if self.children:
+            from src.distributed_job_manager import DistributedJobManager
+            DistributedJobManager.wait_for_subjobs(local_job=self)
+
+        # Post Render Work
+        logger.debug("Starting post-processing work")
+        self.post_processing()
+        self.status = RenderStatus.COMPLETED
+        logger.info(f"Render {self.id}-{self.name} completed successfully after {self.time_elapsed()}")
+
+    def post_processing(self):
         pass
-        except Exception as e:
-            logger.error(f"Error stopping the process: {e}")
 
     def is_running(self):
-        if hasattr(self, '__thread'):
+        if self.__thread:
             return self.__thread.is_alive()
         return False
 
@@ -444,11 +281,15 @@ class BaseRenderWorker(Base):
             self.stop(is_error=True)
 
     def stop(self, is_error=False):
-        logger.debug(f"Stopping {self}")
+        if hasattr(self, '__process'):
-
+            try:
-        # cleanup status
+                process = psutil.Process(self.__process.pid)
-        if self.status in [RenderStatus.RUNNING, RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED,
+                for proc in process.children(recursive=True):
-                           RenderStatus.CONFIGURING]:
+                    proc.kill()
+                process.kill()
+            except Exception as e:
+                logger.debug(f"Error stopping the process: {e}")
+        if self.status in [RenderStatus.RUNNING, RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED]:
             if is_error:
                 err_message = self.errors[-1] if self.errors else 'Unknown error'
                 logger.error(f"Halting render due to error: {err_message}")
@@ -456,9 +297,13 @@ class BaseRenderWorker(Base):
             else:
                 self.status = RenderStatus.CANCELLED
 
-        self.__kill_process()
+    def percent_complete(self):
-        if self.is_running():  # allow the log files to close
+        if self.status == RenderStatus.COMPLETED:
-            self.__thread.join(timeout=5)
+            return 1.0
+        return 0
+
+    def _parse_stdout(self, line):
+        raise NotImplementedError("_parse_stdout not implemented")
 
     def time_elapsed(self):
         return get_time_elapsed(self.start_time, self.end_time)
@@ -466,11 +311,7 @@ class BaseRenderWorker(Base):
     def file_list(self):
         try:
             job_dir = os.path.dirname(self.output_path)
-            file_list = [
+            file_list = [os.path.join(job_dir, file) for file in os.listdir(job_dir)]
-                os.path.join(job_dir, file)
-                for file in os.listdir(job_dir)
-                if not file.startswith('.')  # Ignore hidden files
-            ]
             file_list.sort()
             return file_list
         except FileNotFoundError:

src/engines/engine_manager.py

@@ -6,22 +6,20 @@ import concurrent.futures
 
 from src.engines.blender.blender_engine import Blender
 from src.engines.ffmpeg.ffmpeg_engine import FFMPEG
+from src.engines.aerender.aerender_engine import AERender
 from src.utilities.misc_helper import system_safe_path, current_system_os, current_system_cpu
 
 logger = logging.getLogger()
 
 
 class EngineManager:
-    """Class that manages different versions of installed renderers and handles fetching and downloading new versions,
-    if possible.
-    """
 
     engines_path = None
     download_tasks = []
 
     @staticmethod
     def supported_engines():
-        return [Blender, FFMPEG]
+        return [Blender, FFMPEG, AERender]
 
     @classmethod
     def engine_with_name(cls, engine_name):
@@ -30,7 +28,7 @@ class EngineManager:
                 return obj
 
     @classmethod
-    def get_engines(cls, filter_name=None, include_corrupt=False):
+    def get_engines(cls, filter_name=None):
 
         if not cls.engines_path:
             raise FileNotFoundError("Engine path is not set")
@@ -52,8 +50,10 @@ class EngineManager:
                 # Initialize binary_name with engine name
                 binary_name = result_dict['engine'].lower()
                 # Determine the correct binary name based on the engine and system_os
-                eng = cls.engine_with_name(result_dict['engine'])
+                for eng in cls.supported_engines():
+                    if eng.name().lower() == result_dict['engine']:
                         binary_name = eng.binary_names.get(result_dict['system_os'], binary_name)
+                        break
 
                 # Find the path to the binary file
                 path = next(
@@ -61,16 +61,8 @@ class EngineManager:
                      os.walk(system_safe_path(os.path.join(cls.engines_path, directory))) if binary_name in files),
                     None
                 )
+
                 result_dict['path'] = path
-
-                # fetch version number from binary - helps detect corrupted downloads
-                binary_version = eng(path).version()
-                if not binary_version:
-                    logger.warning(f"Possible corrupt {eng.name()} {result_dict['version']} install detected: {path}")
-                    if not include_corrupt:
-                        continue
-                result_dict['version'] = binary_version or 'error'
-
                 # Add the result dictionary to results if it matches the filter_name or if no filter is applied
                 if not filter_name or filter_name == result_dict['engine']:
                     results.append(result_dict)
@@ -78,37 +70,36 @@ class EngineManager:
             logger.warning(f"Cannot find local engines download directory: {e}")
 
         # add system installs to this list - use bg thread because it can be slow
-        def fetch_engine_details(eng, include_corrupt=False):
+        def fetch_engine_details(eng):
-            version = eng().version()
-            if not version and not include_corrupt:
-                return
-
             return {
                 'engine': eng.name(),
-                'version': version or 'error',
+                'version': eng().version(),
                 'system_os': current_system_os(),
                 'cpu': current_system_cpu(),
                 'path': eng.default_renderer_path(),
                 'type': 'system'
             }
 
+        if not filter_name:
             with concurrent.futures.ThreadPoolExecutor() as executor:
                 futures = {
-                executor.submit(fetch_engine_details, eng, include_corrupt): eng.name()
+                    executor.submit(fetch_engine_details, eng): eng.name()
                     for eng in cls.supported_engines()
-                if eng.default_renderer_path() and (not filter_name or filter_name == eng.name())
+                    if eng.default_renderer_path()
                 }
 
                 for future in concurrent.futures.as_completed(futures):
                     result = future.result()
                     if result:
                         results.append(result)
+        else:
+            results.append(fetch_engine_details(cls.engine_with_name(filter_name)))
 
         return results
 
     @classmethod
-    def all_versions_for_engine(cls, engine_name, include_corrupt=False):
+    def all_versions_for_engine(cls, engine_name):
-        versions = cls.get_engines(filter_name=engine_name, include_corrupt=include_corrupt)
+        versions = cls.get_engines(filter_name=engine_name)
         sorted_versions = sorted(versions, key=lambda x: x['version'], reverse=True)
         return sorted_versions
 
@@ -185,7 +176,7 @@ class EngineManager:
 
         if background:
             return thread
-
+        else:
             thread.join()
             found_engine = cls.is_version_downloaded(engine, version, system_os, cpu)  # Check that engine downloaded
             if not found_engine:
@@ -217,19 +208,13 @@ class EngineManager:
         def engine_update_task(engine_class):
             logger.debug(f"Checking for updates to {engine_class.name()}")
             latest_version = engine_class.downloader().find_most_recent_version()
-
+            if latest_version:
-            if not latest_version:
+                logger.debug(f"Latest version of {engine_class.name()} available: {latest_version.get('version')}")
-                logger.warning(f"Could not find most recent version of {engine.name()} to download")
+                if not cls.is_version_downloaded(engine_class.name(), latest_version.get('version')):
-                return
+                    logger.info(f"Downloading latest version of {engine_class.name()}...")
-
+                    cls.download_engine(engine=engine_class.name(), version=latest_version['version'], background=True)
-            version_num = latest_version.get('version')
+            else:
-            if cls.is_version_downloaded(engine_class.name(), version_num):
+                logger.warning(f"Unable to get check for updates for {engine.name()}")
-                logger.debug(f"Latest version of {engine_class.name()} ({version_num}) already downloaded")
-                return
-
-            # download the engine
-            logger.info(f"Downloading latest version of {engine_class.name()} ({version_num})...")
-            cls.download_engine(engine=engine_class.name(), version=version_num, background=True)
 
         logger.info(f"Checking for updates for render engines...")
         threads = []
@@ -279,24 +264,13 @@ class EngineManager:
         _, extension = os.path.splitext(path)
         extension = extension.lower().strip('.')
         for engine in cls.supported_engines():
-            if extension in engine().supported_extensions():
+            if extension in engine.supported_extensions():
                 return engine
-        undefined_renderer_support = [x for x in cls.supported_engines() if not x().supported_extensions()]
+        undefined_renderer_support = [x for x in cls.supported_engines() if not x.supported_extensions()]
         return undefined_renderer_support[0]
 
 
 class EngineDownloadWorker(threading.Thread):
-    """A thread worker for downloading a specific version of a rendering engine.
-
-    This class handles the process of downloading a rendering engine in a separate thread,
-    ensuring that the download process does not block the main application.
-
-    Attributes:
-        engine (str): The name of the rendering engine to download.
-        version (str): The version of the rendering engine to download.
-        system_os (str, optional): The operating system for which to download the engine. Defaults to current OS type.
-        cpu (str, optional): Requested CPU architecture. Defaults to system CPU type.
-    """
     def __init__(self, engine, version, system_os=None, cpu=None):
         super().__init__()
         self.engine = engine
@@ -305,7 +279,6 @@ class EngineDownloadWorker(threading.Thread):
         self.cpu = cpu
 
     def run(self):
-        try:
         existing_download = EngineManager.is_version_downloaded(self.engine, self.version, self.system_os, self.cpu)
         if existing_download:
             logger.info(f"Requested download of {self.engine} {self.version}, but local copy already exists")
@@ -315,9 +288,7 @@ class EngineDownloadWorker(threading.Thread):
         EngineManager.engine_with_name(self.engine).downloader().download_engine(
             self.version, download_location=EngineManager.engines_path, system_os=self.system_os, cpu=self.cpu,
             timeout=300)
-        except Exception as e:
+
-            logger.error(f"Error in download worker: {e}")
-        finally:
         # remove itself from the downloader list
         EngineManager.download_tasks.remove(self)
 
@@ -327,6 +298,6 @@ if __name__ == '__main__':
 
     # print(EngineManager.newest_engine_version('blender', 'macos', 'arm64'))
     # EngineManager.delete_engine_download('blender', '3.2.1', 'macos', 'a')
-    EngineManager.engines_path = "/Users/brettwilliams/zordon-uploads/engines"
+    EngineManager.engines_path = "/Users/brettwilliams/zordon-uploads/engines/"
     # print(EngineManager.is_version_downloaded("ffmpeg", "6.0"))
     print(EngineManager.get_engines())

src/engines/ffmpeg/ffmpeg_downloader.py

@@ -132,8 +132,8 @@ class FFMPEGDownloader(EngineDownloader):
             system_os = system_os or current_system_os()
             cpu = cpu or current_system_cpu()
             return cls.all_versions(system_os, cpu)[0]
-        except (IndexError, requests.exceptions.RequestException) as e:
+        except (IndexError, requests.exceptions.RequestException):
-            logger.error(f"Cannot get most recent version of ffmpeg: {e}")
+            logger.error(f"Cannot get most recent version of ffmpeg")
         return {}
 
     @classmethod

src/engines/ffmpeg/ffmpeg_engine.py

@@ -3,8 +3,6 @@ import re
 
 from src.engines.core.base_engine import *
 
-_creationflags = subprocess.CREATE_NO_WINDOW if platform.system() == 'Windows' else 0
-
 
 class FFMPEG(BaseRenderEngine):
     binary_names = {'linux': 'ffmpeg', 'windows': 'ffmpeg.exe', 'macos': 'ffmpeg'}
@@ -14,29 +12,32 @@ class FFMPEG(BaseRenderEngine):
         from src.engines.ffmpeg.ffmpeg_downloader import FFMPEGDownloader
         return FFMPEGDownloader
 
-    @staticmethod
+    @classmethod
-    def worker_class():
+    def worker_class(cls):
         from src.engines.ffmpeg.ffmpeg_worker import FFMPEGRenderWorker
         return FFMPEGRenderWorker
 
-    def ui_options(self):
+    def ui_options(self, project_info):
         from src.engines.ffmpeg.ffmpeg_ui import FFMPEGUI
-        return FFMPEGUI.get_options(self)
+        return FFMPEGUI.get_options(self, project_info)
 
-    def supported_extensions(self):
+    @classmethod
-        help_text = (subprocess.check_output([self.renderer_path(), '-h', 'full'], stderr=subprocess.STDOUT,
+    def supported_extensions(cls):
-                                             creationflags=_creationflags).decode('utf-8'))
+        if not cls.file_extensions:
+            help_text = (subprocess.check_output([cls().renderer_path(), '-h', 'full'], stderr=subprocess.STDOUT)
+                         .decode('utf-8'))
             found = re.findall(r'extensions that .* is allowed to access \(default "(.*)"', help_text)
             found_extensions = set()
             for match in found:
                 found_extensions.update(match.split(','))
-        return list(found_extensions)
+            cls.file_extensions = list(found_extensions)
+        return cls.file_extensions
 
     def version(self):
         version = None
         try:
-            ver_out = subprocess.check_output([self.renderer_path(), '-version'], timeout=SUBPROCESS_TIMEOUT,
+            ver_out = subprocess.check_output([self.renderer_path(), '-version'],
-                                              creationflags=_creationflags).decode('utf-8')
+                                              timeout=SUBPROCESS_TIMEOUT).decode('utf-8')
             match = re.match(r".*version\s*([\w.*]+)\W*", ver_out)
             if match:
                 version = match.groups()[0]
@@ -51,8 +52,7 @@ class FFMPEG(BaseRenderEngine):
                 'ffprobe', '-v', 'quiet', '-print_format', 'json',
                 '-show_streams', '-select_streams', 'v', project_path
             ]
-            output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, text=True,
+            output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, text=True)
-                                             creationflags=_creationflags)
             video_info = json.loads(output)
 
             # Extract the necessary information
@@ -83,7 +83,7 @@ class FFMPEG(BaseRenderEngine):
 
     def get_encoders(self):
         raw_stdout = subprocess.check_output([self.renderer_path(), '-encoders'], stderr=subprocess.DEVNULL,
-                                             timeout=SUBPROCESS_TIMEOUT, creationflags=_creationflags).decode('utf-8')
+                                             timeout=SUBPROCESS_TIMEOUT).decode('utf-8')
         pattern = r'(?P<type>[VASFXBD.]{6})\s+(?P<name>\S{2,})\s+(?P<description>.*)'
         encoders = [m.groupdict() for m in re.finditer(pattern, raw_stdout)]
         return encoders
@@ -95,8 +95,7 @@ class FFMPEG(BaseRenderEngine):
     def get_all_formats(self):
         try:
             formats_raw = subprocess.check_output([self.renderer_path(), '-formats'], stderr=subprocess.DEVNULL,
-                                                  timeout=SUBPROCESS_TIMEOUT,
+                                                  timeout=SUBPROCESS_TIMEOUT).decode('utf-8')
-                                                  creationflags=_creationflags).decode('utf-8')
             pattern = r'(?P<type>[DE]{1,2})\s+(?P<id>\S{2,})\s+(?P<name>.*)'
             all_formats = [m.groupdict() for m in re.finditer(pattern, formats_raw)]
             return all_formats
@@ -108,8 +107,7 @@ class FFMPEG(BaseRenderEngine):
         # Extract the common extension using regex
         muxer_flag = 'muxer' if 'E' in ffmpeg_format['type'] else 'demuxer'
         format_detail_raw = subprocess.check_output(
-            [self.renderer_path(), '-hide_banner', '-h', f"{muxer_flag}={ffmpeg_format['id']}"],
+            [self.renderer_path(), '-hide_banner', '-h', f"{muxer_flag}={ffmpeg_format['id']}"]).decode('utf-8')
-            creationflags=_creationflags).decode('utf-8')
         pattern = r"Common extensions: (\w+)"
         common_extensions = re.findall(pattern, format_detail_raw)
         found_extensions = []
@@ -123,7 +121,7 @@ class FFMPEG(BaseRenderEngine):
     def get_frame_count(self, path_to_file):
         raw_stdout = subprocess.check_output([self.renderer_path(), '-i', path_to_file, '-map', '0:v:0', '-c', 'copy',
                                               '-f', 'null', '-'], stderr=subprocess.STDOUT,
-                                             timeout=SUBPROCESS_TIMEOUT, creationflags=_creationflags).decode('utf-8')
+                                             timeout=SUBPROCESS_TIMEOUT).decode('utf-8')
         match = re.findall(r'frame=\s*(\d+)', raw_stdout)
         if match:
             frame_number = int(match[-1])
@@ -131,8 +129,8 @@ class FFMPEG(BaseRenderEngine):
         return -1
 
     def get_arguments(self):
-        help_text = (subprocess.check_output([self.renderer_path(), '-h', 'long'], stderr=subprocess.STDOUT,
+        help_text = (subprocess.check_output([self.renderer_path(), '-h', 'long'], stderr=subprocess.STDOUT)
-                                             creationflags=_creationflags).decode('utf-8'))
+                     .decode('utf-8'))
         lines = help_text.splitlines()
 
         options = {}

src/engines/ffmpeg/ffmpeg_ui.py

@@ -1,5 +1,5 @@
 class FFMPEGUI:
     @staticmethod
-    def get_options(system_info):
+    def get_options(instance, project_info):
         options = []
         return options

src/init.py

@@ -1,154 +1,67 @@
+''' app/init.py '''
 import logging
-import multiprocessing
 import os
-import socket
 import sys
 import threading
 from collections import deque
 
-import cpuinfo
+from PyQt6.QtCore import QObject, pyqtSignal
+from PyQt6.QtWidgets import QApplication
 
-from api.api_server import API_VERSION
 from src.api.api_server import start_server
-from src.api.preview_manager import PreviewManager
-from src.api.serverproxy_manager import ServerProxyManager
-from src.distributed_job_manager import DistributedJobManager
 from src.engines.engine_manager import EngineManager
 from src.render_queue import RenderQueue
+from src.ui.main_window import MainWindow
 from src.utilities.config import Config
-from src.utilities.misc_helper import (system_safe_path, current_system_cpu, current_system_os,
+from src.utilities.misc_helper import system_safe_path
-                                       current_system_os_version, check_for_updates)
-from src.utilities.zeroconf_server import ZeroconfServer
-from src.version import APP_NAME, APP_VERSION, APP_REPO_NAME, APP_REPO_OWNER
-
-logger = logging.getLogger()
 
 
-def run(server_only=False) -> int:
+def run() -> int:
-    """Initializes the application and runs it.
+    """
-
+    Initializes the application and runs it.
-    Args:
-        server_only: Run in server-only CLI mode. Default is False (runs in GUI mode).
 
     Returns:
         int: The exit status code.
     """
 
-    def existing_process(process_name):
-        import psutil
-        current_pid = os.getpid()
-        current_process = psutil.Process(current_pid)
-        for proc in psutil.process_iter(['pid', 'name', 'ppid']):
-            proc_name = proc.info['name'].lower().rstrip('.exe')
-            if proc_name == process_name.lower() and proc.info['pid'] != current_pid:
-                if proc.info['pid'] == current_process.ppid():
-                    continue  # parent process
-                elif proc.info['ppid'] == current_pid:
-                    continue  # child process
-                else:
-                    return proc  # unrelated process
-        return None
-
-    # setup logging
-    logging.basicConfig(format='%(asctime)s: %(levelname)s: %(module)s: %(message)s', datefmt='%d-%b-%y %H:%M:%S',
-                        level=Config.server_log_level.upper())
-    logging.getLogger("requests").setLevel(logging.WARNING)  # suppress noisy requests/urllib3 logging
-    logging.getLogger("urllib3").setLevel(logging.WARNING)
-
-    # check for existing instance
-    existing_proc = existing_process(APP_NAME)
-    if existing_proc:
-        logger.fatal(f"Another instance of {APP_NAME} is already running (pid: {existing_proc.pid})")
-        sys.exit(1)
-
-    # Setup logging for console ui
-    buffer_handler = __setup_buffer_handler() if not server_only else None
-
-    # check for updates
-    update_thread = threading.Thread(target=check_for_updates, args=(APP_REPO_NAME, APP_REPO_OWNER, APP_NAME,
-                                                                     APP_VERSION))
-    update_thread.start()
-
-    # main start
-    logger.info(f"Starting {APP_NAME} Render Server")
-    return_code = 0
     try:
         # Load Config YAML
         Config.setup_config_dir()
         Config.load_config(system_safe_path(os.path.join(Config.config_dir(), 'config.yaml')))
-
-        # configure default paths
         EngineManager.engines_path = system_safe_path(
             os.path.join(os.path.join(os.path.expanduser(Config.upload_folder),
                                       'engines')))
-        os.makedirs(EngineManager.engines_path, exist_ok=True)
+        logging.basicConfig(format='%(asctime)s: %(levelname)s: %(module)s: %(message)s', datefmt='%d-%b-%y %H:%M:%S',
-        PreviewManager.storage_path = system_safe_path(
+                            level=Config.server_log_level.upper())
-            os.path.join(os.path.expanduser(Config.upload_folder), 'previews'))
 
-        # Debug info
+        app: QApplication = QApplication(sys.argv)
-        logger.debug(f"Upload directory: {os.path.expanduser(Config.upload_folder)}")
-        logger.debug(f"Thumbs directory: {PreviewManager.storage_path}")
-        logger.debug(f"Engines directory: {EngineManager.engines_path}")
 
-        # Set up the RenderQueue object
+        # Start server in background
-        RenderQueue.load_state(database_directory=system_safe_path(os.path.expanduser(Config.upload_folder)))
+        background_server = threading.Thread(target=start_server)
-        ServerProxyManager.subscribe_to_listener()
+        background_server.daemon = True
-        DistributedJobManager.subscribe_to_listener()
+        background_server.start()
 
-        # check for updates for render engines if configured or on first launch
+        # Setup logging for console ui
-        if Config.update_engines_on_launch or not EngineManager.get_engines():
+        buffer_handler = BufferingHandler()
-            EngineManager.update_all_engines()
+        buffer_handler.setFormatter(logging.getLogger().handlers[0].formatter)
+        logger = logging.getLogger()
+        logger.addHandler(buffer_handler)
 
-        # get hostname
+        window: MainWindow = MainWindow()
-        local_hostname = socket.gethostname()
+        window.buffer_handler = buffer_handler
-        local_hostname = local_hostname + (".local" if not local_hostname.endswith(".local") else "")
+        window.show()
 
-        # configure and start API server
+        return_code = app.exec()
-        api_server = threading.Thread(target=start_server, args=(local_hostname,))
-        api_server.daemon = True
-        api_server.start()
 
-        # start zeroconf server
-        ZeroconfServer.configure(f"_{APP_NAME.lower()}._tcp.local.", local_hostname, Config.port_number)
-        ZeroconfServer.properties = {'system_cpu': current_system_cpu(),
-                                     'system_cpu_brand': cpuinfo.get_cpu_info()['brand_raw'],
-                                     'system_cpu_cores': multiprocessing.cpu_count(),
-                                     'system_os': current_system_os(),
-                                     'system_os_version': current_system_os_version(),
-                                     'api_version': API_VERSION}
-        ZeroconfServer.start()
-        logger.info(f"{APP_NAME} Render Server started - Hostname: {local_hostname}")
-        RenderQueue.start()  # Start evaluating the render queue
-
-        # start in gui or server only (cli) mode
-        logger.debug(f"Launching in {'server only' if server_only else 'GUI'} mode")
-        if server_only:  # CLI only
-            api_server.join()
-        else:  # GUI
-            return_code = __show_gui(buffer_handler)
-
-    except KeyboardInterrupt:
-        pass
     except Exception as e:
         logging.error(f"Unhandled exception: {e}")
         return_code = 1
     finally:
-        # shut down gracefully
-        logger.info(f"{APP_NAME} Render Server is preparing to shut down")
-        try:
         RenderQueue.prepare_for_shutdown()
-        except Exception as e:
-            logger.exception(f"Exception during prepare for shutdown: {e}")
-        ZeroconfServer.stop()
-        logger.info(f"{APP_NAME} Render Server has shut down")
         return sys.exit(return_code)
 
 
-def __setup_buffer_handler():
+class BufferingHandler(logging.Handler, QObject):
-    # lazy load GUI frameworks
-    from PyQt6.QtCore import QObject, pyqtSignal
-
-    class BufferingHandler(logging.Handler, QObject):
     new_record = pyqtSignal(str)
 
     def __init__(self, capacity=100):
@@ -157,36 +70,9 @@ def __setup_buffer_handler():
         self.buffer = deque(maxlen=capacity)  # Define a buffer with a fixed capacity
 
     def emit(self, record):
-            try:
         msg = self.format(record)
         self.buffer.append(msg)  # Add message to the buffer
         self.new_record.emit(msg)  # Emit signal
-            except RuntimeError:
-                pass
 
     def get_buffer(self):
         return list(self.buffer)  # Return a copy of the buffer
-
-    buffer_handler = BufferingHandler()
-    buffer_handler.setFormatter(logging.getLogger().handlers[0].formatter)
-    new_logger = logging.getLogger()
-    new_logger.addHandler(buffer_handler)
-    return buffer_handler
-
-
-def __show_gui(buffer_handler):
-    # lazy load GUI frameworks
-    from PyQt6.QtWidgets import QApplication
-
-    # load application
-    app: QApplication = QApplication(sys.argv)
-    if app.style().objectName() != 'macos':
-        app.setStyle('Fusion')
-
-    # configure main window
-    from src.ui.main_window import MainWindow
-    window: MainWindow = MainWindow()
-    window.buffer_handler = buffer_handler
-    window.show()
-
-    return app.exec()

src/render_queue.py

@@ -2,13 +2,12 @@ import logging
 import os
 from datetime import datetime
 
-from pubsub import pub
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy.orm.exc import DetachedInstanceError
 
-from src.engines.core.base_worker import Base
 from src.utilities.status_utils import RenderStatus
+from src.engines.engine_manager import EngineManager
+from src.engines.core.base_worker import Base
 
 logger = logging.getLogger()
 
@@ -18,9 +17,6 @@ class JobNotFoundError(Exception):
         super().__init__(args)
         self.job_id = job_id
 
-    def __str__(self):
-        return f"Cannot find job with ID: {self.job_id}"
-
 
 class RenderQueue:
     engine = None
@@ -28,53 +24,18 @@ class RenderQueue:
     job_queue = []
     maximum_renderer_instances = {'blender': 1, 'aerender': 1, 'ffmpeg': 4}
     last_saved_counts = {}
-    is_running = False
 
-    # --------------------------------------------
+    def __init__(self):
-    # Render Queue Evaluation:
-    # --------------------------------------------
-
-    @classmethod
-    def start(cls):
-        """Start evaluating the render queue"""
-        logger.debug("Starting render queue updates")
-        cls.is_running = True
-        cls.evaluate_queue()
-
-    @classmethod
-    def evaluate_queue(cls):
-        try:
-            not_started = cls.jobs_with_status(RenderStatus.NOT_STARTED, priority_sorted=True)
-            for job in not_started:
-                if cls.is_available_for_job(job.renderer, job.priority):
-                    cls.start_job(job)
-
-            scheduled = cls.jobs_with_status(RenderStatus.SCHEDULED, priority_sorted=True)
-            for job in scheduled:
-                if job.scheduled_start <= datetime.now():
-                    logger.debug(f"Starting scheduled job: {job}")
-                    cls.start_job(job)
-
-            if cls.last_saved_counts != cls.job_counts():
-                cls.save_state()
-        except DetachedInstanceError:
         pass
 
     @classmethod
-    def __local_job_status_changed(cls, job_id, old_status, new_status):
+    def add_to_render_queue(cls, render_job, force_start=False):
-        render_job = RenderQueue.job_with_id(job_id, none_ok=True)
+        logger.debug('Adding priority {} job to render queue: {}'.format(render_job.priority, render_job))
-        if render_job and cls.is_running:  # ignore changes from render jobs not in the queue yet
+        cls.job_queue.append(render_job)
-            logger.debug(f"RenderQueue detected job {job_id} has changed from {old_status} -> {new_status}")
+        if force_start and render_job.status in (RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED):
-            RenderQueue.evaluate_queue()
+            cls.start_job(render_job)
-
+        cls.session.add(render_job)
-    @classmethod
+        cls.save_state()
-    def stop(cls):
-        logger.debug("Stopping render queue updates")
-        cls.is_running = False
-
-    # --------------------------------------------
-    # Fetch Jobs:
-    # --------------------------------------------
 
     @classmethod
     def all_jobs(cls):
@@ -105,15 +66,12 @@ class RenderQueue:
         return found_job
 
     @classmethod
-    def job_counts(cls):
+    def clear_history(cls):
-        job_counts = {}
+        to_remove = [x for x in cls.all_jobs() if x.status in [RenderStatus.CANCELLED,
-        for job_status in RenderStatus:
+                                                               RenderStatus.COMPLETED, RenderStatus.ERROR]]
-            job_counts[job_status.value] = len(cls.jobs_with_status(job_status))
+        for job_to_remove in to_remove:
-        return job_counts
+            cls.delete_job(job_to_remove)
-
+        cls.save_state()
-    # --------------------------------------------
-    # Startup / Shutdown:
-    # --------------------------------------------
 
     @classmethod
     def load_state(cls, database_directory):
@@ -123,7 +81,6 @@ class RenderQueue:
             cls.session = sessionmaker(bind=cls.engine)()
         from src.engines.core.base_worker import BaseRenderWorker
         cls.job_queue = cls.session.query(BaseRenderWorker).all()
-        pub.subscribe(cls.__local_job_status_changed, 'status_change')
 
     @classmethod
     def save_state(cls):
@@ -132,22 +89,11 @@ class RenderQueue:
     @classmethod
     def prepare_for_shutdown(cls):
         logger.debug("Closing session")
-        cls.stop()
         running_jobs = cls.jobs_with_status(RenderStatus.RUNNING)  # cancel all running jobs
         [cls.cancel_job(job) for job in running_jobs]
         cls.save_state()
         cls.session.close()
 
-    # --------------------------------------------
-    # Renderer Availability:
-    # --------------------------------------------
-
-    @classmethod
-    def renderer_instances(cls):
-        from collections import Counter
-        all_instances = [x.renderer for x in cls.running_jobs()]
-        return Counter(all_instances)
-
     @classmethod
     def is_available_for_job(cls, renderer, priority=2):
 
@@ -157,50 +103,52 @@ class RenderQueue:
         maxed_out_instances = renderer in instances.keys() and instances[renderer] >= max_allowed_instances
         return not maxed_out_instances and not higher_priority_jobs
 
-    # --------------------------------------------
-    # Job Lifecycle Management:
-    # --------------------------------------------
-
     @classmethod
-    def add_to_render_queue(cls, render_job, force_start=False):
+    def evaluate_queue(cls):
-        logger.info(f"Adding job to render queue: {render_job}")
+        not_started = cls.jobs_with_status(RenderStatus.NOT_STARTED, priority_sorted=True)
-        cls.job_queue.append(render_job)
+        for job in not_started:
-        if cls.is_running and force_start and render_job.status in (RenderStatus.NOT_STARTED, RenderStatus.SCHEDULED):
+            if cls.is_available_for_job(job.renderer, job.priority):
-            cls.start_job(render_job)
+                cls.start_job(job)
-        cls.session.add(render_job)
+
+        scheduled = cls.jobs_with_status(RenderStatus.SCHEDULED, priority_sorted=True)
+        for job in scheduled:
+            if job.scheduled_start <= datetime.now():
+                logger.debug(f"Starting scheduled job: {job}")
+                cls.start_job(job)
+
+        if cls.last_saved_counts != cls.job_counts():
             cls.save_state()
-        if cls.is_running:
-            cls.evaluate_queue()
 
     @classmethod
     def start_job(cls, job):
-        logger.info(f'Starting job: {job}')
+        logger.info(f'Starting render: {job.name} - Priority {job.priority}')
         job.start()
         cls.save_state()
 
     @classmethod
     def cancel_job(cls, job):
-        logger.info(f'Cancelling job: {job}')
+        logger.info(f'Cancelling job ID: {job.id}')
         job.stop()
         return job.status == RenderStatus.CANCELLED
 
     @classmethod
     def delete_job(cls, job):
-        logger.info(f"Deleting job: {job}")
+        logger.info(f"Deleting job ID: {job.id}")
         job.stop()
         cls.job_queue.remove(job)
         cls.session.delete(job)
         cls.save_state()
         return True
 
-    # --------------------------------------------
+    @classmethod
-    # Miscellaneous:
+    def renderer_instances(cls):
-    # --------------------------------------------
+        from collections import Counter
+        all_instances = [x.renderer for x in cls.running_jobs()]
+        return Counter(all_instances)
 
     @classmethod
-    def clear_history(cls):
+    def job_counts(cls):
-        to_remove = [x for x in cls.all_jobs() if x.status in [RenderStatus.CANCELLED,
+        job_counts = {}
-                                                               RenderStatus.COMPLETED, RenderStatus.ERROR]]
+        for job_status in RenderStatus:
-        for job_to_remove in to_remove:
+            job_counts[job_status.value] = len(cls.jobs_with_status(job_status))
-            cls.delete_job(job_to_remove)
+        return job_counts
-        cls.save_state()

src/ui/about_window.py

@@ -1,74 +0,0 @@
-import os
-import sys
-
-from PyQt6.QtCore import Qt
-from PyQt6.QtGui import QPixmap
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QLabel, QDialogButtonBox, QHBoxLayout
-
-from src.version import *
-
-
-class AboutDialog(QDialog):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle(f"About {APP_NAME}")
-
-        # Create the layout
-        layout = QVBoxLayout()
-
-        # App Icon
-        icon_name = 'Server.png'  # todo: temp icon - replace with final later
-        icon_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-                                 'resources', icon_name)
-        icon_label = QLabel(self)
-        icon_pixmap = QPixmap(icon_path)
-        icon_label.setPixmap(icon_pixmap)
-        icon_layout = QHBoxLayout()
-        icon_layout.addStretch()
-        icon_layout.addWidget(icon_label)
-        icon_layout.addStretch()
-        layout.addLayout(icon_layout)
-
-        # Application name
-        name_label = QLabel(f"<h2>{APP_NAME}</h2>")
-        layout.addWidget(name_label)
-
-        # Description
-        description_label = QLabel(APP_DESCRIPTION)
-        layout.addWidget(description_label)
-
-        # Version
-        version_label = QLabel(f"<strong>Version:</strong> {APP_VERSION}")
-        layout.addWidget(version_label)
-
-        # Contributors
-        contributors_label = QLabel(f"Copyright © {APP_COPYRIGHT_YEAR} {APP_AUTHOR}")
-        layout.addWidget(contributors_label)
-
-        # License
-        license_label = QLabel(f"Released under {APP_LICENSE}")
-        layout.addWidget(license_label)
-
-        # Add an "OK" button to close the dialog
-        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok)
-        button_box.accepted.connect(self.accept)
-        layout.addWidget(button_box)
-
-        # Set the layout for the dialog
-        self.setLayout(layout)
-
-        # Make the dialog non-resizable
-        self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowContextHelpButtonHint)
-        self.setFixedSize(self.sizeHint())
-
-
-if __name__ == '__main__':
-    # lazy load GUI frameworks
-    from PyQt6.QtWidgets import QApplication
-
-    # load application
-    app: QApplication = QApplication(sys.argv)
-    window: AboutDialog = AboutDialog()
-    window.show()
-
-    app.exec()

src/ui/add_job.py

@@ -55,7 +55,7 @@ class NewRenderJobForm(QWidget):
         self.priority_input = None
         self.end_frame_input = None
         self.start_frame_input = None
-        self.render_name_input = None
+        self.output_path_input = None
         self.scene_file_input = None
         self.scene_file_browse_button = None
         self.job_name_input = None
@@ -68,12 +68,11 @@ class NewRenderJobForm(QWidget):
         # Setup
         self.setWindowTitle("New Job")
         self.setup_ui()
-        self.update_renderer_info()
         self.setup_project()
 
         # get renderer info in bg thread
-        # t = threading.Thread(target=self.update_renderer_info)
+        t = threading.Thread(target=self.update_renderer_info)
-        # t.start()
+        t.start()
 
         self.show()
 
@@ -137,11 +136,11 @@ class NewRenderJobForm(QWidget):
         self.output_settings_group = QGroupBox("Output Settings")
         output_settings_layout = QVBoxLayout(self.output_settings_group)
         # output path
-        render_name_layout = QHBoxLayout()
+        output_path_layout = QHBoxLayout()
-        render_name_layout.addWidget(QLabel("Render name:"))
+        output_path_layout.addWidget(QLabel("Render name:"))
-        self.render_name_input = QLineEdit()
+        self.output_path_input = QLineEdit()
-        render_name_layout.addWidget(self.render_name_input)
+        output_path_layout.addWidget(self.output_path_input)
-        output_settings_layout.addLayout(render_name_layout)
+        output_settings_layout.addLayout(output_path_layout)
         # file format
         file_format_layout = QHBoxLayout()
         file_format_layout.addWidget(QLabel("Format:"))
@@ -282,7 +281,7 @@ class NewRenderJobForm(QWidget):
 
         output_name, _ = os.path.splitext(os.path.basename(self.scene_file_input.text()))
         output_name = output_name.replace(' ', '_')
-        self.render_name_input.setText(output_name)
+        self.output_path_input.setText(output_name)
         file_name = self.scene_file_input.text()
 
         # setup bg worker
@@ -293,7 +292,7 @@ class NewRenderJobForm(QWidget):
     def browse_output_path(self):
         directory = QFileDialog.getExistingDirectory(self, "Select Output Directory")
         if directory:
-            self.render_name_input.setText(directory)
+            self.output_path_input.setText(directory)
 
     def args_help_button_clicked(self):
         url = (f'http://{self.server_proxy.hostname}:{self.server_proxy.port}/api/renderer/'
@@ -317,16 +316,28 @@ class NewRenderJobForm(QWidget):
                 self.renderer_type.setCurrentIndex(0)  #todo: find out why we don't have renderer info yet
                 # not ideal but if we don't have the renderer info we have to pick something
 
+            self.output_path_input.setText(os.path.basename(input_path))
+
             # cleanup progress UI
             self.load_file_group.setHidden(True)
             self.toggle_renderer_enablement(True)
 
-            # Load scene data
+            # -- Load scene data
-            self.start_frame_input.setValue(self.project_info.get('frame_start'))
+            # start / end frames
-            self.end_frame_input.setValue(self.project_info.get('frame_end'))
+            self.start_frame_input.setValue(self.project_info.get('start_frame', 0))
-            self.resolution_x_input.setValue(self.project_info.get('resolution_x'))
+            self.end_frame_input.setValue(self.project_info.get('end_frame', 0))
-            self.resolution_y_input.setValue(self.project_info.get('resolution_y'))
+            self.start_frame_input.setEnabled(bool(self.project_info.get('start_frame')))
-            self.frame_rate_input.setValue(self.project_info.get('fps'))
+            self.end_frame_input.setEnabled(bool(self.project_info.get('start_frame')))
+
+            # resolution
+            self.resolution_x_input.setValue(self.project_info.get('resolution_x', 1920))
+            self.resolution_y_input.setValue(self.project_info.get('resolution_y', 1080))
+            self.resolution_x_input.setEnabled(bool(self.project_info.get('resolution_x')))
+            self.resolution_y_input.setEnabled(bool(self.project_info.get('resolution_y')))
+
+            # frame rate
+            self.frame_rate_input.setValue(self.project_info.get('fps', 24))
+            self.frame_rate_input.setEnabled(bool(self.project_info.get('fps')))
 
             # Cameras
             self.cameras_list.clear()
@@ -349,8 +360,7 @@ class NewRenderJobForm(QWidget):
             # Dynamic Engine Options
             clear_layout(self.renderer_options_layout)  # clear old options
             # dynamically populate option list
-            system_info = self.renderer_info.get(engine.name(), {}).get('system_info', {})
+            self.current_engine_options = engine().ui_options(self.project_info)
-            self.current_engine_options = engine.ui_options(system_info=system_info)
             for option in self.current_engine_options:
                 h_layout = QHBoxLayout()
                 label = QLabel(option['name'].replace('_', ' ').capitalize() + ':')
@@ -377,7 +387,7 @@ class NewRenderJobForm(QWidget):
             self.cameras_group.setHidden(True)
         self.submit_button.setEnabled(enabled)
 
-    def after_job_submission(self, error_string):
+    def after_job_submission(self, result):
 
         # UI cleanup
         self.submit_progress.setMaximum(0)
@@ -389,7 +399,7 @@ class NewRenderJobForm(QWidget):
         self.toggle_renderer_enablement(True)
 
         self.msg_box = QMessageBox()
-        if not error_string:
+        if result.ok:
             self.msg_box.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
             self.msg_box.setIcon(QMessageBox.Icon.Information)
             self.msg_box.setText("Job successfully submitted to server. Submit another?")
@@ -400,7 +410,7 @@ class NewRenderJobForm(QWidget):
         else:
             self.msg_box.setStandardButtons(QMessageBox.StandardButton.Ok)
             self.msg_box.setIcon(QMessageBox.Icon.Critical)
-            self.msg_box.setText(error_string)
+            self.msg_box.setText(result.text or "Unknown error")
             self.msg_box.setWindowTitle("Error")
             self.msg_box.exec()
 
@@ -431,7 +441,7 @@ class NewRenderJobForm(QWidget):
 class SubmitWorker(QThread):
     """Worker class called to submit all the jobs to the server and update the UI accordingly"""
 
-    message_signal = pyqtSignal(str)
+    message_signal = pyqtSignal(Response)
     update_ui_signal = pyqtSignal(str, str)
 
     def __init__(self, window):
@@ -447,21 +457,18 @@ class SubmitWorker(QThread):
                 self.update_ui_signal.emit(hostname, percent)
             return callback
 
-        try:
         hostname = self.window.server_input.currentText()
         job_json = {'owner': psutil.Process().username() + '@' + socket.gethostname(),
                     'renderer': self.window.renderer_type.currentText().lower(),
                     'engine_version': self.window.renderer_version_combo.currentText(),
-                        'args': {'raw': self.window.raw_args.text(),
+                    'args': {'raw': self.window.raw_args.text()},
-                                 'export_format': self.window.file_format_combo.currentText()},
+                    'output_path': self.window.output_path_input.text(),
-                        'output_path': self.window.render_name_input.text(),
                     'start_frame': self.window.start_frame_input.value(),
                     'end_frame': self.window.end_frame_input.value(),
                     'priority': self.window.priority_input.currentIndex() + 1,
                     'notes': self.window.notes_input.toPlainText(),
                     'enable_split_jobs': self.window.enable_splitjobs.isChecked(),
-                        'split_jobs_same_os': self.window.splitjobs_same_os.isChecked(),
+                    'split_jobs_same_os': self.window.splitjobs_same_os.isChecked()}
-                        'name': self.window.render_name_input.text()}
 
         # get the dynamic args
         for i in range(self.window.renderer_options_layout.count()):
@@ -490,8 +497,7 @@ class SubmitWorker(QThread):
             for cam in selected_cameras:
                 job_copy = copy.deepcopy(job_json)
                 job_copy['args']['camera'] = cam
-                    job_copy['name'] = job_copy['name'].replace(' ', '-') + "_" + cam.replace(' ', '')
+                job_copy['name'] = pathlib.Path(input_path).stem.replace(' ', '_') + "-" + cam.replace(' ', '')
-                    job_copy['output_path'] = job_copy['name']
                 job_list.append(job_copy)
         else:
             job_list = [job_json]
@@ -500,16 +506,13 @@ class SubmitWorker(QThread):
         engine = EngineManager.engine_with_name(self.window.renderer_type.currentText().lower())
         input_path = engine().perform_presubmission_tasks(input_path)
         # submit
-            err_msg = ""
+        result = None
+        try:
             result = self.window.server_proxy.post_job_to_server(file_path=input_path, job_list=job_list,
                                                           callback=create_callback)
-            if not (result and result.ok):
-                err_msg = "Error posting job to server."
-
-            self.message_signal.emit(err_msg)
-
         except Exception as e:
-            self.message_signal.emit(str(e))
+            pass
+        self.message_signal.emit(result)
 
 
 class GetProjectInfoWorker(QThread):

src/ui/console.py

@@ -1,3 +1,4 @@
+import sys
 import logging
 
 from PyQt6.QtGui import QFont
@@ -15,10 +16,7 @@ class QSignalHandler(logging.Handler, QObject):
 
     def emit(self, record):
         msg = self.format(record)
-        try:
         self.new_record.emit(msg)  # Emit signal
-        except RuntimeError:
-            pass
 
 
 class ConsoleWindow(QMainWindow):

src/ui/main_window.py

@@ -3,6 +3,7 @@ import datetime
 import io
 import logging
 import os
+import subprocess
 import sys
 import threading
 import time
@@ -15,22 +16,20 @@ from PyQt6.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QListWidget, QTab
     QTableWidgetItem, QLabel, QVBoxLayout, QHeaderView, QMessageBox, QGroupBox, QPushButton, QListWidgetItem, \
     QFileDialog
 
-from api.api_server import API_VERSION
 from src.render_queue import RenderQueue
 from src.utilities.misc_helper import get_time_elapsed, resources_dir, is_localhost
 from src.utilities.status_utils import RenderStatus
 from src.utilities.zeroconf_server import ZeroconfServer
-from src.ui.add_job import NewRenderJobForm
+from .add_job import NewRenderJobForm
-from src.ui.console import ConsoleWindow
+from .console import ConsoleWindow
-from src.ui.engine_browser import EngineBrowserWindow
+from .engine_browser import EngineBrowserWindow
-from src.ui.log_viewer import LogViewer
+from .log_viewer import LogViewer
-from src.ui.widgets.menubar import MenuBar
+from .widgets.menubar import MenuBar
-from src.ui.widgets.proportional_image_label import ProportionalImageLabel
+from .widgets.proportional_image_label import ProportionalImageLabel
-from src.ui.widgets.statusbar import StatusBar
+from .widgets.statusbar import StatusBar
-from src.ui.widgets.toolbar import ToolBar
+from .widgets.toolbar import ToolBar
 from src.api.serverproxy_manager import ServerProxyManager
-from src.utilities.misc_helper import launch_url, iso_datestring_to_formatted_datestring
+from src.utilities.misc_helper import launch_url
-from src.version import APP_NAME
 
 logger = logging.getLogger()
 
@@ -64,7 +63,7 @@ class MainWindow(QMainWindow):
         self.buffer_handler = None
 
         # Window-Settings
-        self.setWindowTitle(APP_NAME)
+        self.setWindowTitle("Zordon")
         self.setGeometry(100, 100, 900, 800)
         central_widget = QWidget(self)
         self.setCentralWidget(central_widget)
@@ -184,13 +183,8 @@ class MainWindow(QMainWindow):
 
     def __background_update(self):
         while True:
-            try:
             self.update_servers()
             self.fetch_jobs()
-            except RuntimeError:
-                pass
-            except Exception as e:
-                logger.error(f"Uncaught exception in background update: {e}")
             time.sleep(0.5)
 
     def closeEvent(self, event):
@@ -243,7 +237,7 @@ class MainWindow(QMainWindow):
 
         # Use the get method with defaults to avoid KeyError
         os_info = f"OS: {server_info.get('system_os', 'Unknown')} {server_info.get('system_os_version', '')}"
-        cpu_info = f"CPU: {server_info.get('system_cpu_brand', 'Unknown')} ({server_info.get('system_cpu_cores', 'Unknown')} cores)"
+        cpu_info = f"CPU: {server_info.get('system_cpu', 'Unknown')} - {server_info.get('system_cpu_cores', 'Unknown')} cores"
 
         self.server_info_os.setText(os_info.strip())
         self.server_info_cpu.setText(cpu_info)
@@ -257,7 +251,7 @@ class MainWindow(QMainWindow):
             self.job_list_view.clear()
             self.refresh_job_headers()
 
-        job_fetch = self.current_server_proxy.get_all_jobs(ignore_token=False)
+        job_fetch = self.current_server_proxy.get_all_jobs(ignore_token=clear_table)
         if job_fetch:
             num_jobs = len(job_fetch)
             self.job_list_view.setRowCount(num_jobs)
@@ -277,11 +271,10 @@ class MainWindow(QMainWindow):
                 renderer = f"{job.get('renderer', '')}-{job.get('renderer_version')}"
                 priority = str(job.get('priority', ''))
                 total_frames = str(job.get('total_frames', ''))
-                date_created_string = iso_datestring_to_formatted_datestring(job['date_created'])
 
                 items = [QTableWidgetItem(job['id']), QTableWidgetItem(name), QTableWidgetItem(renderer),
                          QTableWidgetItem(priority), QTableWidgetItem(display_status), QTableWidgetItem(time_elapsed),
-                         QTableWidgetItem(total_frames), QTableWidgetItem(date_created_string)]
+                         QTableWidgetItem(total_frames), QTableWidgetItem(job['date_created'])]
 
                 for col, item in enumerate(items):
                     self.job_list_view.setItem(row, col, item)
@@ -327,7 +320,7 @@ class MainWindow(QMainWindow):
             current_status = self.job_list_view.item(selected_row.row(), 4).text()
 
             # show / hide the stop button
-            show_stop_button = "%" in current_status
+            show_stop_button = current_status.lower() == 'running'
             self.topbar.actions_call['Stop Job'].setEnabled(show_stop_button)
             self.topbar.actions_call['Stop Job'].setVisible(show_stop_button)
             self.topbar.actions_call['Delete Job'].setEnabled(not show_stop_button)
@@ -379,17 +372,13 @@ class MainWindow(QMainWindow):
 
     def load_image_path(self, image_path):
         # Load and set the image using QPixmap
-        try:
         pixmap = QPixmap(image_path)
         if not pixmap:
             logger.error("Error loading image")
             return
         self.image_label.setPixmap(pixmap)
-        except Exception as e:
-            logger.error(f"Error loading image path: {e}")
 
     def load_image_data(self, pillow_image):
-        try:
         # Convert the Pillow Image to a QByteArray (byte buffer)
         byte_array = QByteArray()
         buffer = QBuffer(byte_array)
@@ -407,13 +396,9 @@ class MainWindow(QMainWindow):
             logger.error("Error loading image")
             return
         self.image_label.setPixmap(pixmap)
-        except Exception as e:
-            logger.error(f"Error loading image data: {e}")
 
     def update_servers(self):
         found_servers = list(set(ZeroconfServer.found_hostnames() + self.added_hostnames))
-        found_servers = [x for x in found_servers if ZeroconfServer.get_hostname_properties(x)['api_version'] == API_VERSION]
-
         # Always make sure local hostname is first
         if found_servers and not is_localhost(found_servers[0]):
             for hostname in found_servers:
@@ -516,7 +501,7 @@ class MainWindow(QMainWindow):
 
     def stop_job(self, event):
         """
-        Event handler for the Stop Job button
+        Event handler for the "Exit" button. Closes the application.
         """
         job_ids = self.selected_job_ids()
         if not job_ids:
@@ -526,14 +511,14 @@ class MainWindow(QMainWindow):
             job = next((job for job in self.current_server_proxy.get_all_jobs() if job.get('id') == job_ids[0]), None)
             if job:
                 display_name = job.get('name', os.path.basename(job.get('input_path', '')))
-                message = f"Are you sure you want to stop the job:\n{display_name}?"
+                message = f"Are you sure you want to delete the job:\n{display_name}?"
             else:
                 return  # Job not found, handle this case as needed
         else:
-            message = f"Are you sure you want to stop these {len(job_ids)} jobs?"
+            message = f"Are you sure you want to delete these {len(job_ids)} jobs?"
 
         # Display the message box and check the response in one go
-        msg_box = QMessageBox(QMessageBox.Icon.Warning, "Stop Job", message,
+        msg_box = QMessageBox(QMessageBox.Icon.Warning, "Delete Job", message,
                               QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, self)
 
         if msg_box.exec() == QMessageBox.StandardButton.Yes:
@@ -569,15 +554,7 @@ class MainWindow(QMainWindow):
             self.fetch_jobs(clear_table=True)
 
     def download_files(self, event):
-
+        pass
-        job_ids = self.selected_job_ids()
-        if not job_ids:
-            return
-
-        import webbrowser
-        download_url = (f"http://{self.current_server_proxy.hostname}:{self.current_server_proxy.port}"
-                        f"/api/job/{job_ids[0]}/download_all")
-        webbrowser.open(download_url)
 
     def open_files(self, event):
         job_ids = self.selected_job_ids()
@@ -595,21 +572,3 @@ class MainWindow(QMainWindow):
         if file_name:
             self.new_job_window = NewRenderJobForm(file_name)
             self.new_job_window.show()
-
-
-if __name__ == "__main__":
-    # lazy load GUI frameworks
-    from PyQt6.QtWidgets import QApplication
-
-    # load application
-    # QtCore.QCoreApplication.setAttribute(QtCore.Qt.ApplicationAttribute.AA_MacDontSwapCtrlAndMeta)
-    app: QApplication = QApplication(sys.argv)
-
-    # configure main main_window
-    main_window = MainWindow()
-    # main_window.buffer_handler = buffer_handler
-    app.setActiveWindow(main_window)
-
-    main_window.show()
-
-    sys.exit(app.exec())

src/ui/widgets/menubar.py

@@ -1,6 +1,5 @@
 ''' app/ui/widgets/menubar.py '''
-from PyQt6.QtGui import QAction
+from PyQt6.QtWidgets import QMenuBar
-from PyQt6.QtWidgets import QMenuBar, QApplication, QMessageBox, QDialog, QVBoxLayout, QLabel, QPushButton
 
 
 class MenuBar(QMenuBar):
@@ -13,89 +12,12 @@ class MenuBar(QMenuBar):
 
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
-
-        # setup menus
         file_menu = self.addMenu("File")
         # edit_menu = self.addMenu("Edit")
         # view_menu = self.addMenu("View")
-        help_menu = self.addMenu("Help")
+        # help_menu = self.addMenu("Help")
 
-        # --file menu--
+        # Add actions to the menus
-        # new job
+        # file_menu.addAction(self.parent().topbar.actions_call["Open"]) # type: ignore
-        new_job_action = QAction("New Job...", self)
+        # file_menu.addAction(self.parent().topbar.actions_call["Save"]) # type: ignore
-        new_job_action.setShortcut(f'Ctrl+N')
+        # file_menu.addAction(self.parent().topbar.actions_call["Exit"]) # type: ignore
-        new_job_action.triggered.connect(self.new_job)
-        file_menu.addAction(new_job_action)
-        # settings
-        settings_action = QAction("Settings...", self)
-        settings_action.triggered.connect(self.show_settings)
-        settings_action.setShortcut(f'Ctrl+,')
-        # file_menu.addAction(settings_action)  # todo: enable once we have a setting screen
-        # exit
-        exit_action = QAction('&Exit', self)
-        exit_action.setShortcut('Ctrl+Q')
-        exit_action.triggered.connect(QApplication.instance().quit)
-        file_menu.addAction(exit_action)
-
-        # --help menu--
-        about_action = QAction("About", self)
-        about_action.triggered.connect(self.show_about)
-        help_menu.addAction(about_action)
-        update_action = QAction("Check for Updates...", self)
-        update_action.triggered.connect(self.check_for_updates)
-        help_menu.addAction(update_action)
-
-    def new_job(self):
-        self.parent().new_job()
-
-    def show_settings(self):
-        pass
-
-    @staticmethod
-    def show_about():
-        from src.ui.about_window import AboutDialog
-        dialog = AboutDialog()
-        dialog.exec()
-
-    @staticmethod
-    def check_for_updates():
-        from src.utilities.misc_helper import check_for_updates
-        from src.version import APP_NAME, APP_VERSION, APP_REPO_NAME, APP_REPO_OWNER
-        found_update = check_for_updates(APP_REPO_NAME, APP_REPO_OWNER, APP_NAME, APP_VERSION)
-        if found_update:
-            dialog = UpdateDialog(found_update, APP_VERSION)
-            dialog.exec()
-        else:
-            QMessageBox.information(None, "No Update", "No updates available.")
-
-
-class UpdateDialog(QDialog):
-    def __init__(self, release_info, current_version, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle(f"Update Available ({current_version} -> {release_info['tag_name']})")
-
-        layout = QVBoxLayout()
-        label = QLabel(f"A new version ({release_info['tag_name']}) is available! Current version: {current_version}")
-        layout.addWidget(label)
-
-        # Label to show the release notes
-        description = QLabel(release_info["body"])
-        layout.addWidget(description)
-
-        # Button to download the latest version
-        download_button = QPushButton(f"Download Latest Version ({release_info['tag_name']})")
-        download_button.clicked.connect(lambda: self.open_url(release_info["html_url"]))
-        layout.addWidget(download_button)
-
-        # OK button to dismiss the dialog
-        ok_button = QPushButton("Dismiss")
-        ok_button.clicked.connect(self.accept)  # Close the dialog when clicked
-        layout.addWidget(ok_button)
-
-        self.setLayout(layout)
-
-    def open_url(self, url):
-        from PyQt6.QtCore import QUrl
-        from PyQt6.QtGui import QDesktopServices
-        QDesktopServices.openUrl(QUrl(url))
-        self.accept()

src/ui/widgets/statusbar.py

@@ -32,23 +32,20 @@ class StatusBar(QStatusBar):
 
             # Check for status change every 1s on background thread
             while True:
-                try:
-                    # update status label - get download status
                 new_status = proxy.status()
+                new_image_name = image_names.get(new_status, 'Synchronize.png')
+                image_path = os.path.join(resources_dir(), new_image_name)
+                self.label.setPixmap((QPixmap(image_path).scaled(16, 16, Qt.AspectRatioMode.KeepAspectRatio)))
+
+                # add download status
                 if EngineManager.download_tasks:
                     if len(EngineManager.download_tasks) == 1:
                         task = EngineManager.download_tasks[0]
                         new_status = f"{new_status} | Downloading {task.engine.capitalize()} {task.version}..."
                     else:
                         new_status = f"{new_status} | Downloading {len(EngineManager.download_tasks)} engines"
-                    self.messageLabel.setText(new_status)
 
-                    # update status image
+                self.messageLabel.setText(new_status)
-                    new_image_name = image_names.get(new_status, 'Synchronize.png')
-                    new_image_path = os.path.join(resources_dir(), new_image_name)
-                    self.label.setPixmap((QPixmap(new_image_path).scaled(16, 16, Qt.AspectRatioMode.KeepAspectRatio)))
-                except RuntimeError:  # ignore runtime errors during shutdown
-                    pass
                 time.sleep(1)
 
         background_thread = threading.Thread(target=background_update,)

src/utilities/config.py

@@ -10,7 +10,7 @@ class Config:
     max_content_path = 100000000
     server_log_level = 'debug'
     log_buffer_length = 250
-    worker_process_timeout = 120
+    subjob_connection_timeout = 120
     flask_log_level = 'error'
     flask_debug_enable = False
     queue_eval_seconds = 1
@@ -28,7 +28,7 @@ class Config:
         cls.max_content_path = cfg.get('max_content_path', cls.max_content_path)
         cls.server_log_level = cfg.get('server_log_level', cls.server_log_level)
         cls.log_buffer_length = cfg.get('log_buffer_length', cls.log_buffer_length)
-        cls.worker_process_timeout = cfg.get('worker_process_timeout', cls.worker_process_timeout)
+        cls.subjob_connection_timeout = cfg.get('subjob_connection_timeout', cls.subjob_connection_timeout)
         cls.flask_log_level = cfg.get('flask_log_level', cls.flask_log_level)
         cls.flask_debug_enable = cfg.get('flask_debug_enable', cls.flask_debug_enable)
         cls.queue_eval_seconds = cfg.get('queue_eval_seconds', cls.queue_eval_seconds)

src/utilities/misc_helper.py

@@ -159,33 +159,6 @@ def copy_directory_contents(src_dir, dst_dir):
             shutil.copy2(src_path, dst_path)
 
 
-def check_for_updates(repo_name, repo_owner, app_name, current_version):
-    def get_github_releases(owner, repo):
-        import requests
-        url = f"https://api.github.com/repos/{owner}/{repo}/releases"
-        try:
-            response = requests.get(url, timeout=3)
-            response.raise_for_status()
-            releases = response.json()
-            return releases
-        except Exception as e:
-            logger.error(f"Error checking for updates: {e}")
-            return []
-
-    releases = get_github_releases(repo_owner, repo_name)
-    if not releases:
-        return
-
-    latest_version = releases[0]
-    latest_version_tag = latest_version['tag_name']
-
-    from packaging import version
-    if version.parse(latest_version_tag) > version.parse(current_version):
-        logger.info(f"Newer version of {app_name} available. "
-                    f"Latest: {latest_version_tag}, Current: {current_version}")
-        return latest_version
-
-
 def is_localhost(comparison_hostname):
     # this is necessary because socket.gethostname() does not always include '.local' - This is a sanitized comparison
     try:
@@ -210,18 +183,3 @@ def num_to_alphanumeric(num):
         result += characters[remainder]
 
     return result[::-1]  # Reverse the result to get the correct alphanumeric string
-
-
-def iso_datestring_to_formatted_datestring(iso_date_string):
-    from dateutil import parser
-    import pytz
-
-    # Parse the ISO date string into a datetime object and convert timezones
-    date = parser.isoparse(iso_date_string).astimezone(pytz.UTC)
-    local_timezone = datetime.now().astimezone().tzinfo
-    date_local = date.astimezone(local_timezone)
-
-    # Format the date to the desired readable yet sortable format with 12-hour time
-    formatted_date = date_local.strftime('%Y-%m-%d %I:%M %p')
-
-    return formatted_date

src/utilities/server_helper.py

@@ -1,200 +1,47 @@
 import logging
 import os
-import zipfile
+import subprocess
-from concurrent.futures import ThreadPoolExecutor
+import threading
 
-import requests
+from src.utilities.ffmpeg_helper import generate_thumbnail, save_first_frame
-
-from src.api.server_proxy import RenderServerProxy
-from src.utilities.misc_helper import get_file_size_human
-from src.utilities.zeroconf_server import ZeroconfServer
 
 logger = logging.getLogger()
 
 
-def download_missing_frames_from_subjob(local_job, subjob_id, subjob_hostname):
+def generate_thumbnail_for_job(job, thumb_video_path, thumb_image_path, max_width=320):
-    success = True
-    try:
-        local_files = [os.path.basename(x) for x in local_job.file_list()]
-        subjob_proxy = RenderServerProxy(subjob_hostname)
-        subjob_files = subjob_proxy.get_job_files_list(job_id=subjob_id) or []
 
-        for subjob_filename in subjob_files:
+    # Simple thread to generate thumbs in background
-            if subjob_filename not in local_files:
+    def generate_thumb_thread(source):
+        in_progress_path = thumb_video_path + '_IN-PROGRESS'
+        subprocess.run(['touch', in_progress_path])
         try:
-                    logger.debug(f"Downloading new file '{subjob_filename}' from {subjob_hostname}")
+            logger.debug(f"Generating video thumbnail for {source}")
-                    local_save_path = os.path.join(os.path.dirname(local_job.output_path), subjob_filename)
+            generate_thumbnail(source_path=source, dest_path=thumb_video_path, max_width=max_width)
-                    subjob_proxy.download_job_file(job_id=subjob_id, job_filename=subjob_filename,
+        except subprocess.CalledProcessError as err:
-                                                   save_path=local_save_path)
+            logger.error(f"Error generating video thumbnail for {source}: {err}")
-                    logger.debug(f'Downloaded successfully - {local_save_path}')
+
+        try:
+            os.remove(in_progress_path)
+        except FileNotFoundError:
+            pass
+
+    # Determine best source file to use for thumbs
+    source_files = job.file_list() or [job.input_path]
+    if source_files:
+        video_formats = ['.mp4', '.mov', '.avi', '.mpg', '.mpeg', '.mxf', '.m4v', 'mkv']
+        image_formats = ['.jpg', '.png', '.exr']
+
+        image_files = [f for f in source_files if os.path.splitext(f)[-1].lower() in image_formats]
+        video_files = [f for f in source_files if os.path.splitext(f)[-1].lower() in video_formats]
+
+        if (video_files or image_files) and not os.path.exists(thumb_image_path):
+            try:
+                path_of_source = image_files[0] if image_files else video_files[0]
+                logger.debug(f"Generating image thumbnail for {path_of_source}")
+                save_first_frame(source_path=path_of_source, dest_path=thumb_image_path, max_width=max_width)
             except Exception as e:
-                    logger.error(f"Error downloading file '{subjob_filename}' from {subjob_hostname}: {e}")
+                logger.error(f"Exception saving first frame: {e}")
-                    success = False
-    except Exception as e:
-        logger.exception(f'Uncaught exception while trying to download from subjob: {e}')
-        success = False
-    return success
 
-
+        if video_files and not os.path.exists(thumb_video_path):
-def download_all_from_subjob(local_job, subjob_id, subjob_hostname):
+            x = threading.Thread(target=generate_thumb_thread, args=(video_files[0],))
-    """
+            x.start()
-    Downloads and extracts files from a completed subjob on a remote server.
-
-    Parameters:
-    local_job (BaseRenderWorker): The local parent job worker.
-    subjob_id (str or int): The ID of the subjob.
-    subjob_hostname (str): The hostname of the remote server where the subjob is located.
-
-    Returns:
-    bool: True if the files have been downloaded and extracted successfully, False otherwise.
-    """
-
-    child_key = f'{subjob_id}@{subjob_hostname}'
-    logname = f"{local_job.id}:{child_key}"
-    zip_file_path = local_job.output_path + f'_{subjob_hostname}_{subjob_id}.zip'
-
-    # download zip file from server
-    try:
-        local_job.children[child_key]['download_status'] = 'working'
-        logger.info(f"Downloading completed subjob files from {subjob_hostname} to localhost")
-        RenderServerProxy(subjob_hostname).download_all_job_files(subjob_id, zip_file_path)
-        logger.info(f"File transfer complete for {logname} - Transferred {get_file_size_human(zip_file_path)}")
-    except Exception as e:
-        logger.error(f"Error downloading files from remote server: {e}")
-        local_job.children[child_key]['download_status'] = 'failed'
-        return False
-
-    # extract zip
-    try:
-        logger.debug(f"Extracting zip file: {zip_file_path}")
-        extract_path = os.path.dirname(zip_file_path)
-        with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
-            zip_ref.extractall(extract_path)
-            logger.info(f"Successfully extracted zip to: {extract_path}")
-        os.remove(zip_file_path)
-        local_job.children[child_key]['download_status'] = 'complete'
-    except Exception as e:
-        logger.exception(f"Exception extracting zip file: {e}")
-        local_job.children[child_key]['download_status'] = 'failed'
-
-    return local_job.children[child_key].get('download_status', None) == 'complete'
-
-
-def distribute_server_work(start_frame, end_frame, available_servers, method='evenly'):
-    """
-    Splits the frame range among available servers proportionally based on their performance (CPU count).
-
-    Args:
-        start_frame (int): The start frame number of the animation to be rendered.
-        end_frame (int): The end frame number of the animation to be rendered.
-        available_servers (list): A list of available server dictionaries. Each server dictionary should include
-        'hostname' and 'cpu_count' keys (see find_available_servers).
-        method (str, optional): Specifies the distribution method. Possible values are 'cpu_benchmark', 'cpu_count'
-        and 'evenly'.
-        Defaults to 'cpu_benchmark'.
-
-    Returns:
-        list: A list of server dictionaries where each dictionary includes the frame range and total number of
-        frames to be rendered by the server.
-    """
-    # Calculate respective frames for each server
-    def divide_frames_by_cpu_count(frame_start, frame_end, servers):
-        total_frames = frame_end - frame_start + 1
-        total_cpus = sum(server['cpu_count'] for server in servers)
-
-        frame_ranges = {}
-        current_frame = frame_start
-        allocated_frames = 0
-
-        for i, server in enumerate(servers):
-            if i == len(servers) - 1:  # if it's the last server
-                # Give all remaining frames to the last server
-                num_frames = total_frames - allocated_frames
-            else:
-                num_frames = round((server['cpu_count'] / total_cpus) * total_frames)
-                allocated_frames += num_frames
-
-            frame_end_for_server = current_frame + num_frames - 1
-
-            if current_frame <= frame_end_for_server:
-                frame_ranges[server['hostname']] = (current_frame, frame_end_for_server)
-            current_frame = frame_end_for_server + 1
-
-        return frame_ranges
-
-    def divide_frames_by_benchmark(frame_start, frame_end, servers):
-
-        def fetch_benchmark(server):
-            try:
-                benchmark = requests.get(f'http://{server["hostname"]}:{ZeroconfServer.server_port}'
-                                         f'/api/cpu_benchmark').text
-                server['cpu_benchmark'] = benchmark
-                logger.debug(f'Benchmark for {server["hostname"]}: {benchmark}')
-            except requests.exceptions.RequestException as e:
-                logger.error(f'Error fetching benchmark for {server["hostname"]}: {e}')
-
-        # Number of threads to use (can adjust based on your needs or number of servers)
-        threads = len(servers)
-
-        with ThreadPoolExecutor(max_workers=threads) as executor:
-            executor.map(fetch_benchmark, servers)
-
-        total_frames = frame_end - frame_start + 1
-        total_performance = sum(int(server['cpu_benchmark']) for server in servers)
-
-        frame_ranges = {}
-        current_frame = frame_start
-        allocated_frames = 0
-
-        for i, server in enumerate(servers):
-            if i == len(servers) - 1:  # if it's the last server
-                # Give all remaining frames to the last server
-                num_frames = total_frames - allocated_frames
-            else:
-                num_frames = round((int(server['cpu_benchmark']) / total_performance) * total_frames)
-                allocated_frames += num_frames
-
-            frame_end_for_server = current_frame + num_frames - 1
-
-            if current_frame <= frame_end_for_server:
-                frame_ranges[server['hostname']] = (current_frame, frame_end_for_server)
-            current_frame = frame_end_for_server + 1
-
-        return frame_ranges
-
-    def divide_frames_equally(frame_start, frame_end, servers):
-        frame_range = frame_end - frame_start + 1
-        frames_per_server = frame_range // len(servers)
-        leftover_frames = frame_range % len(servers)
-
-        frame_ranges = {}
-        current_start = frame_start
-        for i, server in enumerate(servers):
-            current_end = current_start + frames_per_server - 1
-            if leftover_frames > 0:
-                current_end += 1
-                leftover_frames -= 1
-            if current_start <= current_end:
-                frame_ranges[server['hostname']] = (current_start, current_end)
-            current_start = current_end + 1
-
-        return frame_ranges
-
-    if len(available_servers) == 1:
-        breakdown = {available_servers[0]['hostname']: (start_frame, end_frame)}
-    else:
-        logger.debug(f'Splitting between {len(available_servers)} servers by {method} method')
-        if method == 'evenly':
-            breakdown = divide_frames_equally(start_frame, end_frame, available_servers)
-        elif method == 'cpu_benchmark':
-            breakdown = divide_frames_by_benchmark(start_frame, end_frame, available_servers)
-        elif method == 'cpu_count':
-            breakdown = divide_frames_by_cpu_count(start_frame, end_frame, available_servers)
-        else:
-            raise ValueError(f"Invalid distribution method: {method}")
-
-    server_breakdown = [server for server in available_servers if breakdown.get(server['hostname']) is not None]
-    for server in server_breakdown:
-        server['frame_range'] = breakdown[server['hostname']]
-        server['total_frames'] = breakdown[server['hostname']][-1] - breakdown[server['hostname']][0] + 1
-    return server_breakdown

src/utilities/zeroconf_server.py

@@ -2,8 +2,7 @@ import logging
 import socket
 
 from pubsub import pub
-from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser, ServiceStateChange, NonUniqueNameException, \
+from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser, ServiceStateChange, NonUniqueNameException
-    NotRunningException
 
 logger = logging.getLogger()
 
@@ -32,16 +31,12 @@ class ZeroconfServer:
     def start(cls, listen_only=False):
         if not cls.service_type:
             raise RuntimeError("The 'configure' method must be run before starting the zeroconf server")
-        elif not listen_only:
+        if not listen_only:
-            logger.debug(f"Starting zeroconf service")
             cls._register_service()
-        else:
-            logger.debug(f"Starting zeroconf service - Listen only mode")
         cls._browse_services()
 
     @classmethod
     def stop(cls):
-        logger.debug("Stopping zeroconf service")
         cls._unregister_service()
         cls.zeroconf.close()
 
@@ -78,7 +73,6 @@ class ZeroconfServer:
 
     @classmethod
     def _on_service_discovered(cls, zeroconf, service_type, name, state_change):
-        try:
         info = zeroconf.get_service_info(service_type, name)
         hostname = name.split(f'.{cls.service_type}')[0]
         logger.debug(f"Zeroconf: {hostname} {state_change}")
@@ -88,8 +82,6 @@ class ZeroconfServer:
             else:
                 cls.client_cache.pop(hostname)
             pub.sendMessage('zeroconf_state_change', hostname=hostname, state_change=state_change)
-        except NotRunningException:
-            pass
 
     @classmethod
     def found_hostnames(cls):
@@ -112,15 +104,9 @@ class ZeroconfServer:
 
 # Example usage:
 if __name__ == "__main__":
-    import time
-
-    logging.basicConfig(level=logging.DEBUG)
     ZeroconfServer.configure("_zordon._tcp.local.", "foobar.local", 8080)
     try:
         ZeroconfServer.start()
-        while True:
+        input("Server running - Press enter to end")
-            time.sleep(0.1)
-    except KeyboardInterrupt:
-        pass
     finally:
         ZeroconfServer.stop()

src/version.py

@@ -1,8 +0,0 @@
-APP_NAME = "Zordon"
-APP_VERSION = "0.0.1"
-APP_AUTHOR = "Brett Williams"
-APP_DESCRIPTION = "Distributed Render Farm Tools"
-APP_COPYRIGHT_YEAR = "2024"
-APP_LICENSE = "MIT License"
-APP_REPO_NAME = APP_NAME
-APP_REPO_OWNER = "blw1138"