From c73b6d1da7fa1ae69558806eea740e206ef9ccdd Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 18:53:19 -0500 Subject: [PATCH 1/8] BaseRenderWorker split into BaseRenderWorker & BaseRenderEngine --- lib/render_workers/render_worker.py | 93 +++++++++++++++++------------ 1 file changed, 56 insertions(+), 37 deletions(-) diff --git a/lib/render_workers/render_worker.py b/lib/render_workers/render_worker.py index 4ee6cb6..94ac298 100644 --- a/lib/render_workers/render_worker.py +++ b/lib/render_workers/render_worker.py @@ -30,27 +30,24 @@ def string_to_status(string): class BaseRenderWorker(object): - renderer = 'BaseRenderWorker' - render_engine = None - render_engine_version = None - supported_extensions = [] - install_paths = [] - supported_export_formats = [] + engine = None def __init__(self, input_path, output_path, args=None, ignore_extensions=True): if not ignore_extensions: - if not any(ext in input_path for ext in self.supported_extensions): - err_meg = f'Cannot find valid project with supported file extension for {self.renderer} renderer' + 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") # Essential Info self.input_path = input_path self.output_path = output_path self.args = args or {} self.date_created = datetime.now() - self.renderer_version = self.version() + self.renderer_version = self.engine.version() # Frame Ranges self.total_frames = 0 @@ -75,23 +72,6 @@ class BaseRenderWorker(object): self.is_finished = False self.last_output = None - @classmethod - def version(cls): - raise NotImplementedError("Unknown version") - - @classmethod - def renderer_path(cls): - path = None - try: - path = subprocess.check_output(['which', cls.render_engine]).decode('utf-8').strip() - except subprocess.CalledProcessError: - for p in cls.install_paths: - if os.path.exists(p): - path = p - except Exception as e: - logging.exception(e) - return path - def validate(self): if not os.path.exists(self.input_path): raise FileNotFoundError(f"Cannot find input path: {self.input_path}") @@ -128,9 +108,9 @@ class BaseRenderWorker(object): self.errors.append(msg) return - if not self.renderer_path(): + if not self.engine.renderer_path(): self.status = RenderStatus.ERROR - msg = 'Cannot find render engine path for {}'.format(self.render_engine) + msg = 'Cannot find render engine path for {}'.format(self.engine.name()) logger.error(msg) self.errors.append(msg) return @@ -166,12 +146,12 @@ class BaseRenderWorker(object): with open(self.log_path, "a") as f: - f.write("{3} - Starting {0} {1} Render for {2}\n".format(self.renderer, self.version(), self.input_path, - self.start_time.isoformat())) + f.write(f"{self.start_time.isoformat()} - Starting {self.engine.name()} {self.engine.version()} " + f"Render for {self.input_path}") f.write(f"Running command: {' '.join(subprocess_cmds)}\n") for c in io.TextIOWrapper(self.__process.stdout, encoding="utf-8"): # or another encoding f.write(c) - logger.debug(f"{self.renderer}Worker: {c.strip()}") + logger.debug(f"{self.engine.name()}Worker: {c.strip()}") self.last_output = c.strip() self._parse_stdout(c.strip()) f.write('\n') @@ -187,18 +167,19 @@ class BaseRenderWorker(object): duration = self.end_time - self.start_time if return_code: - message = f"{self.renderer} render failed with return_code {return_code} after {duration}" + message = f"{self.engine.name()} render failed with return_code {return_code} after {duration}" logger.error(message) self.failed_attempts = self.failed_attempts + 1 else: - message = f"{self.renderer} render completed successfully in {duration}" + message = f"{self.engine.name()} render completed successfully in {duration}" logger.info(message) self.status = RenderStatus.COMPLETED f.write(message) if self.failed_attempts >= self.maximum_attempts and self.status is not RenderStatus.CANCELLED: - logger.error('{} Render of {} failed after {} attempts'.format(self.renderer, self.input_path, self.failed_attempts)) + logger.error('{} Render of {} failed after {} attempts'.format(self.engine.name(), self.input_path, + self.failed_attempts)) self.status = RenderStatus.ERROR if not self.errors: self.errors = [self.last_output] @@ -237,6 +218,45 @@ class BaseRenderWorker(object): return elapsed +class BaseRenderEngine(object): + + install_paths = [] + supported_extensions = [] + + @classmethod + def name(cls): + return cls.__name__.lower() + + @classmethod + def renderer_path(cls): + path = None + try: + path = subprocess.check_output(['which', cls.name()]).decode('utf-8').strip() + except subprocess.CalledProcessError: + for p in cls.install_paths: + if os.path.exists(p): + path = p + except Exception as e: + logging.exception(e) + return path + + @classmethod + def version(cls): + raise NotImplementedError("version not implemented") + + @classmethod + def get_help(cls): + path = cls.renderer_path() + if not path: + raise FileNotFoundError("renderer path not found") + help_doc = subprocess.check_output([path, '-h'], stderr=subprocess.STDOUT).decode('utf-8') + return help_doc + + @classmethod + def get_formats(cls): + raise NotImplementedError("get_formats not implemented") + + class RenderWorkerFactory: @staticmethod @@ -255,15 +275,14 @@ class RenderWorkerFactory: @staticmethod def supported_renderers(): - return [x.render_engine for x in RenderWorkerFactory.supported_classes()] + 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.render_engine == name: + if render_class.engine.name() == name: return render_class - raise LookupError(f'Cannot find class for name: {name}') From 074b802d456d4f6759aa2582891047c3c199753a Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 18:55:54 -0500 Subject: [PATCH 2/8] blender_worker refactoring --- lib/render_workers/blender_worker.py | 70 +++++++++++++++++----------- 1 file changed, 42 insertions(+), 28 deletions(-) diff --git a/lib/render_workers/blender_worker.py b/lib/render_workers/blender_worker.py index 73d62c8..bb5ff44 100644 --- a/lib/render_workers/blender_worker.py +++ b/lib/render_workers/blender_worker.py @@ -4,14 +4,39 @@ import re from .render_worker import * +class Blender(BaseRenderEngine): + + install_paths = ['/Applications/Blender.app/Contents/MacOS/Blender'] + supported_extensions = ['.blend'] + + @classmethod + def version(cls): + version = None + try: + render_path = cls.renderer_path() + if render_path: + ver_out = subprocess.check_output([render_path, '-v']) + version = ver_out.decode('utf-8').splitlines()[0].replace('Blender', '').strip() + except Exception as e: + logging.error(f'Failed to get Blender version: {e}') + return version + + @classmethod + def get_formats(cls): + format_string = cls.get_help().split('Format Options')[-1].split('Animation Playback Options')[0] + formats = re.findall(r"'([A-Z_0-9]+)'", format_string) + return formats + + @classmethod + def full_report(cls): + return {'version': cls.version(), + 'help_text': cls.get_help(), + 'formats': cls.get_formats()} + + class BlenderRenderWorker(BaseRenderWorker): - renderer = 'Blender' - render_engine = 'blender' - supported_extensions = ['.blend'] - install_paths = ['/Applications/Blender.app/Contents/MacOS/Blender'] - supported_export_formats = ['TGA', 'RAWTGA', 'JPEG', 'IRIS', 'IRIZ', 'AVIRAW', 'AVIJPEG', 'PNG', 'BMP', 'HDR', - 'TIFF', 'OPEN_EXR', 'OPEN_EXR_MULTILAYER', 'MPEG', 'CINEON', 'DPX', 'DDS', 'JP2'] + engine = Blender def __init__(self, input_path, output_path, args=None): super(BlenderRenderWorker, self).__init__(input_path=input_path, output_path=output_path, @@ -34,21 +59,9 @@ class BlenderRenderWorker(BaseRenderWorker): if self.render_all_frames else 1 self.current_frame = int(self.scene_info.get('frame_start', 0)) - @classmethod - def version(cls): - version = None - try: - render_path = cls.renderer_path() - if render_path: - ver_out = subprocess.check_output([render_path, '-v']) - version = ver_out.decode('utf-8').splitlines()[0].replace('Blender', '').strip() - except Exception as e: - logging.error(f'Failed to get {cls.renderer} version: {e}') - return version - def generate_worker_subprocess(self): - cmd = [self.renderer_path()] + cmd = [self.engine.renderer_path()] if self.args.get('background', True): # optionally run render not in background cmd.append('-b') cmd.append(self.input_path) @@ -131,7 +144,7 @@ class BlenderRenderWorker(BaseRenderWorker): def run_python_expression_in_blend(path, python_expression): if os.path.exists(path): try: - return subprocess.run([BlenderRenderWorker.renderer_path(), '-b', path, '--python-expr', python_expression], + return subprocess.run([Blender.renderer_path(), '-b', path, '--python-expr', python_expression], capture_output=True) except Exception as e: logger.warning(f"Error running python expression in blender: {e}") @@ -143,8 +156,7 @@ def run_python_expression_in_blend(path, python_expression): def run_python_script_in_blend(path, python_path): if os.path.exists(path) and os.path.exists(python_path): try: - return subprocess.run([BlenderRenderWorker.renderer_path(), '-b', path, '--python', python_path], - capture_output=True) + return subprocess.run([Blender.renderer_path(), '-b', path, '--python', python_path], capture_output=True) except Exception as e: logger.warning(f"Error running python expression in blender: {e}") pass @@ -201,12 +213,14 @@ def get_scene_info(path): if __name__ == '__main__': + print(Blender.full_report()) + # x = pack_blender_files('/Users/brett/Blender Files/temple_animatic.blend') # print(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) + # 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) From 9579542ea37853689d3fffb9a6b96f9be866cacc Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:00:46 -0500 Subject: [PATCH 3/8] ffmpeg_worker refacoring --- lib/render_workers/ffmpeg_worker.py | 83 +++++++++++++++++++---------- 1 file changed, 54 insertions(+), 29 deletions(-) diff --git a/lib/render_workers/ffmpeg_worker.py b/lib/render_workers/ffmpeg_worker.py index fee773f..33ecdf8 100644 --- a/lib/render_workers/ffmpeg_worker.py +++ b/lib/render_workers/ffmpeg_worker.py @@ -1,27 +1,9 @@ #!/usr/bin/env python3 import re -import time from .render_worker import * -class FFMPEGRenderWorker(BaseRenderWorker): - - renderer = 'ffmpeg' - render_engine = 'ffmpeg' - - def __init__(self, input_path, output_path, args=None): - super(FFMPEGRenderWorker, self).__init__(input_path=input_path, output_path=output_path, ignore_extensions=True, - args=args) - - 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.total_frames = found_frames[-1] if found_frames else '-1' - self.frame = 0 - - # Stats - self.current_frame = -1 +class FFMPEG(BaseRenderEngine): @classmethod def version(cls): @@ -35,18 +17,58 @@ class FFMPEGRenderWorker(BaseRenderWorker): logger.error("Failed to get FFMPEG version: {}".format(e)) return version + @classmethod + def get_encoders(cls): + encoders_raw = subprocess.check_output([cls.renderer_path(), '-encoders'], stderr=subprocess.DEVNULL).decode('utf-8') + pattern = '(?P[VASFXBD.]{6})\s+(?P\S{2,})\s+(?P.*)' + encoders = [m.groupdict() for m in re.finditer(pattern, encoders_raw)] + return encoders + + @classmethod + def get_formats(cls): + formats_raw = subprocess.check_output([cls.renderer_path(), '-formats'], stderr=subprocess.DEVNULL).decode('utf-8') + pattern = '(?P[DE]{1,2})\s+(?P\S{2,})\s+(?P.*)' + formats = [m.groupdict() for m in re.finditer(pattern, formats_raw)] + return formats + + @classmethod + def full_report(cls): + return {'version': cls.version(), + 'help_text': cls.get_help(), + 'encoders': cls.get_encoders(), + 'formats': cls.get_formats()} + + +class FFMPEGRenderWorker(BaseRenderWorker): + + engine = FFMPEG + + def __init__(self, input_path, output_path, args=None): + super(FFMPEGRenderWorker, self).__init__(input_path=input_path, output_path=output_path, ignore_extensions=True, + args=args) + + stream_info = subprocess.check_output([self.engine.renderer_path(), "-i", # https://stackoverflow.com/a/61604105 + input_path, "-map", "0:v:0", "-c", "copy", "-f", "null", "-y", + "/dev/null"], stderr=subprocess.DEVNULL).decode('utf-8') + found_frames = re.findall('frame=\s*(\d+)', stream_info) + self.total_frames = found_frames[-1] if found_frames else '-1' + self.frame = 0 + + # Stats + self.current_frame = -1 + def generate_worker_subprocess(self): - cmd = [self.renderer_path(), '-y', '-stats', '-i', self.input_path] + cmd = [self.engine.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.get_raw_args() + raw_args = self.args.get('raw', None) if raw_args: - cmd.extend(raw_args) + cmd.extend(raw_args.split(' ')) # Close with output path cmd.append(self.output_path) @@ -67,12 +89,15 @@ class FFMPEGRenderWorker(BaseRenderWorker): if __name__ == '__main__': - logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG) - test_movie = '/Users/brettwilliams/Desktop/dark_knight_rises.mp4' + print(FFMPEG.full_report()) - r = FFMPEGRenderWorker(test_movie, '/Users/brettwilliams/Desktop/test-ffmpeg.mp4', args=['-c:v', 'libx265', '-vtag', 'hvc1']) - # r = FFMPEGRenderer(test_movie, '/Users/brettwilliams/Desktop/dark_knight_rises-output.mp4') - r.start() - while r.is_running(): - time.sleep(1) + # logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG) + # + # test_movie = '/Users/brettwilliams/Desktop/dark_knight_rises.mp4' + # + # r = FFMPEGRenderWorker(test_movie, '/Users/brettwilliams/Desktop/test-ffmpeg.mp4', args=['-c:v', 'libx265', '-vtag', 'hvc1']) + # # r = FFMPEGRenderer(test_movie, '/Users/brettwilliams/Desktop/dark_knight_rises-output.mp4') + # r.start() + # while r.is_running(): + # time.sleep(1) From 49c138968d0719b9d6ca53326f9ad7f056107575 Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:10:14 -0500 Subject: [PATCH 4/8] render_queue refactoring --- lib/render_queue.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/render_queue.py b/lib/render_queue.py index 9be2757..d0bedc5 100755 --- a/lib/render_queue.py +++ b/lib/render_queue.py @@ -25,7 +25,7 @@ class JobNotFoundError(Exception): class RenderQueue: job_queue = [] render_clients = [] - maximum_renderer_instances = {'Blender': 2, 'After Effects': 1, 'ffmpeg': 4} + maximum_renderer_instances = {'blender': 2, 'aerender': 1, 'ffmpeg': 4} host_name = None port = 8080 client_mode = False @@ -153,7 +153,7 @@ class RenderQueue: not_started = cls.jobs_with_status(RenderStatus.NOT_STARTED, priority_sorted=True) if not_started: for job in not_started: - renderer = job.worker.renderer + renderer = job.worker.engine.name higher_priority_jobs = [x for x in cls.running_jobs() if x.priority < job.priority] max_renderers = renderer in instances.keys() and instances[ renderer] >= cls.maximum_renderer_instances.get(renderer, 1) @@ -191,7 +191,7 @@ class RenderQueue: @classmethod def renderer_instances(cls): from collections import Counter - all_instances = [x.worker.renderer for x in cls.running_jobs()] + all_instances = [x.worker.engine.name for x in cls.running_jobs()] return Counter(all_instances) @classmethod From 861df5f2159712306442e9d245a31b14ec36de58 Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:15:02 -0500 Subject: [PATCH 5/8] Fix issues with engine name --- lib/render_queue.py | 4 ++-- lib/render_workers/render_worker.py | 4 ++-- lib/server/job_server.py | 11 ++++++----- 3 files changed, 10 insertions(+), 9 deletions(-) diff --git a/lib/render_queue.py b/lib/render_queue.py index d0bedc5..b90ce87 100755 --- a/lib/render_queue.py +++ b/lib/render_queue.py @@ -153,7 +153,7 @@ class RenderQueue: not_started = cls.jobs_with_status(RenderStatus.NOT_STARTED, priority_sorted=True) if not_started: for job in not_started: - renderer = job.worker.engine.name + renderer = job.worker.engine.name() higher_priority_jobs = [x for x in cls.running_jobs() if x.priority < job.priority] max_renderers = renderer in instances.keys() and instances[ renderer] >= cls.maximum_renderer_instances.get(renderer, 1) @@ -191,7 +191,7 @@ class RenderQueue: @classmethod def renderer_instances(cls): from collections import Counter - all_instances = [x.worker.engine.name for x in cls.running_jobs()] + all_instances = [x.worker.engine.name() for x in cls.running_jobs()] return Counter(all_instances) @classmethod diff --git a/lib/render_workers/render_worker.py b/lib/render_workers/render_worker.py index 94ac298..f855ef8 100644 --- a/lib/render_workers/render_worker.py +++ b/lib/render_workers/render_worker.py @@ -36,7 +36,7 @@ class BaseRenderWorker(object): 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' + 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: @@ -116,7 +116,7 @@ class BaseRenderWorker(object): return self.status = RenderStatus.RUNNING - logger.info('Starting {0} {1} Render for {2}'.format(self.renderer, self.version(), self.input_path)) + logger.info(f'Starting {self.engine.name()} {self.engine.version()} Render for {self.input_path}') self.__thread.start() def run(self): diff --git a/lib/server/job_server.py b/lib/server/job_server.py index 44a22b5..79a75ec 100755 --- a/lib/server/job_server.py +++ b/lib/server/job_server.py @@ -427,11 +427,12 @@ def status(): def renderer_info(): renderer_data = {} for r in RenderWorkerFactory.supported_renderers(): - renderer_class = RenderWorkerFactory.class_for_name(r) - renderer_data[r] = {'available': renderer_class.renderer_path() is not None, - 'version': renderer_class.version(), - 'supported_extensions': renderer_class.supported_extensions, - 'supported_export_formats': renderer_class.supported_export_formats} + engine = RenderWorkerFactory.class_for_name(r).engine + renderer_data[r] = {'available': engine.renderer_path() is not None, + 'version': engine.version(), + 'supported_extensions': engine.supported_extensions, + 'supported_export_formats': engine.get_formats(), + 'path': engine.renderer_path()} return renderer_data From 69e557dfdb003c22586fb3733eb61b2b7f6ba537 Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:19:04 -0500 Subject: [PATCH 6/8] Consolidate Blender methods --- lib/render_workers/blender_worker.py | 51 ++++++++++++++-------------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/lib/render_workers/blender_worker.py b/lib/render_workers/blender_worker.py index bb5ff44..2cf8ade 100644 --- a/lib/render_workers/blender_worker.py +++ b/lib/render_workers/blender_worker.py @@ -33,6 +33,30 @@ class Blender(BaseRenderEngine): 'help_text': cls.get_help(), 'formats': cls.get_formats()} + @classmethod + def run_python_expression(cls, path, python_expression): + if os.path.exists(path): + try: + return subprocess.run([cls.renderer_path(), '-b', path, '--python-expr', python_expression], + capture_output=True) + except Exception as e: + logger.warning(f"Error running python expression in blender: {e}") + pass + else: + raise FileNotFoundError + + @classmethod + def run_python_script(cls, path, python_path): + if os.path.exists(path) and os.path.exists(python_path): + try: + return subprocess.run([cls.renderer_path(), '-b', path, '--python', python_path], + capture_output=True) + except Exception as e: + logger.warning(f"Error running python expression in blender: {e}") + pass + else: + raise FileNotFoundError + class BlenderRenderWorker(BaseRenderWorker): @@ -141,29 +165,6 @@ class BlenderRenderWorker(BaseRenderWorker): return max(total_percent, 0) -def run_python_expression_in_blend(path, python_expression): - if os.path.exists(path): - try: - return subprocess.run([Blender.renderer_path(), '-b', path, '--python-expr', python_expression], - capture_output=True) - except Exception as e: - logger.warning(f"Error running python expression in blender: {e}") - pass - else: - raise FileNotFoundError - - -def run_python_script_in_blend(path, python_path): - if os.path.exists(path) and os.path.exists(python_path): - try: - return subprocess.run([Blender.renderer_path(), '-b', path, '--python', python_path], capture_output=True) - except Exception as e: - logger.warning(f"Error running python expression in blender: {e}") - pass - else: - raise FileNotFoundError - - def pack_blender_files(path): # Credit to L0Lock for pack script - https://blender.stackexchange.com/a/243935 pack_script = "import bpy\n" \ @@ -173,7 +174,7 @@ def pack_blender_files(path): "bpy.ops.wm.save_as_mainfile(filepath=myPath[:-6]+'_packed'+myPath[-6:])" try: - results = run_python_expression_in_blend(path, pack_script) + results = Blender.run_python_script(path, pack_script) result_text = results.stdout.decode() dir_name = os.path.dirname(path) @@ -198,7 +199,7 @@ def get_scene_info(path): scene_info = None try: - results = run_python_script_in_blend(path, os.path.join(os.path.dirname(os.path.realpath(__file__)), + results = Blender.run_python_script(path, os.path.join(os.path.dirname(os.path.realpath(__file__)), 'scripts', 'get_blender_info.py')) result_text = results.stdout.decode() for line in result_text.splitlines(): From fbaefdd575b7289da97f528162ae185a1458348a Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:36:28 -0500 Subject: [PATCH 7/8] Fix Blender naming collision --- lib/render_workers/blender_worker.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/render_workers/blender_worker.py b/lib/render_workers/blender_worker.py index 2cf8ade..cb2c23c 100644 --- a/lib/render_workers/blender_worker.py +++ b/lib/render_workers/blender_worker.py @@ -67,7 +67,7 @@ class BlenderRenderWorker(BaseRenderWorker): ignore_extensions=False, args=args) # Args - self.engine = self.args.get('engine', 'BLENDER_EEVEE').upper() + 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) self.render_all_frames = self.args.get('render_all_frames', False) or \ @@ -93,7 +93,7 @@ class BlenderRenderWorker(BaseRenderWorker): if self.camera: cmd.extend(['--python-expr', f"import bpy;bpy.context.scene.camera = bpy.data.objects['{self.camera}'];"]) - cmd.extend(['-E', self.engine, '-o', self.output_path, '-F', self.export_format]) + cmd.extend(['-E', self.blender_engine, '-o', self.output_path, '-F', self.export_format]) # all frames or single cmd.extend(['-a'] if self.render_all_frames else ['-f', str(self.frame_to_render)]) From d9ebd0b2d9861bfd472667dc41e90c55a714f3e9 Mon Sep 17 00:00:00 2001 From: Brett Williams Date: Mon, 22 May 2023 19:41:38 -0500 Subject: [PATCH 8/8] Rename RenderJob to ScheduledJob --- lib/render_queue.py | 8 ++++---- lib/{render_job.py => scheduled_job.py} | 2 +- lib/server/job_server.py | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) rename lib/{render_job.py => scheduled_job.py} (99%) diff --git a/lib/render_queue.py b/lib/render_queue.py index b90ce87..a3a56ad 100755 --- a/lib/render_queue.py +++ b/lib/render_queue.py @@ -7,7 +7,7 @@ from datetime import datetime import psutil import requests -from .render_job import RenderJob +from .scheduled_job import ScheduledJob from .render_workers.render_worker import RenderStatus logger = logging.getLogger() @@ -95,9 +95,9 @@ class RenderQueue: for job in saved_state.get('jobs', []): try: - render_job = RenderJob(renderer=job['renderer'], input_path=job['worker']['input_path'], - output_path=job['worker']['output_path'], args=job['worker']['args'], - priority=job['priority'], client=job['client']) + render_job = ScheduledJob(renderer=job['renderer'], input_path=job['worker']['input_path'], + output_path=job['worker']['output_path'], args=job['worker']['args'], + priority=job['priority'], client=job['client']) # Load Worker values for key, val in job['worker'].items(): diff --git a/lib/render_job.py b/lib/scheduled_job.py similarity index 99% rename from lib/render_job.py rename to lib/scheduled_job.py index 3da21de..42171c5 100644 --- a/lib/render_job.py +++ b/lib/scheduled_job.py @@ -12,7 +12,7 @@ from .render_workers.render_worker import RenderStatus, RenderWorkerFactory logger = logging.getLogger() -class RenderJob: +class ScheduledJob: # Get file hash on bg thread def __get_file_hash(self): diff --git a/lib/server/job_server.py b/lib/server/job_server.py index 79a75ec..6c14045 100755 --- a/lib/server/job_server.py +++ b/lib/server/job_server.py @@ -16,7 +16,7 @@ import yaml from flask import Flask, request, render_template, send_file, after_this_request, Response, redirect, url_for, abort from werkzeug.utils import secure_filename -from lib.render_job import RenderJob +from lib.scheduled_job import ScheduledJob from lib.render_queue import RenderQueue, JobNotFoundError from lib.render_workers.render_worker import RenderWorkerFactory, string_to_status, RenderStatus from lib.utilities.server_helper import post_job_to_server, generate_thumbnail_for_job @@ -309,8 +309,8 @@ def add_job(job_params, remove_job_dir_on_failure=False): if client == RenderQueue.host_name: logger.info(f"Creating job locally - {name if name else input_path}") try: - render_job = RenderJob(renderer, input_path, output_path, args, priority, job_owner, client, - notify=False, custom_id=custom_id, name=name) + render_job = ScheduledJob(renderer, input_path, output_path, args, priority, job_owner, client, + notify=False, custom_id=custom_id, name=name) RenderQueue.add_to_render_queue(render_job, force_start=force_start) return render_job.json() except Exception as e: