More code re-organizing

src/engines/aerender/aerender_engine.py

@@ -1,7 +1,4 @@
-try:
-    from .base_engine import *
-except ImportError:
-    from base_engine import *
+from src.engines.core.base_engine import BaseRenderEngine
 
 
 class AERender(BaseRenderEngine):

src/engines/aerender/aerender_worker.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import glob
+import json
+import logging
+import os
+import re
+import time
+
+from src.engines.core.base_worker import BaseRenderWorker, timecode_to_frames
+from src.engines.aerender.aerender_engine import AERender
+
+
+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):
+        super(AERenderWorker, self).__init__(input_path=input_path, output_path=output_path, args=args,
+                                             parent=parent, name=name)
+
+        self.comp = args.get('comp', None)
+        self.render_settings = args.get('render_settings', None)
+        self.omsettings = args.get('omsettings', None)
+
+        self.progress = 0
+        self.progress_history = []
+        self.attributes = {}
+
+    def generate_worker_subprocess(self):
+
+        if os.path.exists('nexrender-cli-macos'):
+            logging.info('nexrender found')
+            # {
+            #     "template": {
+            #         "src": String,
+            #         "composition": String,
+            #
+            #         "frameStart": Number,
+            #         "frameEnd": Number,
+            #         "frameIncrement": Number,
+            #
+            #         "continueOnMissing": Boolean,
+            #         "settingsTemplate": String,
+            #         "outputModule": String,
+            #         "outputExt": String,
+            #     },
+            #     "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):
+
+        # print line
+        if line.startswith('PROGRESS:'):
+            # print 'progress'
+            trimmed = line.replace('PROGRESS:', '').strip()
+            if len(trimmed):
+                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()
+        elif line.startswith('WARNING:'):
+            trimmed = line.replace('WARNING:', '').strip()
+            self.warnings.append(trimmed)
+            logging.warning(trimmed)
+        elif line.startswith('aerender ERROR') or 'ERROR:' in line:
+            self.log_error(line)
+
+    def _update_progress(self, line):
+
+        if not self.total_frames:
+            duration_string = self.attributes.get('Duration', None)
+            frame_rate = self.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']
+
+    def average_frame_duration(self):
+
+        total_durations = 0
+
+        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
+        return average
+
+    def percent_complete(self):
+        if self.total_frames:
+            return (float(self.last_frame) / float(self.total_frames)) * 100
+        else:
+            return 0
+
+
+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"',
+                   '"Draft Settings"', '"ProRes"', '/Users/brett/Desktop/test_render')
+    r.start()
+    while r.is_running():
+        time.sleep(0.1)

src/engines/blender/blender_downloader.py

@@ -1,11 +1,10 @@
 import logging
-import os
 import platform
 import re
 
 import requests
 
-from .downloader_core import download_and_extract_app
+from ..core.downloader_core import download_and_extract_app
 
 # url = "https://download.blender.org/release/"
 url = "https://ftp.nluug.nl/pub/graphics/blender/release/"  # much faster mirror for testing

src/engines/blender/blender_engine.py

@@ -1,10 +1,8 @@
-try:
-    from .base_engine import *
-except ImportError:
-    from base_engine import *
 import json
 import re
-import logging
+
+from src.engines.core.base_engine import *
+from src.utilities.misc_helper import system_safe_path
 
 logger = logging.getLogger()
 
@@ -58,8 +56,7 @@ class Blender(BaseRenderEngine):
     def get_scene_info(self, project_path, timeout=10):
         scene_info = {}
         try:
-            script_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                       'scripts', 'blender', 'get_file_info.py')
+            script_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'scripts', 'get_file_info.py')
             results = self.run_python_script(project_path, system_safe_path(script_path), timeout=timeout)
             result_text = results.stdout.decode()
             for line in result_text.splitlines():

