Merge pull request #44 from mjishnu/v1.5.5

- Refine Range Header parsing for spec compliance and error suppression (#43)
- Remove clear_terminal option (no longer clears the terminal)
- Update docs and logging format
- Minor bug fixes

Author: mjishnu

.deepsource.toml

@@ -63,7 +63,6 @@ dl.start(
     callback: Callable = None,
     block: bool = True,
     display: bool = True,
-    clear_terminal: bool = True,
 )
 ```
 
@@ -99,7 +98,6 @@ Each option is explained below:
 - `callback`: A callback function to be called when the download is complete. The default value is `None`. The function must accept 2 positional parameters: `status` (bool) indicating if the download was successful, and `result` (FileValidator object if successful, None if failed).
 - `block`: Whether to block until the download is complete. The default value is `True`.
 - `display`: Whether to display download progress and other optional messages. The default value is `True`.
-- `clear_terminal`: Whether to clear the terminal before displaying the download progress. The default value is `True`.
 
 - Supported Keyword Arguments:
     - `params`: Parameters to be sent in the query string of the new request. The default value is `None`.
@@ -410,7 +408,6 @@ The `Pypdl` class represents a file downloader that can download a file from a g
     callback = None,
     block = True,
     display = True,
-    clear_terminal = True
 )`: Starts the download process.
 
     ##### Parameters
@@ -443,7 +440,6 @@ The `Pypdl` class represents a file downloader that can download a file from a g
     - `callback`: A callback function to be called when the download is complete. The default value is `None`. The function must accept 2 positional parameters: `status` (bool) indicating if the download was successful, and `result` (FileValidator object if successful, None if failed).
     - `block`: Whether to block until the download is complete. The default value is `True`.
     - `display`: Whether to display download progress and other optional messages. The default value is `True`.
-    - `clear_terminal`: Whether to clear the terminal before displaying the download progress. The default value is `True`.
 
     - Supported Keyword Arguments:
         - `params`: Parameters to be sent in the query string of the new request. The default value is `None`.
@@ -477,44 +473,12 @@ The `Pypdl` class represents a file downloader that can download a file from a g
 
 ### Helper Classes
 
-#### `Basicdown()`
-
-The `Basicdown` class is the base downloader class that provides the basic structure for downloading files.
-
-##### Attributes
-
-- `curr`: The current size of the downloaded file in bytes.
-- `completed`: A flag that indicates if the download is complete.
-- `interrupt`: A flag that indicates if the download was interrupted.
-- `downloaded`: The total amount of data downloaded so far in bytes.
-
-##### Methods
-
-- `download(url, path, mode, session, **kwargs)`: Downloads data in chunks.
-
-#### `Singledown()`
-
-The `Singledown` class extends `Basicdown` and is responsible for downloading a whole file in a single segment.
-
-##### Methods
-
-- `worker(url, file_path, session, **kwargs)`: Downloads a whole file in a single segment.
-
-#### `Multidown()`
-
-The `Multidown` class extends `Basicdown` and is responsible for downloading a specific segment of a file.
-
-##### Methods
-
-- `worker(segment_table, id, session, **kwargs)`: Downloads a part of the file in multiple segments.
-
 #### `FileValidator()`
 
 The `FileValidator` class is used to validate the integrity of the downloaded file.
 
-##### Parameters
-
-- `path`: The path of the file to be validated.
+##### Attributes
+- `path`: The path of the file
 
 ##### Methods
 
@@ -526,12 +490,6 @@ The `FileValidator` class is used to validate the integrity of the downloaded fi
 
 The `AutoShutdownFuture` class is a wrapper for concurrent.futures.Future object that shuts down the eventloop and executor when the result is retrieved.
 
-##### Parameters
-
-- `future`: The Future object to be wrapped.
-- `executor`: The executor to be shut down when the result is retrieved.
-- `loop`: The eventloop to be stopped when result is retrieved.
-
 ##### Methods
 
 - `result(timeout=None)`: Retrieves the result of the Future object and shuts down the executor. If the download was successful, it returns a `FileValidator` object; otherwise, it returns `None`.
@@ -540,11 +498,6 @@ The `AutoShutdownFuture` class is a wrapper for concurrent.futures.Future object
 
 The `EFuture` class is a wrapper for a `concurrent.futures.Future` object that integrates with an event loop to handle asynchronous operations.
 
-##### Parameters
-
-- `future`: The `Future` object to be wrapped.
-- `loop`: The event loop that will be used to manage the `Future`.
-
 ##### Methods
 
 - `result(timeout=None)`: Retrieves the result of the `Future` object. If the `Future` completes successfully, it returns the result; otherwise, it raises an exception.

README.md

@@ -1,3 +1,3 @@
-__version__ = "1.5.4"
+__version__ = "1.5.5"
 
 from .pypdl import Pypdl

pypdl/__init__.py

@@ -135,23 +135,23 @@ async def _fetch_task_info(self, url, file_path, multisegment, **kwargs):
         if file_size := int(header.get("content-length", 0)):
             self._logger.debug("File size acquired from header")
 
-        if range_header:
-            start, end = get_range(range_header, file_size)
+        if multisegment and range_header:
+            size = get_range(range_header, file_size)
         else:
-            start = 0
-            end = file_size - 1
+            size = Size(0, file_size - 1)
 
-        size = Size(start, end)
         etag = header.get("etag", "")
         if etag != "":
             self._logger.debug("ETag acquired from header")
             etag = etag.strip('"')
 
-        if size.value < 1 or not header.get("accept-ranges"):
+        if size.value == 0 or not header.get("accept-ranges"):
             self._logger.debug("Single segment mode, accept-ranges or size not found")
-            kwargs["headers"] = user_headers
             multisegment = False
 
+        if not multisegment:
+            kwargs["headers"] = user_headers
+
         return url, file_path, multisegment, etag, size, kwargs
 
     async def _fetch_header(self, url, **kwargs):

pypdl/producer.py

@@ -104,7 +104,6 @@ def start(
         callback: Callable = None,
         block: bool = True,
         display: bool = True,
-        clear_terminal: bool = True,
         **kwargs,
     ) -> Union[utils.EFuture, utils.AutoShutdownFuture, List]:
         """
@@ -124,7 +123,6 @@ def start(
         :param callback: Callback function to call after each download.
         :param block: If True, block until downloads finish.
         :param display: If True, display progress.
-        :param clear_terminal: If True, clear terminal before displaying progress bar.
         :param kwargs: Addtional keyword arguments for aiohttp.
         :return: A future-like object if non-blocking, or a result list if blocking.
         :raises RuntimeError: If downloads are already in progress.
@@ -171,7 +169,7 @@ def start(
             task_dict[i] = task
             self.total_task += 1
 
-        coro = self._download_tasks(task_dict, display, clear_terminal)
+        coro = self._download_tasks(task_dict, display)
 
         self._future = utils.EFuture(
             asyncio.run_coroutine_threadsafe(coro, self._loop.get()),
@@ -194,7 +192,7 @@ def start(
 
         return future
 
-    async def _download_tasks(self, tasks_dict, display, clear_terminal):
+    async def _download_tasks(self, tasks_dict, display):
         self._logger.debug("Starting download tasks")
         start_time = time.time()
         coroutines = []
@@ -224,7 +222,7 @@ async def _download_tasks(self, tasks_dict, display, clear_terminal):
                     self._consumers.append(consumer)
 
                 self._logger.debug("Starting producer and consumer tasks")
-                self._pool.submit(self._progress_monitor, display, clear_terminal)
+                self._pool.submit(self._progress_monitor, display)
                 await utils.auto_cancel_gather(*coroutines)
                 await asyncio.sleep(0.5)
         except utils.MainThreadException as e:
@@ -272,11 +270,11 @@ def _reset(self):
         self._success.clear()
         self._failed.clear()
 
-    def _progress_monitor(self, display, clear_terminal):
+    def _progress_monitor(self, display):
         self._logger.debug("Starting progress monitor")
         interval = 0.5
         recent_queue = deque(maxlen=12)
-        with utils.ScreenCleaner(display, clear_terminal):
+        with utils.ScreenCleaner(display):
             while not self.completed and not self._interrupt.is_set():
                 self._calc_values(recent_queue, interval)
                 if display:

pypdl/pypdl.py

@@ -7,7 +7,7 @@
 from concurrent.futures import CancelledError, Executor, Future, ThreadPoolExecutor
 from os import path
 from threading import Event, Thread
-from typing import Callable, Dict, List, Optional, Tuple, Union
+from typing import Callable, Dict, List, Optional, Union
 from urllib.parse import unquote, urlparse
 
 from aiofiles import open as fopen
@@ -278,22 +278,17 @@ def _stop(self) -> None:
 
 
 class ScreenCleaner:
-    """A context manager to clear the screen and hide cursor."""
+    """Context manager to hide the terminal cursor and add spacing for cleaner output."""
 
-    def __init__(self, display: bool, clear_terminal: bool):
+    def __init__(self, display: bool):
         self.display = display
-        self.clear_terminal = clear_terminal
-
-    def clear(self) -> None:
-        sys.stdout.write(2 * "\n")
-        if self.clear_terminal:
-            sys.stdout.write("\033c")  # Clear screen
-        sys.stdout.write("\x1b[?25l")  # Hide cursor
-        sys.stdout.flush()
 
     def __enter__(self):
         if self.display:
-            self.clear()
+            sys.stdout.write(2 * "\n")
+            sys.stdout.write("\x1b[?25l")  # Hide cursor
+            sys.stdout.flush()
+
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -303,7 +298,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 
 def to_mb(size_in_bytes: int) -> float:
-    return size_in_bytes / MEGABYTE
+    return max(0, size_in_bytes) / MEGABYTE
 
 
 def seconds_to_hms(sec: float) -> str:
@@ -502,45 +497,54 @@ def default_logger(name: str) -> logging.Logger:
     handler = logging.FileHandler("pypdl.log", mode="a", delay=True)
     handler.setFormatter(
         logging.Formatter(
-            "(%(name)s)  %(asctime)s - %(levelname)s: %(message)s",
+            "%(asctime)s - %(levelname)s: %(message)s",
             datefmt="%d-%m-%y %H:%M:%S",
         )
     )
     logger.addHandler(handler)
     return logger
 
 
-def get_range(range_header: str, file_size: int) -> Tuple[int, int]:
-    def parse_part(part: str) -> Optional[int]:
-        return int(part) if part else None
+def get_range(range_header: str, file_size: int) -> Size:
+    if not range_header.lower().startswith("bytes="):
+        raise ValueError('Range header must start with "bytes="')
 
-    range_value = range_header.replace("bytes=", "")
-    parts = range_value.split("-")
-    if len(parts) != 2:
-        raise TypeError("Invalid range format")
+    range_value = range_header.split("=")[1].strip()
+    parts = range_value.split("-", 1)
 
-    start, end = map(parse_part, parts)
+    try:
+        start = int(parts[0]) if parts[0] else None
+        end = int(parts[1]) if parts[1] else None
+    except (ValueError, IndexError):
+        raise ValueError(f"Invalid range format: {range_value}")
 
+    # Case 1: "bytes=start-end"
     if start is not None and end is not None:
-        if start > end:
-            raise TypeError("Invalid range, start is greater than end")
+        # Already parsed correctly
+        pass
+
+    # Case 2: "bytes=start-"
+    elif start is not None and end is None:
+        end = file_size - 1
+
+    # Case 3: "bytes=-suffix_length"
+    elif end is not None and start is None:
+        if end == 0:
+            raise ValueError("Invalid range: suffix length cannot be zero")
+        start = max(0, file_size - end)
+        end = file_size - 1
+
+    # Case 4: Invalid format like "bytes=-"
     else:
-        if file_size == 0:
-            raise TypeError("Invalid range, file size is 0")
-
-        if end is not None:
-            if end > file_size - 1:
-                raise TypeError("Invalid range, end is greater than file size")
-            start = file_size - end
-            end = file_size - 1
-        elif start is not None:
-            if start > file_size - 1:
-                raise TypeError("Invalid range, start is greater than file size")
-            end = file_size - 1
+        raise ValueError(f"Invalid range format: {range_value}")
+
+    if start > end:
+        if end == -1:  # file_size == 0
+            start = 0
         else:
-            raise TypeError(f"Invalid range: {start}-{end}")
+            raise ValueError(f"Invalid range: start ({start}) > end ({end})")
 
-    return start, end
+    return Size(start, end)
 
 
 def run_callback(