Re implement upload progress after rebase

Signed-off-by: lzzy12 <[email protected]>

Author: lzzy12

bot/__init__.py

@@ -3,7 +3,6 @@
 import threading
 import os
 from dotenv import load_dotenv
-from telegram import Bot
 import telegram.ext as tg
 import time
 
@@ -20,6 +19,7 @@
 
 Interval = []
 
+
 def getConfig(name: str):
     return os.environ[name]
 
@@ -41,7 +41,6 @@ def getConfig(name: str):
     )
 )
 
-
 DOWNLOAD_DIR = None
 BOT_TOKEN = None
 
@@ -74,8 +73,6 @@ def getConfig(name: str):
     LOGGER.error("One or more env variables missing! Exiting now")
     exit(1)
 
-bot = Bot(BOT_TOKEN)
 updater = tg.Updater(token=BOT_TOKEN)
+bot = updater.bot
 dispatcher = updater.dispatcher
-
-

bot/helper/ext_utils/bot_utils.py

@@ -3,14 +3,14 @@
 import re
 import threading
 import time
-import math
 
 LOGGER = logging.getLogger(__name__)
 
 MAGNET_REGEX = r"magnet:\?xt=urn:btih:[a-zA-Z0-9]*"
 
 URL_REGEX = r"(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-?=%.]+"
 
+
 class MirrorStatus:
     STATUS_UPLOADING = "Uploading"
     STATUS_DOWNLOADING = "Downloading"
@@ -25,23 +25,25 @@ class MirrorStatus:
 
 SIZE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
 
-class setInterval :
-    def __init__(self,interval,action) :
-        self.interval=interval
-        self.action=action
-        self.stopEvent=threading.Event()
-        thread=threading.Thread(target=self.__setInterval)
+
+class setInterval:
+    def __init__(self, interval, action):
+        self.interval = interval
+        self.action = action
+        self.stopEvent = threading.Event()
+        thread = threading.Thread(target=self.__setInterval)
         thread.start()
 
-    def __setInterval(self) :
-        nextTime=time.time()+self.interval
-        while not self.stopEvent.wait(nextTime-time.time()) :
-            nextTime+=self.interval
+    def __setInterval(self):
+        nextTime = time.time() + self.interval
+        while not self.stopEvent.wait(nextTime - time.time()):
+            nextTime += self.interval
             self.action()
 
-    def cancel(self) :
+    def cancel(self):
         self.stopEvent.set()
 
+
 def get_readable_file_size(size_in_bytes) -> str:
     index = 0
     while size_in_bytes >= 1024:
@@ -65,10 +67,10 @@ def get_download_status_list():
 
 def get_progress_bar_string(status):
     if status.status() == MirrorStatus.STATUS_UPLOADING:
-        completed = status.upload_helper.uploaded_bytes / 8
+        completed = status.obj.uploaded_bytes / 8
     else:
         completed = status.download().completed_length / 8
-    total = status.download().total_length / 8
+    total = status.size_raw() / 8
     if total == 0:
         p = 0
     else:
@@ -99,6 +101,7 @@ def get_download_str():
             result += (status.progress() + status.speed() + status.status())
         return result
 
+
 def get_readable_message():
     with download_dict_lock:
         msg = ""
@@ -110,11 +113,15 @@ def get_readable_message():
                 msg += "Archiving\n\n"
             elif download.status() == MirrorStatus.STATUS_WAITING:
                 msg += "Queued\n\n"
-            else:
-                msg += f"<code>{get_progress_bar_string(download)} {download.progress()}</code> of {get_readable_file_size(download.download().total_length)}" \
-                       f" at {get_readable_file_size(download.download().download_speed)}ps, ETA: {download.eta()}\n\n"
+            elif download.status() == MirrorStatus.STATUS_DOWNLOADING:
+                msg += "Downloading"
+            if download.status() != MirrorStatus.STATUS_ARCHIVING:
+                msg += f"<code>{get_progress_bar_string(download)} {download.progress()}</code> of " \
+                    f"{download.size()}" \
+                    f" at {download.speed()}ps, ETA: {download.eta()}\n\n"
         return msg
 
+
 def get_readable_time(seconds: int) -> str:
     result = ''
     (days, remainder) = divmod(seconds, 86400)
@@ -135,14 +142,14 @@ def get_readable_time(seconds: int) -> str:
 
 
 def is_url(url: str):