src/engines/blender/blender_worker.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+import re
+from collections import Counter
+
+from src.engines.blender.blender_engine import Blender
+from src.utilities.ffmpeg_helper import image_sequence_to_video
+from src.engines.core.base_worker import *
+
+
+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)
+
+        # Args
+        self.blender_engine = self.args.get('engine', 'BLENDER_EEVEE').upper()
+        self.export_format = self.args.get('export_format', None) or 'JPEG'
+        self.camera = self.args.get('camera', None)
+
+        # Stats
+        self.__frame_percent_complete = 0.0
+
+        # Scene Info
+        self.scene_info = Blender(engine_path).get_scene_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):
+
+        cmd = [self.renderer_path]
+        if self.args.get('background', True):  # optionally run render not in background
+            cmd.append('-b')
+        cmd.append(self.input_path)
+
+        # Python expressions
+        cmd.append('--python-expr')
+        python_exp = 'import bpy; bpy.context.scene.render.use_overwrite = False;'
+        if self.camera:
+            python_exp = python_exp + f"bpy.context.scene.camera = bpy.data.objects['{self.camera}'];"
+        # insert any other python exp checks here
+        cmd.append(python_exp)
+
+        path_without_ext = os.path.splitext(self.output_path)[0] + "_"
+        cmd.extend(['-E', self.blender_engine, '-o', path_without_ext, '-F', self.export_format])
+
+        # set frame range
+        cmd.extend(['-s', self.start_frame, '-e', self.end_frame, '-a'])
+
+        # Convert raw args from string if available
+        raw_args = self.get_raw_args()
+        if raw_args:
+            cmd.extend(raw_args)
+
+        return cmd
+
+    def _parse_stdout(self, line):
+
+        pattern = re.compile(
+            r'Fra:(?P<frame>\d*).*Mem:(?P<memory>\S+).*Time:(?P<time>\S+)(?:.*Remaining:)?(?P<remaining>\S*)')
+        found = pattern.search(line)
+        if found:
+            stats = found.groupdict()
+            memory_use = stats['memory']
+            time_elapsed = stats['time']
+            time_remaining = stats['remaining'] or 'Unknown'
+
+            sample_string = line.split('|')[-1].strip()
+            if "sample" in sample_string.lower():
+                samples = re.sub(r'[^\d/]', '', sample_string)
+                self.__frame_percent_complete = int(samples.split('/')[0]) / int(samples.split('/')[-1])
+
+            if int(stats['frame']) > self.current_frame:
+                self.current_frame = int(stats['frame'])
+                logger.debug(
+                    'Frame:{0} | Mem:{1} | Time:{2} | Remaining:{3}'.format(self.current_frame, memory_use,
+                                                                            time_elapsed, time_remaining))
+        elif "file doesn't exist" in line.lower():
+            self.log_error(line, halt_render=True)
+        elif line.lower().startswith('error'):
+            self.log_error(line)
+        elif 'Saved' in line or 'Saving' in line or 'quit' in line:
+            match = re.match(r'Time: (.*) \(Saving', line)
+            if match:
+                time_completed = match.groups()[0]
+                frame_count = self.current_frame - self.end_frame + self.total_frames
+                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(line)
+        else:
+            pass
+            # if len(line.strip()):
+            #     logger.debug(line.strip())
+
+    def percent_complete(self):
+        if self.total_frames <= 1:
+            return self.__frame_percent_complete
+        else:
+            whole_frame_percent = (self.current_frame - self.start_frame) / self.total_frames
+            adjusted_frame_percent = self.__frame_percent_complete / self.total_frames
+            total_percent = whole_frame_percent + adjusted_frame_percent
+            return max(total_percent, 0)
+
+    def post_processing(self):
+
+        def most_common_extension(file_paths):
+            extensions = [os.path.splitext(path)[1] for path in file_paths]
+            counter = Counter(extensions)
+            most_common_ext, _ = counter.most_common(1)[0]
+            return most_common_ext
+
+        output_dir_files = os.listdir(os.path.dirname(self.output_path))
+        if self.total_frames > 1 and len(output_dir_files) > 1 and not self.parent:
+            logger.info("Generating preview for image sequence")
+
+            # Calculate what the real start frame # is if we have child objects
+            start_frame = self.start_frame
+            if self.children:
+                min_child_frame = min(int(child["start_frame"]) for child in self.children.values())
+                start_frame = min(min_child_frame, self.start_frame)
+                logger.debug(f"Post processing start frame #{start_frame}")
+
+            try:
+                pattern = os.path.splitext(self.output_path)[0] + "_%04d" + most_common_extension(output_dir_files)
+                image_sequence_to_video(source_glob_pattern=pattern,
+                                        output_path=self.output_path + '.mov',
+                                        framerate=self.scene_info['fps'],
+                                        start_frame=start_frame)
+                logger.info('Successfully generated preview video from image sequence')
+            except Exception as e:
+                logger.error(f'Error generating video from image sequence: {e}')
+
+
+if __name__ == '__main__':
+
+    import pprint
+    x = Blender.get_scene_info('/Users/brett/Desktop/TC Previz/nallie_farm.blend')
+    pprint.pprint(x)
+
+    # logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG)
+    # r = BlenderRenderWorker('/Users/brett/Blender Files/temple_animatic.blend', '/Users/brett/testing1234')
+    # # r.engine = 'CYCLES'
+    # r.start()
+    # while r.is_running():
+    #     time.sleep(1)

