Consolidate engine_info api calls

src/api/api_server.py

@@ -389,83 +389,38 @@ def get_installed_engines():
     return result
 
 
-@server.get('/api/engine_info')
+def _validated_engine_response_type():
-def engine_info():
     response_type = request.args.get('response_type', 'standard')
     if response_type not in ['full', 'standard']:
         raise ValueError(f"Invalid response_type: {response_type}")
-
+    return response_type
-    def process_engine(engine):
-        try:
-            # Get all installed versions of the engine
-            installed_versions = EngineManager.all_version_data_for_engine(engine.name())
-            if not installed_versions:
-                return None
-
-            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 installed_versions[0]['path']
-
-            en = engine(install_path)
-            engine_name = en.name()
-            result = {
-                engine_name: {
-                    'is_available': RenderQueue.is_available_for_job(engine_name),
-                    'versions': installed_versions
-                }
-            }
-
-            if response_type == 'full':
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future_results = {
-                        'supported_extensions': executor.submit(en.supported_extensions),
-                        'supported_export_formats': executor.submit(en.get_output_formats),
-                        'system_info': executor.submit(en.system_info)
-                    }
-
-                    for key, future in future_results.items():
-                        result[engine_name][key] = future.result()
-
-            return result
-
-        except Exception as e:
-            traceback.print_exc(e)
-            logger.error(f"Error fetching details for engine '{engine.name()}': {e}")
-            return {}
-
-    engine_data = {}
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        futures = {executor.submit(process_engine, engine): engine.name() for engine in EngineManager.supported_engines()}
-
-        for future in concurrent.futures.as_completed(futures):
-            result = future.result()
-            if result:
-                engine_data.update(result)
-
-    return engine_data
 
 
-@server.get('/api/<engine_name>/info')
+def _engine_info_for_engine(engine_class, response_type='standard'):
-def get_engine_info(engine_name):
     try:
-        response_type = request.args.get('response_type', 'standard')
+        installed_versions = EngineManager.all_version_data_for_engine(engine_class.name())
-        # Get all installed versions of the engine
-        installed_versions = EngineManager.all_version_data_for_engine(engine_name)
         if not installed_versions:
-            return {}
+            return None
 
-        result = { 'is_available': RenderQueue.is_available_for_job(engine_name),
+        system_installed_versions = [v for v in installed_versions if v['type'] == 'system']
-                   'versions': installed_versions
+        install_path = (
-                   }
+            system_installed_versions[0]['path'] if system_installed_versions else installed_versions[0]['path']
+        )
+
+        engine = engine_class(install_path)
+        engine_name = engine.name()
+        result = {
+            'is_available': RenderQueue.is_available_for_job(engine_name),
+            'versions': installed_versions
+        }
 
         if response_type == 'full':
             with concurrent.futures.ThreadPoolExecutor() as executor:
-                engine_class = EngineManager.engine_class_with_name(engine_name)
-                en = EngineManager.get_latest_engine_instance(engine_class)
                 future_results = {
-                    'supported_extensions': executor.submit(en.supported_extensions),
+                    'supported_extensions': executor.submit(engine.supported_extensions),
-                    'supported_export_formats': executor.submit(en.get_output_formats),
+                    'supported_export_formats': executor.submit(engine.get_output_formats),
-                    'system_info': executor.submit(en.system_info),
+                    'system_info': executor.submit(engine.system_info),
-                    'options': executor.submit(en.ui_options)
+                    'options': executor.submit(engine.ui_options)
                 }
 
                 for key, future in future_results.items():
@@ -473,6 +428,35 @@ def get_engine_info(engine_name):
 
         return result
 
+    except Exception as e:
+        logger.error(f"Error fetching details for engine '{engine_class.name()}': {e}")
+        return {}
+
+
+@server.get('/api/engines')
+def get_engines_info():
+    response_type = _validated_engine_response_type()
+    engine_data = {}
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = {
+            executor.submit(_engine_info_for_engine, engine, response_type): engine.name()
+            for engine in EngineManager.supported_engines()
+        }
+        for future in concurrent.futures.as_completed(futures):
+            result = future.result()
+            if result:
+                engine_data[futures[future]] = result
+
+    return engine_data
+
+
+@server.get('/api/engines/<engine_name>')
+def get_engine_info(engine_name):
+    try:
+        response_type = _validated_engine_response_type()
+        engine_class = EngineManager.engine_class_with_name(engine_name)
+        return _engine_info_for_engine(engine_class, response_type) or {}
+
     except Exception as e:
         logger.error(f"Error fetching details for engine '{engine_name}': {e}")
         return {}

src/api/server_proxy.py

@@ -269,7 +269,7 @@ class RenderServerProxy:
         Returns:
             dict: A dictionary containing the engine information.
         """
-        all_data = self.request_data(f"engine_info?response_type={response_type}", timeout=timeout)
+        all_data = self.request_data(f'engines?response_type={response_type}', timeout=timeout)
         return all_data
 
     def get_engine_info(self, engine_name:str, response_type='standard', timeout=5):
@@ -284,7 +284,7 @@ class RenderServerProxy:
         Returns:
             dict: A dictionary containing the engine information.
         """
-        return self.request_data(f'{engine_name}/info?response_type={response_type}', timeout)
+        return self.request_data(f'engines/{engine_name}?response_type={response_type}', timeout)
 
     def delete_engine(self, engine_name:str, version:str, system_cpu=None):
         """