Move to different program structure

bulkredditdownloader/site_downloaders/imgur.py

@@ -1,16 +1,15 @@
 #!/usr/bin/env python3
 
 import json
-import pathlib
 import logging
+import pathlib
 
 import requests
+from praw.models import Submission
 
+from bulkredditdownloader.errors import ExtensionError, ImageNotFound, NotADownloadableLinkError
 from bulkredditdownloader.site_downloaders.base_downloader import BaseDownloader
 from bulkredditdownloader.site_downloaders.direct import Direct
-from bulkredditdownloader.errors import (AlbumNotDownloadedCompletely, ExtensionError, FileAlreadyExistsError,
-                                         ImageNotFound, NotADownloadableLinkError, TypeInSkip)
-from bulkredditdownloader.utils import GLOBAL, nameCorrector
 
 logger = logging.getLogger(__name__)
 
@@ -19,85 +18,43 @@ class Imgur(BaseDownloader):
 
     imgur_image_domain = "https://i.imgur.com/"
 
-    def __init__(self, directory: pathlib.Path, post: dict):
+    def __init__(self, directory: pathlib.Path, post: Submission):
         super().__init__(directory, post)
         self.raw_data = {}
-        self.download()
 
     def download(self):
-        link = self.post['CONTENTURL']
+        link = self.post.url
 
         if link.endswith(".gifv"):
-            link = link.replace(".gifv", ".mp4")
-            Direct(self.directory, {**self.post, 'CONTENTURL': link})
-            return
+            direct_thing = Direct(self.directory, self.post)
+            return direct_thing.download()
 
         self.raw_data = self._get_data(link)
 
         if self._is_album:
             if self.raw_data["album_images"]["count"] != 1:
-                self._download_album(self.raw_data["album_images"])
+                out = self._download_album(self.raw_data["album_images"])
             else:
-                self._download_image(self.raw_data["album_images"]["images"][0])
+                out = self._download_image(self.raw_data["album_images"]["images"][0])
         else:
-            self._download_image(self.raw_data)
+            out = self._download_image(self.raw_data)
+        return out
 
     def _download_album(self, images: dict):
-        folder_name = GLOBAL.config['filename'].format(**self.post)
-        folder_dir = self.directory / folder_name
-
         images_length = images["count"]
-        how_many_downloaded = 0
-        duplicates = 0
 
-        folder_dir.mkdir(exist_ok=True)
-        logger.info(folder_name)
+        out = []
 
         for i in range(images_length):
             extension = self._validate_extension(images["images"][i]["ext"])
             image_url = self.imgur_image_domain + images["images"][i]["hash"] + extension
-            filename = pathlib.Path("_".join([str(i + 1),
-                                              nameCorrector(images["images"][i]['title']),
-                                              images["images"][i]['hash']]) + extension)
-
-            logger.info("\n  ({}/{})".format(i + 1, images_length))
-
-            try:
-                self._download_resource(filename, folder_dir, image_url, indent=2)
-                how_many_downloaded += 1
-
-            except FileAlreadyExistsError:
-                logger.info("  The file already exists" + " " * 10, end="\n\n")
-                duplicates += 1
-
-            except TypeInSkip:
-                logger.info("  Skipping...")
-                how_many_downloaded += 1
-
-            except Exception as exception:
-                logger.info("\n  Could not get the file")
-                logger.info(
-                    "  "
-                    + "{class_name}: {info}\nSee CONSOLE_LOG.txt for more information".format(
-                        class_name=exception.__class__.__name__,
-                        info=str(exception)
-                    )
-                    + "\n"
-                )
-                logger.info(GLOBAL.log_stream.getvalue(), no_print=True)
-
-        if duplicates == images_length:
-            raise FileAlreadyExistsError
-        elif how_many_downloaded + duplicates < images_length:
-            raise AlbumNotDownloadedCompletely("Album Not Downloaded Completely")
+            out.append(self._download_resource(image_url))
+        return out
 
     def _download_image(self, image: dict):
         extension = self._validate_extension(image["ext"])
         image_url = self.imgur_image_domain + image["hash"] + extension
-
-        filename = GLOBAL.config['filename'].format(**self.post) + extension
-
-        self._download_resource(filename, self.directory, image_url)
+        return [self._download_resource(image_url)]
 
     def _is_album(self) -> bool:
         return "album_images" in self.raw_data
@@ -134,9 +91,8 @@ class Imgur(BaseDownloader):
     @staticmethod
     def _validate_extension(extension_suffix: str) -> str:
         possible_extensions = [".jpg", ".png", ".mp4", ".gif"]
-
         for extension in possible_extensions:
             if extension in extension_suffix:
                 return extension
         else:
-            raise ExtensionError(f"\"{extension_suffix}\" is not recognized as a valid extension.")
+            raise ExtensionError(f'"{extension_suffix}" is not recognized as a valid extension for Imgur')