src/engines/core/base_worker.py

@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+import io
+import json
+import logging
+import os
+import subprocess
+import threading
+from datetime import datetime
+
+import psutil
+from pubsub import pub
+from sqlalchemy import Column, Integer, String, DateTime, JSON
+from sqlalchemy.ext.declarative import declarative_base
+
+from src.utilities.misc_helper import get_time_elapsed
+from src.utilities.status_utils import RenderStatus, string_to_status
+
+logger = logging.getLogger()
+Base = declarative_base()
+
+
+class BaseRenderWorker(Base):
+    __tablename__ = 'render_workers'
+
+    id = Column(String, primary_key=True)
+    input_path = Column(String)
+    output_path = Column(String)
+    date_created = Column(DateTime)
+    start_time = Column(DateTime, nullable=True)
+    end_time = Column(DateTime, nullable=True)
+    renderer = Column(String)
+    renderer_version = Column(String)
+    renderer_path = Column(String)
+    priority = Column(Integer)
+    project_length = Column(Integer)
+    start_frame = Column(Integer)
+    end_frame = Column(Integer, nullable=True)
+    parent = Column(String, nullable=True)
+    children = Column(JSON)
+    name = Column(String)
+    file_hash = Column(String)
+    _status = Column(String)
+
+    engine = None
+
+    def __init__(self, input_path, output_path, engine_path, priority=2, args=None, ignore_extensions=True, parent=None,
+                 name=None):
+
+        if not ignore_extensions:
+            if not any(ext in input_path for ext in self.engine.supported_extensions):
+                err_meg = f'Cannot find valid project with supported file extension for {self.engine.name()} renderer'
+                logger.error(err_meg)
+                raise ValueError(err_meg)
+        if not self.engine:
+            raise NotImplementedError("Engine not defined")
+
+        def generate_id():
+            import uuid
+            return str(uuid.uuid4()).split('-')[0]
+
+        # Essential Info
+        self.id = generate_id()
+        self.input_path = input_path
+        self.output_path = output_path
+        self.args = args or {}
+        self.date_created = datetime.now()
+        self.renderer = self.engine.name()
+        self.renderer_path = engine_path
+        self.renderer_version = self.engine(engine_path).version()
+        self.custom_renderer_path = None
+        self.priority = priority
+        self.parent = parent
+        self.children = {}
+        self.name = name or os.path.basename(input_path)
+
+        # Frame Ranges
+        self.project_length = -1
+        self.current_frame = 0  # should this be a 1 ?
+        self.start_frame = 0  # should this be a 1 ?
+        self.end_frame = None
+
+        # Logging
+        self.start_time = None
+        self.end_time = None
+
+        # History
+        self.status = RenderStatus.CONFIGURING
+        self.warnings = []
+        self.errors = []
+
+        # Threads and processes
+        self.__thread = threading.Thread(target=self.run, args=())
+        self.__thread.daemon = True
+        self.__process = None
+        self.last_output = None
+
+    @property
+    def total_frames(self):
+        return (self.end_frame or self.project_length) - self.start_frame + 1
+
+    @property
+    def status(self):
+        return self._status
+
+    @status.setter
+    def status(self, new_status):
+        if self._status != new_status.value:
+            old_status = self.status
+            self._status = new_status.value
+            pub.sendMessage('status_change', job_id=self.id, old_status=old_status, new_status=new_status)
+
+    @status.getter
+    def status(self):
+        if self._status in [RenderStatus.RUNNING.value, RenderStatus.NOT_STARTED.value]:
+            if not hasattr(self, 'errors'):
+                self._status = RenderStatus.CANCELLED.value
+        return string_to_status(self._status)
+
+    def validate(self):
+        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 = "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', 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'
+        return os.path.join(os.path.dirname(self.input_path), filename)
+
+    def start(self):
+
+        if self.status not in [RenderStatus.SCHEDULED, RenderStatus.NOT_STARTED]:
+            logger.error(f"Trying to start job with status: {self.status}")
+            return
+
+        if not os.path.exists(self.input_path):
+            self.status = RenderStatus.ERROR
+            msg = 'Cannot find input path: {}'.format(self.input_path)
+            logger.error(msg)
+            self.errors.append(msg)
+            return
+
+        if not os.path.exists(self.renderer_path):
+            self.status = RenderStatus.ERROR
+            msg = 'Cannot find render engine path for {}'.format(self.engine.name())
+            logger.error(msg)
+            self.errors.append(msg)
+            return
+
+        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()
+
+    def run(self):
+        # 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())
+        attempt_number = 0
+
+        with open(self.log_path(), "a") as f:
+
+            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: {subprocess_cmds}\n")
+            f.write('=' * 80 + '\n\n')
+
+            while True:
+                # Log attempt #
+                if attempt_number:
+                    f.write(f'\n{"=" * 80} Attempt #{attempt_number} {"=" * 30}\n\n')
+                    logger.warning(f"Restarting render - Attempt #{attempt_number}")
+                attempt_number += 1
+
+                # Start process and get updates
+                self.__process = subprocess.Popen(subprocess_cmds, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                                  universal_newlines=False)
+
+                for c in io.TextIOWrapper(self.__process.stdout, encoding="utf-8"):  # or another encoding
+                    f.write(c)
+                    self.last_output = c.strip()
+                    self._parse_stdout(c.strip())
+
+                f.write('\n')
+
+                # Check return codes and process
+                return_code = self.__process.wait()
+                self.end_time = datetime.now()
+
+                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)
+                    return
+
+                if not return_code:
+                    message = f"{'=' * 50}\n\n{self.engine.name()} render completed successfully in {self.time_elapsed()}"
+                    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()}"
+                f.write(message)
+                self.errors.append(message)
+
+                # if file output hasn't increased, return as error, otherwise restart process.
+                if len(self.file_list()) <= initial_file_count:
+                    self.status = RenderStatus.ERROR
+                    return
+
+        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
+
+    def is_running(self):
+        if self.__thread:
+            return self.__thread.is_alive()
+        return False
+
+    def log_error(self, error_line, halt_render=False):
+        logger.error(error_line)
+        self.errors.append(error_line)
+        if halt_render:
+            self.stop(is_error=True)
+
+    def stop(self, is_error=False):
+        if hasattr(self, '__process'):
+            try:
+                process = psutil.Process(self.__process.pid)
+                for proc in process.children(recursive=True):
+                    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}")
+                self.status = RenderStatus.ERROR
+            else:
+                self.status = RenderStatus.CANCELLED
+
+    def percent_complete(self):
+        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)
+
+    def file_list(self):
+        try:
+            job_dir = os.path.dirname(self.output_path)
+            file_list = [os.path.join(job_dir, file) for file in os.listdir(job_dir)]
+            file_list.sort()
+            return file_list
+        except FileNotFoundError:
+            return []
+
+    def json(self):
+        job_dict = {
+            'id': self.id,
+            'name': self.name,
+            'input_path': self.input_path,
+            'output_path': self.output_path,
+            'priority': self.priority,
+            'parent': self.parent,
+            'children': self.children,
+            'date_created': self.date_created,
+            'start_time': self.start_time,
+            'end_time': self.end_time,
+            'status': self.status.value,
+            'file_hash': self.file_hash,
+            'percent_complete': self.percent_complete(),
+            'file_count': len(self.file_list()),
+            'renderer': self.renderer,
+            'renderer_version': self.renderer_version,
+            'errors': getattr(self, 'errors', None),
+            'start_frame': self.start_frame,
+            'end_frame': self.end_frame,
+            'total_frames': self.total_frames,
+            'last_output': getattr(self, 'last_output', None),
+            'log_path': self.log_path()
+        }
+
+        # convert to json and back to auto-convert dates to iso format
+        def date_serializer(o):
+            if isinstance(o, datetime):
+                return o.isoformat()
+
+        json_convert = json.dumps(job_dict, default=date_serializer)
+        worker_json = json.loads(json_convert)
+        return worker_json
+
+
+def timecode_to_frames(timecode, frame_rate):
+    e = [int(x) for x in timecode.split(':')]
+    seconds = (((e[0] * 60) + e[1] * 60) + e[2])
+    frames = (seconds * frame_rate) + e[-1] + 1
+    return frames

