feat: build

music_kraken/utils/support_classes/__init__.py

@@ -0,0 +1 @@
+from .thread_classes import EndThread, FinishedSearch

music_kraken/utils/support_classes/download_result.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+from ...utils.config import main_settings, logging_settings
+from ...utils.enums.colors import BColors
+from ...objects import Target
+
+UNIT_PREFIXES: List[str] = ["", "k", "m", "g", "t"]
+UNIT_DIVISOR = 1024
+
+LOGGER = logging_settings["download_logger"]
+
+
+@dataclass
+class DownloadResult:
+    total: int = 0
+    fail: int = 0
+    sponsor_segments: int = 0
+    error_message: str = None
+    total_size = 0
+    found_on_disk: int = 0
+
+    _error_message_list: List[str] = field(default_factory=list)
+
+    @property
+    def success(self) -> int:
+        return self.total - self.fail
+
+    @property
+    def success_percentage(self) -> float:
+        if self.total == 0:
+            return 0
+        return self.success / self.total
+
+    @property
+    def failure_percentage(self) -> float:
+        if self.total == 0:
+            return 1
+        return self.fail / self.total
+
+    @property
+    def is_fatal_error(self) -> bool:
+        return self.error_message is not None
+
+    @property
+    def is_mild_failure(self) -> bool:
+        if self.is_fatal_error:
+            return True
+
+        return self.failure_percentage > main_settings["show_download_errors_threshold"]
+
+    def _size_val_unit_pref_ind(self, val: float, ind: int) -> Tuple[float, int]:
+        if val < UNIT_DIVISOR:
+            return val, ind
+        if ind >= len(UNIT_PREFIXES):
+            return val, ind
+
+        return self._size_val_unit_pref_ind(val=val / UNIT_DIVISOR, ind=ind + 1)
+
+    @property
+    def formated_size(self) -> str:
+        total_size, prefix_index = self._size_val_unit_pref_ind(self.total_size, 0)
+        return f"{total_size:.{2}f} {UNIT_PREFIXES[prefix_index]}B"
+
+    def add_target(self, target: Target):
+        self.total_size += target.size
+
+    def merge(self, other: "DownloadResult"):
+        if other.is_fatal_error:
+            LOGGER.debug(other.error_message)
+            self._error_message_list.append(other.error_message)
+            self.total += 1
+            self.fail += 1
+        else:
+            self.total += other.total
+            self.fail += other.fail
+            self._error_message_list.extend(other._error_message_list)
+
+        self.sponsor_segments += other.sponsor_segments
+        self.total_size += other.total_size
+        self.found_on_disk += other.found_on_disk
+
+    def __str__(self):
+        if self.is_fatal_error:
+            return self.error_message
+        head = f"{self.fail} from {self.total} downloads failed:\n" \
+               f"success-rate:\t{int(self.success_percentage * 100)}%\n" \
+               f"fail-rate:\t{int(self.failure_percentage * 100)}%\n" \
+               f"total size:\t{self.formated_size}\n" \
+               f"skipped segments:\t{self.sponsor_segments}\n" \
+               f"found on disc:\t{self.found_on_disk}"
+
+        if not self.is_mild_failure:
+            return head
+
+        _lines = [head]
+        _lines.extend(BColors.FAIL.value + s + BColors.ENDC.value for s in self._error_message_list)
+        return "\n".join(_lines)

music_kraken/utils/support_classes/hacking.py