-    url = re.findall(URL_REGEX,url)
+    url = re.findall(URL_REGEX, url)
     if url:
         return True
-    return False    
+    return False
 
 
 def is_magnet(url: str):
-    magnet = re.findall(MAGNET_REGEX,url)
+    magnet = re.findall(MAGNET_REGEX, url)
     if magnet:
         return True
     return False

bot/helper/ext_utils/fs_utils.py

@@ -5,6 +5,7 @@
 import pathlib
 import mimetypes
 
+
 def clean_download(path: str):
     if os.path.exists(path):
         LOGGER.info(f"Cleaning download: {path}")
@@ -41,4 +42,3 @@ def get_mime_type(file_path):
     mime_type = mimetypes.guess_type(file_path)[0]
     mime_type = mime_type if mime_type else "text/plain"
     return mime_type
-

bot/helper/mirror_utils/download_utils/__init__.py

@@ -1,11 +1,12 @@
-from bot import DOWNLOAD_STATUS_UPDATE_INTERVAL, aria2, Interval
+from bot import aria2
 from bot.helper.ext_utils.bot_utils import *
 from .download_helper import DownloadHelper
-from .download_status import DownloadStatus
+from bot.helper.mirror_utils.status_utils.aria_download_status import AriaDownloadStatus
 from bot.helper.telegram_helper.message_utils import *
 import threading
 from aria2p import API
 
+
 class AriaDownloadHelper(DownloadHelper):
 
     def __init__(self, listener):
@@ -26,11 +27,11 @@ def __onDownloadComplete(self, api: API, gid):
             if self.gid == gid:
                 if api.get_download(gid).followed_by_ids:
                     self.gid = api.get_download(gid).followed_by_ids[0]
-                    download_dict[self._listener.uid] = DownloadStatus(self.gid,self._listener)                 
+                    download_dict[self._listener.uid] = AriaDownloadStatus(self.gid, self._listener)
                     update_all_messages()
                     LOGGER.info(f'Changed gid from {gid} to {self.gid}')
                 else:
-                    self._listener.onDownloadComplete() 
+                    self._listener.onDownloadComplete()
 
     def __onDownloadPause(self, api, gid):
         if self.gid == gid:
@@ -56,14 +57,13 @@ def add_download(self, link: str, path):
             download = aria2.add_uris([link], {'dir': path})
         self.gid = download.gid
         with download_dict_lock:
-            download_dict[self._listener.uid] = DownloadStatus(self.gid,self._listener)
+            download_dict[self._listener.uid] = AriaDownloadStatus(self.gid, self._listener)
         if download.error_message:
             self._listener.onDownloadError(download.error_message)
-            return 
+            return
         LOGGER.info(f"Started: {self.gid} DIR:{download.dir} ")
         aria2.listen_to_notifications(threaded=True, on_download_start=self.__onDownloadStarted,
-                                    on_download_error=self.__onDownloadError,
-                                    on_download_pause=self.__onDownloadPause,
-                                    on_download_stop=self.__onDownloadStopped,
-                                    on_download_complete=self.__onDownloadComplete)
-
+                                      on_download_error=self.__onDownloadError,
+                                      on_download_pause=self.__onDownloadPause,
+                                      on_download_stop=self.__onDownloadStopped,
+                                      on_download_complete=self.__onDownloadComplete)

bot/helper/mirror_utils/aria2_download.py renamed to bot/helper/mirror_utils/download_utils/aria2_download.py

@@ -1,21 +1,22 @@
 from bot import aria2, DOWNLOAD_DIR
 from bot.helper.ext_utils.bot_utils import get_readable_file_size, MirrorStatus, get_readable_time
+from .download_status import DownloadStatus
 
 
 def get_download(gid):
     return aria2.get_download(gid)
 
 
-class DownloadStatus:
+class AriaDownloadStatus(DownloadStatus):
 
     def __init__(self, gid, listener):
+        super().__init__()
         self.upload_name = None
         self.is_archiving = False
         self.__gid = gid
         self.__download = get_download(gid)
         self.__uid = listener.uid
         self._listener = listener
-        self.upload_helper = None
         self.last = None
         self.is_waiting = False
 