src/engines/core/worker_factory.py

@@ -0,0 +1,50 @@
+import logging
+from src.engines.engine_manager import EngineManager
+
+logger = logging.getLogger()
+
+
+class RenderWorkerFactory:
+
+    @staticmethod
+    def supported_classes():
+        # to add support for any additional RenderWorker classes, import their classes and add to list here
+        from src.engines.blender.blender_worker import BlenderRenderWorker
+        from src.engines.aerender.aerender_worker import AERenderWorker
+        from src.engines.ffmpeg.ffmpeg_worker import FFMPEGRenderWorker
+        classes = [BlenderRenderWorker, AERenderWorker, FFMPEGRenderWorker]
+        return classes
+
+    @staticmethod
+    def create_worker(renderer, input_path, output_path, engine_version=None, args=None, parent=None, name=None):
+
+        worker_class = RenderWorkerFactory.class_for_name(renderer)
+
+        # find correct engine version
+        all_versions = EngineManager.all_versions_for_engine(renderer)
+        if not all_versions:
+            raise FileNotFoundError(f"Cannot find any installed {renderer} engines")
+
+        engine_path = all_versions[0]['path']
+        if engine_version:
+            for ver in all_versions:
+                if ver['version'] == engine_version:
+                    engine_path = ver['path']
+                    break
+            if not engine_path:
+                logger.warning(f"Cannot find requested engine version {engine_version}. Using default version {all_versions[0]['version']}")
+
+        return worker_class(input_path=input_path, output_path=output_path, engine_path=engine_path, args=args,
+                            parent=parent, name=name)
+
+    @staticmethod
+    def supported_renderers():
+        return [x.engine.name() for x in RenderWorkerFactory.supported_classes()]
+
+    @staticmethod
+    def class_for_name(name):
+        name = name.lower()
+        for render_class in RenderWorkerFactory.supported_classes():
+            if render_class.engine.name() == name:
+                return render_class
+        raise LookupError(f'Cannot find class for name: {name}')