@@ -0,0 +1,104 @@
+import weakref
+from types import FunctionType
+from functools import wraps
+
+from typing import Dict, Set
+
+class Lake:
+    def __init__(self):
+        self.redirects: Dict[int, int] = {}
+        self.id_to_object: Dict[int, object] = {}
+
+    def get_real_object(self, db_object: object) -> object:
+        _id = id(db_object)
+        while _id in self.redirects:
+            _id = self.redirects[_id]
+
+        try:
+            return self.id_to_object[_id]
+        except KeyError:
+            self.add(db_object)
+        return db_object
+
+    def add(self, db_object: object):
+        self.id_to_object[id(db_object)] = db_object
+
+    def override(self, to_override: object, new_db_object: object):
+        _id = id(to_override)
+        while _id in self.redirects:
+            _id = self.redirects[_id]
+
+        if id(new_db_object) in self.id_to_object:
+            print("!!!!!")
+
+        self.add(new_db_object)
+        self.redirects[_id] = id(new_db_object)
+        # if _id in self.id_to_object:
+        # del self.id_to_object[_id]
+
+    def is_same(self, __object: object, other: object) -> bool:
+        _self_id = id(__object)
+        while _self_id in self.redirects:
+            _self_id = self.redirects[_self_id]
+
+        _other_id = id(other)
+        while _other_id in self.redirects:
+            _other_id = self.redirects[_other_id]
+
+        return _self_id == _other_id
+
+
+lake = Lake()
+
+
+def wrapper(method):
+    @wraps(method)
+    def wrapped(*args, **kwargs):
+        return method(*(lake.get_real_object(args[0]), *args[1:]), **kwargs)
+
+    return wrapped
+
+
+class BaseClass:
+    def __new__(cls, *args, **kwargs):
+        instance = cls(*args, **kwargs)
+        print("new")
+        lake.add(instance)
+        return instance
+
+    def __eq__(self, other):
+        return lake.is_same(self, other)
+
+    def _risky_merge(self, to_replace):
+        lake.override(to_replace, self)
+
+
+class MetaClass(type):
+    def __new__(meta, classname, bases, classDict):
+        bases = (*bases, BaseClass)
+        newClassDict = {}
+
+        ignore_functions: Set[str] = {"__new__", "__init__"}
+
+        for attributeName, attribute in classDict.items():
+            if isinstance(attribute, FunctionType) and (attributeName not in ignore_functions):
+                """
+                The funktion new and init shouldn't be accounted for because we can assume the class is 
+                independent on initialization.
+                """
+                attribute = wrapper(attribute)
+
+            newClassDict[attributeName] = attribute
+
+        print()
+
+        for key, value in object.__dict__.items():
+            # hasattr( value, '__call__' ) and
+            if hasattr(value, '__call__') and value not in newClassDict and key not in ("__new__", "__init__"):
+                newClassDict[key] = wrapper(value)
+
+        new_instance = type.__new__(meta, classname, bases, newClassDict)
+
+        lake.add(new_instance)
+
+        return new_instance

music_kraken/utils/support_classes/query.py

@@ -0,0 +1,32 @@
+from typing import Optional, List
+
+from ...objects import Artist, Album, Song, DatabaseObject
+
+class Query:
+    def __init__(
+        self,
+        raw_query: str = "",
+        music_object: DatabaseObject = None
+    ) -> None:
+        self.raw_query: str = raw_query
+        self.music_object: Optional[DatabaseObject] = music_object
+        
+    @property
+    def is_raw(self) -> bool:
+        return self.music_object is None
+
+    @property
+    def default_search(self) -> List[str]:
+        if self.music_object is None:
+            return [self.raw_query]
+        
+        if isinstance(self.music_object, Artist):
+            return [self.music_object.name]
+        
+        if isinstance(self.music_object, Song):
+            return [f"{artist.name} - {self.music_object}" for artist in self.music_object.main_artist_collection]
+        
+        if isinstance(self.music_object, Album):
+            return [f"{artist.name} - {self.music_object}" for artist in self.music_object.artist_collection]
+        
+        return [self.raw_query]

music_kraken/utils/support_classes/thread_classes.py

@@ -0,0 +1,12 @@
+class EndThread:
+    _has_ended: bool = False
+    
+    def __bool__(self):
+        return self._has_ended
+    
+    def exit(self):
+        self._has_ended
+        
+class FinishedSearch:
+    pass
+