brett/Zordon
1
0
Fork 0
mirror of https://github.com/blw1138/Zordon.git synced 2025-12-17 16:58:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Engine and downloader refactoring (#50)

Browse Source 
* Make downloaders subclass of base_downloader.py

* Link engines and downloaders together for all engines

* Replace / merge worker_factory.py with engine_manager.py
This commit is contained in:
Brett
2023-10-29 20:57:26 -05:00
committed by GitHub
parent 22aaa82da7
commit dcc0504d3c
11 changed files with 328 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
src/engines/engine_manager.py
View File

@@ -3,9 +3,7 @@ import os
import shutil
import threading
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, current_system_os, current_system_cpu
@@ -14,21 +12,26 @@ logger = logging.getLogger()
class EngineManager:
engines_path = "~/zordon-uploads/engines"
downloader_classes = {
"blender": BlenderDownloader,
"ffmpeg": FFMPEGDownloader,
# Add more engine types and corresponding downloader classes as needed
}
engines_path = None
@classmethod
def supported_engines(cls):
@staticmethod
def supported_engines():
return [Blender, FFMPEG]
@classmethod
def engine_with_name(cls, engine_name):
for obj in cls.supported_engines():
if obj.name().lower() == engine_name.lower():
return obj
@classmethod
def all_engines(cls):
results = []
if not cls.engines_path:
raise FileNotFoundError("Engines path must be set before requesting downloads")
# Parse downloaded engine directory
results = []
try:
all_items = os.listdir(cls.engines_path)
all_directories = [item for item in all_items if os.path.isdir(os.path.join(cls.engines_path, item))]
@@ -57,8 +60,8 @@ class EngineManager:
result_dict['path'] = path
results.append(result_dict)
except FileNotFoundError:
logger.warning("Cannot find local engines download directory")
except FileNotFoundError as e:
logger.warning(f"Cannot find local engines download directory: {e}")
# add system installs to this list
for eng in cls.supported_engines():
@@ -99,15 +102,16 @@ class EngineManager:
@classmethod
def version_is_available_to_download(cls, engine, version, system_os=None, cpu=None):
try:
return cls.downloader_classes[engine].version_is_available_to_download(version=version, system_os=system_os,
cpu=cpu)
downloader = cls.engine_with_name(engine).downloader()
return downloader.version_is_available_to_download(version=version, system_os=system_os, cpu=cpu)
except Exception as e:
return None
@classmethod
def find_most_recent_version(cls, engine=None, system_os=None, cpu=None, lts_only=False):
try:
return cls.downloader_classes[engine].find_most_recent_version(system_os=system_os, cpu=cpu)
downloader = cls.engine_with_name(engine).downloader()
return downloader.find_most_recent_version(system_os=system_os, cpu=cpu)
except Exception as e:
return None
@@ -119,13 +123,19 @@ class EngineManager:
return existing_download
# Check if the provided engine type is valid
if engine not in cls.downloader_classes:
engine_to_download = cls.engine_with_name(engine)
if not engine_to_download:
logger.error("No valid engine found")
return
elif not engine_to_download.downloader():
logger.warning("No valid downloader for this engine. Please update this software manually.")
return
elif not cls.engines_path:
raise FileNotFoundError("Engines path must be set before requesting downloads")
# Get the appropriate downloader class based on the engine type
cls.downloader_classes[engine].download_engine(version, download_location=cls.engines_path,
system_os=system_os, cpu=cpu, timeout=300)
engine_to_download.downloader().download_engine(version, download_location=cls.engines_path,
system_os=system_os, cpu=cpu, timeout=300)
# Check that engine was properly downloaded
found_engine = cls.is_version_downloaded(engine, version, system_os, cpu)
@@ -148,30 +158,66 @@ class EngineManager:
@classmethod
def update_all_engines(cls):
def engine_update_task(engine, engine_downloader):
logger.debug(f"Checking for updates to {engine}")
latest_version = engine_downloader.find_most_recent_version()
def engine_update_task(engine):
logger.debug(f"Checking for updates to {engine.name()}")
latest_version = engine.downloader().find_most_recent_version()
if latest_version:
logger.debug(f"Latest version of {engine} available: {latest_version.get('version')}")
logger.debug(f"Latest version of {engine.name()} available: {latest_version.get('version')}")
if not cls.is_version_downloaded(engine, latest_version.get('version')):
logger.info(f"Downloading {engine} ({latest_version['version']})")
cls.download_engine(engine=engine, version=latest_version['version'])
logger.info(f"Downloading {engine.name()} ({latest_version['version']})")
cls.download_engine(engine=engine.name(), version=latest_version['version'])
else:
logger.warning(f"Unable to get latest version for {engine}")
logger.warning(f"Unable to get check for updates for {engine.name()}")
logger.info(f"Checking for updates for render engines...")
threads = []
for engine, engine_downloader in cls.downloader_classes.items():
thread = threading.Thread(target=engine_update_task, args=(engine, engine_downloader))
threads.append(thread)
thread.start()
for engine in cls.supported_engines():
if engine.downloader():
thread = threading.Thread(target=engine_update_task, args=(engine,))
threads.append(thread)
thread.start()
for thread in threads: # wait to finish
thread.join()
@classmethod
def create_worker(cls, renderer, input_path, output_path, engine_version=None, args=None, parent=None, name=None):
worker_class = cls.engine_with_name(renderer).worker_class()
# check to make sure we have versions installed
all_versions = EngineManager.all_versions_for_engine(renderer)
if not all_versions:
raise FileNotFoundError(f"Cannot find any installed {renderer} engines")
# Find the path to the requested engine version or use default
engine_path = None if engine_version else all_versions[0]['path']
if engine_version:
for ver in all_versions:
if ver['version'] == engine_version:
engine_path = ver['path']
break
# Download the required engine if not found locally
if not engine_path:
download_result = EngineManager.download_engine(renderer, engine_version)
if not download_result:
raise FileNotFoundError(f"Cannot download requested version: {renderer} {engine_version}")
engine_path = download_result['path']
logger.info("Engine downloaded. Creating worker.")
if not engine_path:
raise FileNotFoundError(f"Cannot find requested engine version {engine_version}")
return worker_class(input_path=input_path, output_path=output_path, engine_path=engine_path, args=args,
parent=parent, name=name)
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# print(EngineManager.newest_engine_version('blender', 'macos', 'arm64'))
EngineManager.delete_engine_download('blender', '3.2.1', 'macos', 'a')
# 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())