Misc cleanup / renaming

requirements.txt

@@ -19,7 +19,7 @@ setuptools>=69.0.3
 pandas>=2.2.0
 matplotlib>=3.8.2
 MarkupSafe>=2.1.4
-dmglib>=0.9.5
+dmglib>=0.9.5; sys_platform == 'darwin'
 python-dateutil>=2.8.2
 certifi>=2023.11.17
 shiboken6>=6.6.1

src/api/api_server.py

@@ -507,7 +507,7 @@ def start_server():
     flask_log.setLevel(Config.flask_log_level.upper())
 
     # check for updates for render engines if configured or on first launch
-    if Config.update_engines_on_launch or not EngineManager.all_engines():
+    if Config.update_engines_on_launch or not EngineManager.get_engines():
         EngineManager.update_all_engines()
 
     # Set up the RenderQueue object

src/distributed_job_manager.py

@@ -127,10 +127,10 @@ class DistributedJobManager:
                                              input_path=loaded_project_local_path,
                                              output_path=output_path,
                                              engine_version=job_data.get('engine_version'),
-                                             args=job_data.get('args', {}))
+                                             args=job_data.get('args', {}),
+                                             parent=job_data.get('parent'),
+                                             name=job_data.get('name'))
         worker.status = job_data.get("initial_status", worker.status)  # todo: is this necessary?
-        worker.parent = job_data.get("parent", worker.parent)
-        worker.name = job_data.get("name", worker.name)
         worker.priority = int(job_data.get('priority', worker.priority))
         worker.start_frame = int(job_data.get("start_frame", worker.start_frame))
         worker.end_frame = int(job_data.get("end_frame", worker.end_frame))
@@ -315,17 +315,16 @@ class DistributedJobManager:
         parent_worker.status = RenderStatus.CONFIGURING
         available_servers = specific_servers if specific_servers else cls.find_available_servers(parent_worker.renderer, system_os)
         logger.debug(f"Splitting into subjobs - Available servers: {available_servers}")
-        subjob_servers = cls.distribute_server_work(parent_worker.start_frame, parent_worker.end_frame, available_servers)
+        all_subjob_server_data = cls.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: {subjob_servers}")
+        logger.info(f"Job {parent_worker.id} split plan: {all_subjob_server_data}")
         try:
-            for subjob_data in subjob_servers:
+            for subjob_data in all_subjob_server_data:
                 subjob_hostname = subjob_data['hostname']
                 if subjob_hostname != parent_worker.hostname:
-                    post_results = cls.__create_subjob(job_data, parent_worker.hostname, project_path, subjob_data,
+                    post_results = cls.__create_subjob(job_data, project_path, subjob_data, subjob_hostname,
-                                                       subjob_hostname, parent_worker)
+                                                       parent_worker)
                     if not post_results.ok:
                         ValueError(f"Failed to create subjob on {subjob_hostname}")
 
@@ -340,22 +339,23 @@ class DistributedJobManager:
                     logger.info(f"Local job now rendering from {parent_worker.start_frame} to {parent_worker.end_frame}")
 
             # start subjobs
-            logger.debug(f"Created {len(subjob_servers) - 1} subjobs successfully")
+            logger.debug(f"Created {len(all_subjob_server_data) - 1} subjobs successfully")
             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
             logger.error(f"Failed to split job into subjobs: {e}")
-            logger.debug(f"Cancelling {len(subjob_servers) - 1} attempted subjobs")
+            logger.debug(f"Cancelling {len(all_subjob_server_data) - 1} attempted subjobs")
             RenderServerProxy(parent_worker.hostname).cancel_job(parent_worker.id, confirm=True)
 
     @staticmethod
-    def __create_subjob(job_data, local_hostname, project_path, server_data, server_hostname, worker):
+    def __create_subjob(job_data, project_path, server_data, server_hostname, parent_worker):
         subjob = job_data.copy()
-        subjob['name'] = f"{worker.name}[{server_data['frame_range'][0]}-{server_data['frame_range'][-1]}]"
+        subjob['name'] = f"{parent_worker.name}[{server_data['frame_range'][0]}-{server_data['frame_range'][-1]}]"
-        subjob['parent'] = f"{worker.id}@{local_hostname}"
+        subjob['parent'] = f"{parent_worker.id}@{parent_worker.hostname}"
         subjob['start_frame'] = server_data['frame_range'][0]
         subjob['end_frame'] = server_data['frame_range'][-1]
+        subjob['engine_version'] = parent_worker.renderer_version
         logger.debug(f"Posting subjob with frames {subjob['start_frame']}-"
                      f"{subjob['end_frame']} to {server_hostname}")
         post_results = RenderServerProxy(server_hostname).post_job_to_server(
@@ -515,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 = DistributedJobManager.distribute_server_work(1, 100, available_servers)
+    # results = DistributedJobManager.distribute_server_work(1, 100, available_servers)
-    print(f"RESULTS: {results}")
+    # print(f"RESULTS: {results}")
     ZeroconfServer.stop()

src/engines/engine_manager.py

@@ -95,7 +95,7 @@ class EngineManager:
 
     @classmethod
     def all_versions_for_engine(cls, engine_name):
-        versions = cls.all_engines(filter_name=engine_name)
+        versions = cls.get_engines(filter_name=engine_name)
         sorted_versions = sorted(versions, key=lambda x: x['version'], reverse=True)
         return sorted_versions
 
@@ -117,9 +117,8 @@ class EngineManager:
         system_os = system_os or current_system_os()
         cpu = cpu or current_system_cpu()
 
-        filtered = [x for x in cls.all_engines() if
+        filtered = [x for x in cls.get_engines(filter_name=engine) if x['system_os'] == system_os and
-                    x['engine'] == engine and x['system_os'] == system_os and x['cpu'] == cpu and
+                    x['cpu'] == cpu and x['version'] == version]
-                    x['version'] == version]
         return filtered[0] if filtered else False
 
     @classmethod
@@ -297,4 +296,4 @@ if __name__ == '__main__':
     # EngineManager.delete_engine_download('blender', '3.2.1', 'macos', 'a')
     EngineManager.engines_path = "/Users/brettwilliams/zordon-uploads/engines"
     # print(EngineManager.is_version_downloaded("ffmpeg", "6.0"))
-    print(EngineManager.all_engines())
+    print(EngineManager.get_engines())