@@ -28,35 +29,20 @@ def progress(self):
         :return: returns progress in percentage
         """
         self.__update()
-        if self.upload_helper is not None:
-            return f'{round(self.upload_progress(), 2)}%'
         return self.__download.progress_string()
 
-    def upload_progress(self):
-        return self.upload_helper.uploaded_bytes / self.download().total_length * 100
-
-    def __size(self):
+    def size_raw(self):
         """
         Gets total size of the mirror file/folder
         :return: total size of mirror
         """
         return self.download().total_length
 
-    def __upload_speed(self):
-        """
-        :return: Upload speed in Bytes/Seconds
-        """
-        return self.upload_helper.speed()
-
     def speed(self):
         self.__update()
-        if self.upload_helper is not None:
-            return f'{get_readable_file_size(self.__upload_speed())}/s'
         return self.__download.download_speed_string()
 
     def name(self):
-        if self.upload_name is not None:
-            return self.upload_name
         self.__update()
         return self.__download.name
 
@@ -68,24 +54,14 @@ def size(self):
 
     def eta(self):
         self.__update()
-        if self.upload_helper is not None:
-            try:
-                seconds = (self.__size() - self.upload_helper.uploaded_bytes) / self.__upload_speed()
-                return f'{get_readable_time(seconds)}'
-            except ZeroDivisionError:
-                return '-'
         return self.__download.eta_string()
 
     def status(self):
         self.__update()
-        if self.is_archiving:
-            status = MirrorStatus.STATUS_ARCHIVING
-        elif self.download().is_waiting:
+        if self.download().is_waiting:
             status = MirrorStatus.STATUS_WAITING
         elif self.download().is_paused:
             status = MirrorStatus.STATUS_CANCELLED
-        elif self.upload_helper is not None:
-            status = MirrorStatus.STATUS_UPLOADING
         elif self.__download.has_failed:
             status = MirrorStatus.STATUS_FAILED
         else:

bot/helper/mirror_utils/download_helper.py renamed to bot/helper/mirror_utils/download_utils/download_helper.py

@@ -0,0 +1,36 @@
+# Generic status class. All other status classes must inherit this class
+
+
+class DownloadStatus:
+
+    def progress(self):
+        """
+        Calculates the progress of the mirror (upload or download)
+        :return: progress in percentage
+        """
+        raise NotImplementedError
+
+    def speed(self):
+        """:return: speed in bytes per second"""
+        raise NotImplementedError
+
+    def name(self):
+        """:return name of file/directory being processed"""
+        raise NotImplementedError
+
+    def path(self):
+        """:return path of the file/directory"""
+        raise NotImplementedError
+
+    def size(self):
+        """:return Size of file folder"""
+        raise NotImplementedError
+
+    def eta(self):
+        """:return ETA of the process to complete"""
+        raise NotImplementedError
+
+    def status(self):
+        """:return String describing what is the object of this class will be tracking (upload/download/something
+        else) """
+        raise NotImplementedError

bot/helper/mirror_utils/status_utils/__init__.py

@@ -17,14 +17,14 @@ def onDownloadComplete(self):
     def onDownloadError(self, error: str):
         raise NotImplementedError
 
-    def onUploadStarted(self, progress_status_list: list, index: int):
+    def onUploadStarted(self):
         raise NotImplementedError
 
-    def onUploadProgress(self, progress: list, index: int):
+    def onUploadProgress(self):
         raise NotImplementedError
 
-    def onUploadComplete(self, link: str, progress_status_list: list, index: int):
+    def onUploadComplete(self, link: str):
         raise NotImplementedError
 
-    def onUploadError(self, error: str, progress_status: list, index: int):
-        raise NotImplementedError
+    def onUploadError(self, error: str):
+        raise NotImplementedError

bot/helper/mirror_utils/download_status.py renamed to bot/helper/mirror_utils/status_utils/aria_download_status.py

@@ -0,0 +1,31 @@
+from .download_status import DownloadStatus
+from bot.helper.ext_utils.bot_utils import get_readable_file_size, MirrorStatus
+
+
+class TarStatus(DownloadStatus):
+    def __init__(self, name, path, size):
+        self.__name = name
+        self.__path = path
+        self.__size = size
+
+    def progress(self):
+        return '0'
+
+    def speed(self):
+        return '0'
+
+    def name(self):
+        return self.__name
+
+    def path(self):
+        return self.__path
+
+    def size(self):
+        return get_readable_file_size(self.__size)
+
+    def eta(self):
+        return '0s'
+
+    def status(self):
+        return MirrorStatus.STATUS_ARCHIVING
+