Engine and downloader refactoring (#50)

* Make downloaders subclass of base_downloader.py

* Link engines and downloaders together for all engines

* Replace / merge worker_factory.py with engine_manager.py

src/engines/blender/blender_downloader.py

@@ -3,7 +3,8 @@ import re
 
 import requests
 
-from src.engines.core.downloader_core import download_and_extract_app
+from src.engines.blender.blender_engine import Blender
+from src.engines.core.base_downloader import EngineDownloader
 from src.utilities.misc_helper import current_system_os, current_system_cpu
 
 # url = "https://download.blender.org/release/"
@@ -13,10 +14,12 @@ logger = logging.getLogger()
 supported_formats = ['.zip', '.tar.xz', '.dmg']
 
 
-class BlenderDownloader:
+class BlenderDownloader(EngineDownloader):
+
+    engine = Blender
 
     @staticmethod
-    def get_major_versions():
+    def __get_major_versions():
         try:
             response = requests.get(url, timeout=5)
             response.raise_for_status()
@@ -30,10 +33,10 @@ class BlenderDownloader:
             return major_versions
         except requests.exceptions.RequestException as e:
             logger.error(f"Error: {e}")
-        return None
+        return []
 
     @staticmethod
-    def get_minor_versions(major_version, system_os=None, cpu=None):
+    def __get_minor_versions(major_version, system_os=None, cpu=None):
 
         try:
             base_url = url + 'Blender' + major_version
@@ -63,17 +66,8 @@ class BlenderDownloader:
             logger.exception(e)
         return []
 
-    @classmethod
-    def version_is_available_to_download(cls, version, system_os=None, cpu=None):
-        requested_major_version = '.'.join(version.split('.')[:2])
-        minor_versions = cls.get_minor_versions(requested_major_version, system_os, cpu)
-        for minor in minor_versions:
-            if minor['version'] == version:
-                return minor
-        return None
-
     @staticmethod
-    def find_LTS_versions():
+    def __find_LTS_versions():
         response = requests.get('https://www.blender.org/download/lts/')
         response.raise_for_status()
 
@@ -87,11 +81,21 @@ class BlenderDownloader:
     @classmethod
     def find_most_recent_version(cls, system_os=None, cpu=None, lts_only=False):
         try:
-            major_version = cls.find_LTS_versions()[0] if lts_only else cls.get_major_versions()[0]
-            most_recent = cls.get_minor_versions(major_version=major_version, system_os=system_os, cpu=cpu)
+            major_version = cls.__find_LTS_versions()[0] if lts_only else cls.__get_major_versions()[0]
+            most_recent = cls.__get_minor_versions(major_version=major_version, system_os=system_os, cpu=cpu)
             return most_recent[0]
-        except IndexError:
-            logger.error("Cannot find a most recent version")
+        except (IndexError, requests.exceptions.RequestException):
+            logger.error(f"Cannot get most recent version of blender")
+        return {}
+
+    @classmethod
+    def version_is_available_to_download(cls, version, system_os=None, cpu=None):
+        requested_major_version = '.'.join(version.split('.')[:2])
+        minor_versions = cls.__get_minor_versions(requested_major_version, system_os, cpu)
+        for minor in minor_versions:
+            if minor['version'] == version:
+                return minor
+        return None
 
     @classmethod
     def download_engine(cls, version, download_location, system_os=None, cpu=None, timeout=120):
@@ -101,11 +105,11 @@ class BlenderDownloader:
         try:
             logger.info(f"Requesting download of blender-{version}-{system_os}-{cpu}")
             major_version = '.'.join(version.split('.')[:2])
-            minor_versions = [x for x in cls.get_minor_versions(major_version, system_os, cpu) if x['version'] == version]
+            minor_versions = [x for x in cls.__get_minor_versions(major_version, system_os, cpu) if x['version'] == version]
             # we get the URL instead of calculating it ourselves. May change this
 
-            download_and_extract_app(remote_url=minor_versions[0]['url'], download_location=download_location,
-                                     timeout=timeout)
+            cls.__download_and_extract_app(remote_url=minor_versions[0]['url'], download_location=download_location,
+                                           timeout=timeout)
         except IndexError:
             logger.error("Cannot find requested engine")
 
@@ -113,5 +117,5 @@ class BlenderDownloader:
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
-    print(BlenderDownloader.get_major_versions())
+    print(BlenderDownloader.__get_major_versions())