src/engines/engine_manager.py

@@ -1,19 +1,13 @@
-import os
 import logging
+import os
 import platform
 import shutil
-from .downloaders.blender_downloader import BlenderDownloader
-from .downloaders.ffmpeg_downloader import FFMPEGDownloader
-from ..utilities.misc_helper import system_safe_path
 
-try:
-    from .blender_engine import Blender
-except ImportError:
-    from blender_engine import Blender
-try:
-    from .ffmpeg_engine import FFMPEG
-except ImportError:
-    from ffmpeg_engine import FFMPEG
+from src.engines.blender.blender_downloader import BlenderDownloader
+from src.engines.blender.blender_engine import Blender
+from src.engines.ffmpeg.ffmpeg_downloader import FFMPEGDownloader
+from src.engines.ffmpeg.ffmpeg_engine import FFMPEG
+from src.utilities.misc_helper import system_safe_path
 
 logger = logging.getLogger()
 

src/engines/ffmpeg/ffmpeg_downloader.py

@@ -5,7 +5,7 @@ import re
 
 import requests
 
-from .downloader_core import download_and_extract_app
+from src.engines.core.downloader_core import download_and_extract_app
 
 logger = logging.getLogger()
 supported_formats = ['.zip', '.tar.xz', '.dmg']

src/engines/ffmpeg/ffmpeg_engine.py

@@ -1,9 +1,7 @@
-try:
-    from .base_engine import *
-except ImportError:
-    from base_engine import *
 import re
 
+from src.engines.core.base_engine import *
+
 
 class FFMPEG(BaseRenderEngine):
 

src/engines/ffmpeg/ffmpeg_worker.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+import re
+import subprocess
+
+from src.engines.core.base_worker import BaseRenderWorker
+from src.engines.ffmpeg.ffmpeg_engine import FFMPEG
+
+
+class FFMPEGRenderWorker(BaseRenderWorker):
+
+    engine = FFMPEG
+
+    def __init__(self, input_path, output_path, args=None, parent=None, name=None):
+        super(FFMPEGRenderWorker, self).__init__(input_path=input_path, output_path=output_path, args=args,
+                                                 parent=parent, name=name)
+
+        stream_info = subprocess.check_output([self.renderer_path, "-i",  # https://stackoverflow.com/a/61604105
+                                               input_path, "-map", "0:v:0", "-c", "copy", "-f", "null", "-y",
+                                                     "/dev/null"], stderr=subprocess.STDOUT).decode('utf-8')
+        found_frames = re.findall('frame=\s*(\d+)', stream_info)
+        self.project_length = found_frames[-1] if found_frames else '-1'
+        self.current_frame = -1
+
+    def generate_worker_subprocess(self):
+
+        cmd = [self.engine.default_renderer_path(), '-y', '-stats', '-i', self.input_path]
+
+        # Resize frame
+        if self.args.get('x_resolution', None) and self.args.get('y_resolution', None):
+            cmd.extend(['-vf', f"scale={self.args['x_resolution']}:{self.args['y_resolution']}"])
+
+        # Convert raw args from string if available
+        raw_args = self.args.get('raw', None)
+        if raw_args:
+            cmd.extend(raw_args.split(' '))
+
+        # Close with output path
+        cmd.append(self.output_path)
+        return cmd
+
+    def percent_complete(self):
+        return max(float(self.current_frame) / float(self.total_frames), 0.0)
+
+    def _parse_stdout(self, line):
+        pattern = re.compile(r'frame=\s*(?P<current_frame>\d+)\s*fps.*time=(?P<time_elapsed>\S+)')
+        found = pattern.search(line)
+        if found:
+            stats = found.groupdict()
+            self.current_frame = stats['current_frame']
+            time_elapsed = stats['time_elapsed']
+        elif "not found" in line:
+            self.log_error(line)