diff --git a/poetry.lock b/poetry.lock
index 1b91cc7..5e19b04 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -203,7 +203,7 @@ files = [
 name = "atomicwrites"
 version = "1.4.1"
 description = "Atomic file writes."
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 files = [
@@ -718,7 +718,7 @@ testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs
 name = "iniconfig"
 version = "2.0.0"
 description = "brain-dead simple config-ini parsing"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=3.7"
 files = [
@@ -983,7 +983,7 @@ files = [
 name = "packaging"
 version = "23.1"
 description = "Core utilities for Python packages"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=3.7"
 files = [
@@ -1133,7 +1133,7 @@ test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-co
 name = "pluggy"
 version = "1.3.0"
 description = "plugin and hook calling mechanisms for python"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=3.8"
 files = [
@@ -1149,7 +1149,7 @@ testing = ["pytest", "pytest-benchmark"]
 name = "py"
 version = "1.11.0"
 description = "library with cross-python path, ini-parsing, io, code, log facilities"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
 files = [
@@ -1322,7 +1322,7 @@ plugins = ["importlib-metadata"]
 name = "pytest"
 version = "6.2.5"
 description = "pytest: simple powerful testing with Python"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=3.6"
 files = [
@@ -1343,6 +1343,24 @@ toml = "*"
 [package.extras]
 testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "requests", "xmlschema"]
 
+[[package]]
+name = "pytest-mock"
+version = "3.11.1"
+description = "Thin-wrapper around the mock package for easier use with pytest"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pytest-mock-3.11.1.tar.gz", hash = "sha256:7f6b125602ac6d743e523ae0bfa71e1a697a2f5534064528c6ff84c2f7c2fc7f"},
+    {file = "pytest_mock-3.11.1-py3-none-any.whl", hash = "sha256:21c279fff83d70763b05f8874cc9cfb3fcacd6d354247a976f9529d19f9acf39"},
+]
+
+[package.dependencies]
+pytest = ">=5.0"
+
+[package.extras]
+dev = ["pre-commit", "pytest-asyncio", "tox"]
+
 [[package]]
 name = "pytz"
 version = "2023.3.post1"
@@ -1670,7 +1688,7 @@ test = ["pytest"]
 name = "toml"
 version = "0.10.2"
 description = "Python Library for Tom's Obvious, Minimal Language"
-category = "dev"
+category = "main"
 optional = false
 python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
 files = [
@@ -1959,4 +1977,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "p
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.8 <4.0"
-content-hash = "1cf354944aafbff9fe2ac4bd14695367cb3eb289c8177c55612bc9187dbebbab"
+content-hash = "e259b509756397e94af7de03b42c5f6e1e62ad24d133daba282fbe095e244824"
diff --git a/pyproject.toml b/pyproject.toml
index fc7ce19..4f4ed8d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,15 +7,18 @@ license = "GPL-3.0-only"
 readme = "README.md"
 homepage = "https://github.com/nathom/streamrip"
 repository = "https://github.com/nathom/streamrip"
-include = ["streamrip/config.toml"]
+include = ["src/config.toml"]
 keywords = ["hi-res", "free", "music", "download"]
 classifiers = [
     "License :: OSI Approved :: GNU General Public License (GPL)",
     "Operating System :: OS Independent",
 ]
+packages = [
+    { include = "streamrip" }
+]
 
 [tool.poetry.scripts]
-rip = "src.cli:main"
+rip = "streamrip.cli:main"
 
 [tool.poetry.dependencies]
 python = ">=3.8 <4.0"
@@ -36,6 +39,7 @@ aiofiles = "^0.7"
 aiohttp = "^3.7"
 aiodns = "^3.0.0"
 aiolimiter = "^1.1.0"
+pytest-mock = "^3.11.1"
 
 [tool.poetry.urls]
 "Bug Reports" = "https://github.com/nathom/streamrip/issues"
diff --git a/rip/__init__.py b/rip/__init__.py
deleted file mode 100644
index 6015393..0000000
--- a/rip/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Rip: an easy to use command line utility for downloading audio streams."""
diff --git a/rip/__main__.py b/rip/__main__.py
deleted file mode 100644
index f6f770a..0000000
--- a/rip/__main__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Run the rip program."""
-from .cli import main
-
-main()
diff --git a/rip/exceptions.py b/rip/exceptions.py
deleted file mode 100644
index a392215..0000000
--- a/rip/exceptions.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Exceptions used by RipCore."""
-
-
-class DeezloaderFallback(Exception):
-    """Raise if Deezer account isn't logged in and rip is falling back to Deezloader."""
diff --git a/rip/utils.py b/rip/utils.py
deleted file mode 100644
index dcf1a5f..0000000
--- a/rip/utils.py
+++ /dev/null
@@ -1,49 +0,0 @@
-"""Utility functions for RipCore."""
-
-import re
-from typing import Tuple
-
-from streamrip.constants import AGENT
-from streamrip.utils import gen_threadsafe_session
-
-interpreter_artist_regex = re.compile(r"getSimilarArtist\(\s*'(\w+)'")
-
-
-def extract_interpreter_url(url: str) -> str:
-    """Extract artist ID from a Qobuz interpreter url.
-
-    :param url: Urls of the form "https://www.qobuz.com/us-en/interpreter/{artist}/download-streaming-albums"
-    :type url: str
-    :rtype: str
-    """
-    session = gen_threadsafe_session({"User-Agent": AGENT})
-    r = session.get(url)
-    match = interpreter_artist_regex.search(r.text)
-    if match:
-        return match.group(1)
-
-    raise Exception(
-        "Unable to extract artist id from interpreter url. Use a "
-        "url that contains an artist id."
-    )
-
-
-deezer_id_link_regex = re.compile(
-    r"https://www\.deezer\.com/[a-z]{2}/(album|artist|playlist|track)/(\d+)"
-)
-
-
-def extract_deezer_dynamic_link(url: str) -> Tuple[str, str]:
-    """Extract a deezer url that includes an ID from a deezer.page.link url.
-
-    :param url:
-    :type url: str
-    :rtype: Tuple[str, str]
-    """
-    session = gen_threadsafe_session({"User-Agent": AGENT})
-    r = session.get(url)
-    match = deezer_id_link_regex.search(r.text)
-    if match:
-        return match.group(1), match.group(2)
-
-    raise Exception("Unable to extract Deezer dynamic link.")
diff --git a/src/media.py b/src/media.py
deleted file mode 100644
index bf52fc7..0000000
--- a/src/media.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class Media(ABC):
-    async def rip(self):
-        await self.preprocess()
-        await self.download()
-        await self.postprocess()
-
-    @abstractmethod
-    async def preprocess(self):
-        """Create directories, download cover art, etc."""
-        raise NotImplemented
-
-    @abstractmethod
-    async def download(self):
-        """Download and tag the actual audio files in the correct directories."""
-        raise NotImplemented
-
-    @abstractmethod
-    async def postprocess(self):
-        """Update database, run conversion, delete garbage files etc."""
-        raise NotImplemented
-
-
-class Pending(ABC):
-    """A request to download a `Media` whose metadata has not been fetched."""
-
-    @abstractmethod
-    async def resolve(self) -> Media:
-        """Fetch metadata and resolve into a downloadable `Media` object."""
-        raise NotImplemented
diff --git a/src/track.py b/src/track.py
deleted file mode 100644
index 04f1a5f..0000000
--- a/src/track.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-from dataclasses import dataclass
-
-from .client import Client
-from .config import Config
-from .downloadable import Downloadable
-from .media import Media, Pending
-from .metadata import AlbumMetadata, TrackMetadata
-
-
-@dataclass(slots=True)
-class Track(Media):
-    meta: TrackMetadata
-    downloadable: Downloadable
-    config: Config
-    folder: str
-    download_path: str = ""
-
-    async def preprocess(self):
-        folder = self._get_folder(self.folder)
-        os.makedirs(folder, exist_ok=True)
-        # Run in background while track downloads?
-        # Don't download again if part of album
-        await self._download_cover()
-
-    async def download(self):
-        async with get_progress_bar(self.config, self.downloadable.size()) as bar:
-            self.downloadable.download(self.download_path, lambda x: bar.update(x))
-
-    async def postprocess(self):
-        await self.tag()
-        await self.convert()
-
-
-@dataclass(slots=True)
-class PendingTrack(Pending):
-    id: str
-    album: AlbumMetadata
-    client: Client
-    config: Config
-    folder: str
-
-    async def resolve(self) -> Track:
-        resp = await self.client.get_metadata({"id": self.id}, "track")
-        meta = TrackMetadata.from_resp(self.album, self.client.source, resp)
-        quality = getattr(self.config.session, self.client.source).quality
-        assert isinstance(quality, int)
-        downloadable = await self.client.get_downloadable(self.id, quality)
-        return Track(meta, downloadable, self.config, self.directory)
diff --git a/streamrip/__init__.py b/streamrip/__init__.py
index f69b69e..4e1f95f 100644
--- a/streamrip/__init__.py
+++ b/streamrip/__init__.py
@@ -1,5 +1 @@
-"""streamrip: the all in one music downloader."""
-
-__version__ = "1.9.7"
-
-from . import clients, constants, converter, downloadtools, media
+__all__ = ["config"]
diff --git a/src/album.py b/streamrip/album.py
similarity index 100%
rename from src/album.py
rename to streamrip/album.py
diff --git a/src/artist.py b/streamrip/artist.py
similarity index 100%
rename from src/artist.py
rename to streamrip/artist.py
diff --git a/src/cli.py b/streamrip/cli.py
similarity index 100%
rename from src/cli.py
rename to streamrip/cli.py
diff --git a/src/client.py b/streamrip/client.py
similarity index 100%
rename from src/client.py
rename to streamrip/client.py
diff --git a/src/config.py b/streamrip/config.py
similarity index 84%
rename from src/config.py
rename to streamrip/config.py
index 64867b6..e86fd0d 100644
--- a/src/config.py
+++ b/streamrip/config.py
@@ -3,7 +3,7 @@
 import copy
 import logging
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
 
 from tomlkit.api import dumps, parse
 from tomlkit.toml_document import TOMLDocument
@@ -217,10 +217,11 @@ class ConfigData:
     filepaths: FilepathsConfig
     artwork: ArtworkConfig
     metadata: MetadataConfig
-    qobuz_filter: QobuzDiscographyFilterConfig
+    qobuz_filters: QobuzDiscographyFilterConfig
 
     theme: ThemeConfig
     database: DatabaseConfig
+    conversion: ConversionConfig
 
     _modified: bool = False
 
@@ -241,9 +242,10 @@ class ConfigData:
         artwork = ArtworkConfig(**toml["artwork"])  # type: ignore
         filepaths = FilepathsConfig(**toml["filepaths"])  # type: ignore
         metadata = MetadataConfig(**toml["metadata"])  # type: ignore
-        qobuz_filter = QobuzDiscographyFilterConfig(**toml["qobuz_filters"])  # type: ignore
+        qobuz_filters = QobuzDiscographyFilterConfig(**toml["qobuz_filters"])  # type: ignore
         theme = ThemeConfig(**toml["theme"])  # type: ignore
         database = DatabaseConfig(**toml["database"])  # type: ignore
+        conversion = ConversionConfig(**toml["conversion"])  # type: ignore
 
         return cls(
             toml=toml,
@@ -257,9 +259,10 @@ class ConfigData:
             artwork=artwork,
             filepaths=filepaths,
             metadata=metadata,
-            qobuz_filter=qobuz_filter,
+            qobuz_filters=qobuz_filters,
             theme=theme,
             database=database,
+            conversion=conversion,
         )
 
     @classmethod
@@ -275,7 +278,25 @@ class ConfigData:
         return self._modified
 
     def update_toml(self):
-        pass
+        update_toml_section_from_config(self.toml["downloads"], self.downloads)
+        update_toml_section_from_config(self.toml["qobuz"], self.qobuz)
+        update_toml_section_from_config(self.toml["tidal"], self.tidal)
+        update_toml_section_from_config(self.toml["deezer"], self.deezer)
+        update_toml_section_from_config(self.toml["soundcloud"], self.soundcloud)
+        update_toml_section_from_config(self.toml["youtube"], self.youtube)
+        update_toml_section_from_config(self.toml["lastfm"], self.lastfm)
+        update_toml_section_from_config(self.toml["artwork"], self.artwork)
+        update_toml_section_from_config(self.toml["filepaths"], self.filepaths)
+        update_toml_section_from_config(self.toml["metadata"], self.metadata)
+        update_toml_section_from_config(self.toml["qobuz_filters"], self.qobuz_filters)
+        update_toml_section_from_config(self.toml["theme"], self.theme)
+        update_toml_section_from_config(self.toml["database"], self.database)
+        update_toml_section_from_config(self.toml["conversion"], self.conversion)
+
+
+def update_toml_section_from_config(toml_section, config):
+    for field in fields(config):
+        toml_section[field.name] = getattr(config, field.name)
 
 
 class Config:
@@ -294,3 +315,6 @@ class Config:
         with open(self._path, "w") as toml_file:
             self.file.update_toml()
             toml_file.write(dumps(self.file.toml))
+
+    def __del__(self):
+        self.save_file()
diff --git a/src/config.toml b/streamrip/config.toml
similarity index 100%
rename from src/config.toml
rename to streamrip/config.toml
diff --git a/streamrip/constants.py b/streamrip/constants.py
deleted file mode 100644
index ce4eadf..0000000
--- a/streamrip/constants.py
+++ /dev/null
@@ -1,195 +0,0 @@
-"""Constants that are kept in one place."""
-
-import base64
-
-import mutagen.id3 as id3
-
-AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0"
-
-TIDAL_COVER_URL = "https://resources.tidal.com/images/{uuid}/{width}x{height}.jpg"
-# Get this from (base64encoded)
-# aHR0cHM6Ly9hLXYyLnNuZGNkbi5jb20vYXNzZXRzLzItYWIxYjg1NjguanM=
-# Don't know if this is a static url yet
-SOUNDCLOUD_CLIENT_ID = "qHsjZaNbdTcABbiIQnVfW07cEPGLNjIh"
-SOUNDCLOUD_USER_ID = "672320-86895-162383-801513"
-SOUNDCLOUD_APP_VERSION = "1630917744"
-
-
-QUALITY_DESC = {
-    0: "128kbps",
-    1: "320kbps",
-    2: "16bit/44.1kHz",
-    3: "24bit/96kHz",
-    4: "24bit/192kHz",
-}
-
-QOBUZ_FEATURED_KEYS = (
-    "most-streamed",
-    "recent-releases",
-    "best-sellers",
-    "press-awards",
-    "ideal-discography",
-    "editor-picks",
-    "most-featured",
-    "qobuzissims",
-    "new-releases",
-    "new-releases-full",
-    "harmonia-mundi",
-    "universal-classic",
-    "universal-jazz",
-    "universal-jeunesse",
-    "universal-chanson",
-)
-
-__MP4_KEYS = (
-    "\xa9nam",
-    "\xa9ART",
-    "\xa9alb",
-    r"aART",
-    "\xa9day",
-    "\xa9day",
-    "\xa9cmt",
-    "desc",
-    "purd",
-    "\xa9grp",
-    "\xa9gen",
-    "\xa9lyr",
-    "\xa9too",
-    "cprt",
-    "cpil",
-    "covr",
-    "trkn",
-    "disk",
-    None,
-    None,
-    None,
-)
-
-__MP3_KEYS = (
-    id3.TIT2,
-    id3.TPE1,
-    id3.TALB,
-    id3.TPE2,
-    id3.TCOM,
-    id3.TYER,
-    id3.COMM,
-    id3.TT1,
-    id3.TT1,
-    id3.GP1,
-    id3.TCON,
-    id3.USLT,
-    id3.TEN,
-    id3.TCOP,
-    id3.TCMP,
-    None,
-    id3.TRCK,
-    id3.TPOS,
-    None,
-    None,
-    None,
-)
-
-__METADATA_TYPES = (
-    "title",
-    "artist",
-    "album",
-    "albumartist",
-    "composer",
-    "year",
-    "comment",
-    "description",
-    "purchase_date",
-    "grouping",
-    "genre",
-    "lyrics",
-    "encoder",
-    "copyright",
-    "compilation",
-    "cover",
-    "tracknumber",
-    "discnumber",
-    "tracktotal",
-    "disctotal",
-    "date",
-)
-
-
-FLAC_KEY = {v: v.upper() for v in __METADATA_TYPES}
-MP4_KEY = dict(zip(__METADATA_TYPES, __MP4_KEYS))
-MP3_KEY = dict(zip(__METADATA_TYPES, __MP3_KEYS))
-
-COPYRIGHT = "\u2117"
-PHON_COPYRIGHT = "\u00a9"
-FLAC_MAX_BLOCKSIZE = 16777215  # 16.7 MB
-
-# TODO: give these more descriptive names
-TRACK_KEYS = (
-    "tracknumber",
-    "artist",
-    "albumartist",
-    "composer",
-    "title",
-    "albumcomposer",
-    "explicit",
-)
-ALBUM_KEYS = (
-    "albumartist",
-    "title",
-    "year",
-    "bit_depth",
-    "sampling_rate",
-    "container",
-    "albumcomposer",
-    "id",
-)
-# TODO: rename these to DEFAULT_FOLDER_FORMAT etc
-FOLDER_FORMAT = (
-    "{albumartist} - {title} ({year}) [{container}] [{bit_depth}B-{sampling_rate}kHz]"
-)
-TRACK_FORMAT = "{tracknumber}. {artist} - {title}"
-
-
-TIDAL_MAX_Q = 7
-
-TIDAL_Q_MAP = {
-    "LOW": 0,
-    "HIGH": 1,
-    "LOSSLESS": 2,
-    "HI_RES": 3,
-}
-
-DEEZER_MAX_Q = 6
-DEEZER_FEATURED_KEYS = {"releases", "charts", "selection"}
-AVAILABLE_QUALITY_IDS = (0, 1, 2, 3, 4)
-DEEZER_FORMATS = {
-    "AAC_64",
-    "MP3_64",
-    "MP3_128",
-    "MP3_256",
-    "MP3_320",
-    "FLAC",
-}
-# video only for tidal
-MEDIA_TYPES = {"track", "album", "artist", "label", "playlist", "video"}
-
-# used to homogenize cover size keys
-COVER_SIZES = ("thumbnail", "small", "large", "original")
-
-TIDAL_CLIENT_INFO = {
-    "id": base64.b64decode("elU0WEhWVmtjMnREUG80dA==").decode("iso-8859-1"),
-    "secret": base64.b64decode(
-        "VkpLaERGcUpQcXZzUFZOQlY2dWtYVEptd2x2YnR0UDd3bE1scmM3MnNlND0="
-    ).decode("iso-8859-1"),
-}
-
-QOBUZ_BASE = "https://www.qobuz.com/api.json/0.2"
-
-TIDAL_BASE = "https://api.tidalhifi.com/v1"
-TIDAL_AUTH_URL = "https://auth.tidal.com/v1/oauth2"
-
-DEEZER_BASE = "https://api.deezer.com"
-DEEZER_DL = "http://dz.loaderapp.info/deezer"
-
-SOUNDCLOUD_BASE = "https://api-v2.soundcloud.com"
-
-MAX_FILES_OPEN = 128
diff --git a/src/converter.py b/streamrip/converter.py
similarity index 100%
rename from src/converter.py
rename to streamrip/converter.py
diff --git a/src/core.py b/streamrip/core.py
similarity index 100%
rename from src/core.py
rename to streamrip/core.py
diff --git a/src/db.py b/streamrip/db.py
similarity index 100%
rename from src/db.py
rename to streamrip/db.py
diff --git a/src/deezer_client.py b/streamrip/deezer_client.py
similarity index 100%
rename from src/deezer_client.py
rename to streamrip/deezer_client.py
diff --git a/src/deezloader_client.py b/streamrip/deezloader_client.py
similarity index 100%
rename from src/deezloader_client.py
rename to streamrip/deezloader_client.py
diff --git a/src/downloadable.py b/streamrip/downloadable.py
similarity index 100%
rename from src/downloadable.py
rename to streamrip/downloadable.py
diff --git a/streamrip/downloadtools.py b/streamrip/downloadtools.py
deleted file mode 100644
index 1473579..0000000
--- a/streamrip/downloadtools.py
+++ /dev/null
@@ -1,225 +0,0 @@
-import asyncio
-import functools
-import hashlib
-import logging
-import os
-import re
-from tempfile import gettempdir
-from typing import Callable, Dict, Iterable, List, Optional
-
-import aiofiles
-import aiohttp
-from Cryptodome.Cipher import Blowfish
-
-from .exceptions import NonStreamable
-from .utils import gen_threadsafe_session
-
-logger = logging.getLogger("streamrip")
-
-
-class DownloadStream:
-    """An iterator over chunks of a stream.
-
-    Usage:
-
-        >>> stream = DownloadStream('https://google.com', None)
-        >>> with open('google.html', 'wb') as file:
-        >>>     for chunk in stream:
-        >>>         file.write(chunk)
-
-    """
-
-    is_encrypted = re.compile("/m(?:obile|edia)/")
-
-    def __init__(
-        self,
-        url: str,
-        source: str = None,
-        params: dict = None,
-        headers: dict = None,
-        item_id: str = None,
-    ):
-        """Create an iterable DownloadStream of a URL.
-
-        :param url: The url to download
-        :type url: str
-        :param source: Only applicable for Deezer
-        :type source: str
-        :param params: Parameters to pass in the request
-        :type params: dict
-        :param headers: Headers to pass in the request
-        :type headers: dict
-        :param item_id: (Only for Deezer) the ID of the track
-        :type item_id: str
-        """
-        self.source = source
-        self.session = gen_threadsafe_session(headers=headers)
-
-        self.id = item_id
-        if isinstance(self.id, int):
-            self.id = str(self.id)
-
-        if params is None:
-            params = {}
-
-        self.request = self.session.get(
-            url, allow_redirects=True, stream=True, params=params
-        )
-        self.file_size = int(self.request.headers.get("Content-Length", 0))
-
-        if self.file_size < 20000 and not self.url.endswith(".jpg"):
-            import json
-
-            try:
-                info = self.request.json()
-                try:
-                    # Usually happens with deezloader downloads
-                    raise NonStreamable(f"{info['error']} - {info['message']}")
-                except KeyError:
-                    raise NonStreamable(info)
-
-            except json.JSONDecodeError:
-                raise NonStreamable("File not found.")
-
-    def __iter__(self) -> Iterable:
-        """Iterate through chunks of the stream.
-
-        :rtype: Iterable
-        """
-        if self.source == "deezer" and self.is_encrypted.search(self.url) is not None:
-            assert isinstance(self.id, str), self.id
-
-            blowfish_key = self._generate_blowfish_key(self.id)
-            # decryptor = self._create_deezer_decryptor(blowfish_key)
-            CHUNK_SIZE = 2048 * 3
-            return (
-                # (decryptor.decrypt(chunk[:2048]) + chunk[2048:])
-                (self._decrypt_chunk(blowfish_key, chunk[:2048]) + chunk[2048:])
-                if len(chunk) >= 2048
-                else chunk
-                for chunk in self.request.iter_content(CHUNK_SIZE)
-            )
-
-        return self.request.iter_content(chunk_size=1024)
-
-    @property
-    def url(self):
-        """Return the requested url."""
-        return self.request.url
-
-    def __len__(self) -> int:
-        """Return the value of the "Content-Length" header.
-
-        :rtype: int
-        """
-        return self.file_size
-
-    def _create_deezer_decryptor(self, key) -> Blowfish:
-        return Blowfish.new(key, Blowfish.MODE_CBC, b"\x00\x01\x02\x03\x04\x05\x06\x07")
-
-    @staticmethod
-    def _generate_blowfish_key(track_id: str):
-        """Generate the blowfish key for Deezer downloads.
-
-        :param track_id:
-        :type track_id: str
-        """
-        SECRET = "g4el58wc0zvf9na1"
-        md5_hash = hashlib.md5(track_id.encode()).hexdigest()
-        # good luck :)
-        return "".join(
-            chr(functools.reduce(lambda x, y: x ^ y, map(ord, t)))
-            for t in zip(md5_hash[:16], md5_hash[16:], SECRET)
-        ).encode()
-
-    @staticmethod
-    def _decrypt_chunk(key, data):
-        """Decrypt a chunk of a Deezer stream.
-
-        :param key:
-        :param data:
-        """
-        return Blowfish.new(
-            key,
-            Blowfish.MODE_CBC,
-            b"\x00\x01\x02\x03\x04\x05\x06\x07",
-        ).decrypt(data)
-
-
-class DownloadPool:
-    """Asynchronously download a set of urls."""
-
-    def __init__(
-        self,
-        urls: Iterable,
-        tempdir: str = None,
-        chunk_callback: Optional[Callable] = None,
-    ):
-        self.finished: bool = False
-        # Enumerate urls to know the order
-        self.urls = dict(enumerate(urls))
-        self._downloaded_urls: List[str] = []
-        # {url: path}
-        self._paths: Dict[str, str] = {}
-        self.task: Optional[asyncio.Task] = None
-
-        if tempdir is None:
-            tempdir = gettempdir()
-        self.tempdir = tempdir
-
-    async def getfn(self, url):
-        path = os.path.join(self.tempdir, f"__streamrip_partial_{abs(hash(url))}")
-        self._paths[url] = path
-        return path
-
-    async def _download_urls(self):
-        async with aiohttp.ClientSession() as session:
-            tasks = [
-                asyncio.ensure_future(self._download_url(session, url))
-                for url in self.urls.values()
-            ]
-            await asyncio.gather(*tasks)
-
-    async def _download_url(self, session, url):
-        filename = await self.getfn(url)
-        logger.debug("Downloading %s", url)
-        async with session.get(url) as response, aiofiles.open(filename, "wb") as f:
-            # without aiofiles     3.6632679780000004s
-            # with    aiofiles     2.504482839s
-            await f.write(await response.content.read())
-
-        if self.callback:
-            self.callback()
-
-        logger.debug("Finished %s", url)
-
-    def download(self, callback=None):
-        self.callback = callback
-        asyncio.run(self._download_urls())
-
-    @property
-    def files(self):
-        if len(self._paths) != len(self.urls):
-            # Not all of them have downloaded
-            raise Exception("Must run DownloadPool.download() before accessing files")
-
-        return [
-            os.path.join(self.tempdir, self._paths[self.urls[i]])
-            for i in range(len(self.urls))
-        ]
-
-    def __len__(self):
-        return len(self.urls)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        logger.debug("Removing tempfiles %s", self._paths)
-        for file in self._paths.values():
-            try:
-                os.remove(file)
-            except FileNotFoundError:
-                pass
-
-        return False
diff --git a/src/exceptions.py b/streamrip/exceptions.py
similarity index 100%
rename from src/exceptions.py
rename to streamrip/exceptions.py
diff --git a/streamrip/filepath_utils.py b/streamrip/filepath_utils.py
new file mode 100644
index 0000000..38cca8c
--- /dev/null
+++ b/streamrip/filepath_utils.py
@@ -0,0 +1,35 @@
+from string import Formatter, printable
+
+from pathvalidate import sanitize_filename
+
+
+def clean_filename(fn: str, restrict=False) -> str:
+    path = str(sanitize_filename(fn))
+    if restrict:
+        allowed_chars = set(printable)
+        path = "".join(c for c in path if c in allowed_chars)
+
+    return path
+
+
+def clean_format(formatter: str, format_info: dict, restrict: bool = False) -> str:
+    """Format track or folder names sanitizing every formatter key.
+
+    :param formatter:
+    :type formatter: str
+    :param kwargs:
+    """
+    fmt_keys = filter(None, (i[1] for i in Formatter().parse(formatter)))
+
+    clean_dict = {}
+    for key in fmt_keys:
+        if isinstance(format_info.get(key), (str, float)):
+            clean_dict[key] = clean_filename(str(format_info[key]), restrict=restrict)
+        elif key == "explicit":
+            clean_dict[key] = " (Explicit) " if format_info.get(key, False) else ""
+        elif isinstance(format_info.get(key), int):  # track/discnumber
+            clean_dict[key] = f"{format_info[key]:02}"
+        else:
+            clean_dict[key] = "Unknown"
+
+    return formatter.format(**clean_dict)
diff --git a/streamrip/media.py b/streamrip/media.py
index dbdad0b..bf52fc7 100644
--- a/streamrip/media.py
+++ b/streamrip/media.py
@@ -1,2377 +1,32 @@
-"""Bases that handle parsing and downloading media. """
+from abc import ABC, abstractmethod
 
-import abc
-import concurrent.futures
-import hashlib
-import logging
-import os
-import re
-import shutil
-import subprocess
-from tempfile import gettempdir
-from typing import (
-    Any,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-)
 
-from click import echo, secho, style
-from mutagen.flac import FLAC, Picture
-from mutagen.id3 import APIC, ID3, ID3NoHeaderError
-from mutagen.mp4 import MP4, MP4Cover
-from pathvalidate import sanitize_filepath
+class Media(ABC):
+    async def rip(self):
+        await self.preprocess()
+        await self.download()
+        await self.postprocess()
 
-from . import converter
-from .clients import Client, DeezloaderClient
-from .constants import ALBUM_KEYS, FLAC_MAX_BLOCKSIZE, FOLDER_FORMAT, TRACK_FORMAT
-from .downloadtools import DownloadPool, DownloadStream
-from .exceptions import (
-    InvalidQuality,
-    InvalidSourceError,
-    ItemExists,
-    NonStreamable,
-    PartialFailure,
-    TooLargeCoverArt,
-)
-from .metadata import TrackMetadata
-from .utils import (
-    clean_filename,
-    clean_format,
-    concat_audio_files,
-    decrypt_mqa_file,
-    downsize_image,
-    ext,
-    get_container,
-    get_cover_urls,
-    get_stats_from_quality,
-    get_tqdm_bar,
-    safe_get,
-    tidal_cover_url,
-    tqdm_stream,
-)
+    @abstractmethod
+    async def preprocess(self):
+        """Create directories, download cover art, etc."""
+        raise NotImplemented
 
-logger = logging.getLogger("streamrip")
+    @abstractmethod
+    async def download(self):
+        """Download and tag the actual audio files in the correct directories."""
+        raise NotImplemented
 
-TYPE_REGEXES = {
-    "remaster": re.compile(r"(?i)(re)?master(ed)?"),
-    "extra": re.compile(r"(?i)(anniversary|deluxe|live|collector|demo|expanded)"),
-}
+    @abstractmethod
+    async def postprocess(self):
+        """Update database, run conversion, delete garbage files etc."""
+        raise NotImplemented
 
 
-class Media(abc.ABC):
-    """An interface for a downloadable item."""
+class Pending(ABC):
+    """A request to download a `Media` whose metadata has not been fetched."""
 
-    @abc.abstractmethod
-    def download(self, **kwargs):
-        """Download the item.
-
-        :param kwargs:
-        """
-        pass
-
-    @abc.abstractmethod
-    def load_meta(self, **kwargs):
-        """Load all of the metadata for an item.
-
-        :param kwargs:
-        """
-        pass
-
-    @abc.abstractmethod
-    def tag(self, **kwargs):
-        """Tag this item with metadata, if applicable.
-
-        :param kwargs:
-        """
-        pass
-
-    @abc.abstractmethod
-    def convert(self, **kwargs):
-        """Convert this item between file formats.
-
-        :param kwargs:
-        """
-        pass
-
-    @abc.abstractmethod
-    def __repr__(self):
-        """Return a string representation of the item."""
-        pass
-
-    @abc.abstractmethod
-    def __str__(self):
-        """Get a readable representation of the item."""
-        pass
-
-    @property
-    @abc.abstractmethod
-    def type(self):
-        """Return the type of the item."""
-        pass
-
-    @property
-    @abc.abstractmethod
-    def downloaded_ids(self):
-        """If the item is a collection, this is a set of downloaded IDs."""
-        pass
-
-    @downloaded_ids.setter
-    def downloaded_ids(self, other):
-        pass
-
-    @property
-    @abc.abstractmethod
-    def id(self):
-        pass
-
-    @id.setter
-    def id(self, other):
-        pass
-
-
-class Track(Media):
-    """Represents a downloadable track.
-
-    Loading metadata as a single track:
-    >>> t = Track(client, id='20252078')
-    >>> t.load_meta()  # load metadata from api
-
-    Loading metadata as part of an Album:
-    >>> t = Track.from_album_meta(api_track_dict, client)
-
-    where `api_track_dict` is a track entry in an album tracklist.
-
-    Downloading and tagging:
-    >>> t.download()
-    >>> t.tag()
-    """
-
-    id = None
-    downloaded_ids: set = set()
-    downloaded: bool = False
-    tagged: bool = False
-    converted: bool = False
-
-    quality: int
-    folder: str
-    meta: TrackMetadata
-
-    final_path: str
-    container: str
-
-    def __init__(self, client: Client, **kwargs):
-        """Create a track object.
-
-        The only required parameter is client, but passing at an id is
-        highly recommended. Every value in kwargs will be set as an attribute
-        of the object. (TODO: make this safer)
-
-        :param track_id: track id returned by Qobuz API
-        :type track_id: Optional[Union[str, int]]
-        :param client: qopy client
-        :type client: Client
-        :param meta: TrackMetadata object
-        :type meta: Optional[TrackMetadata]
-        :param kwargs: id, filepath_format, meta, quality, folder
-        """
-        logger.debug(kwargs)
-
-        self.client = client
-        self.__dict__.update(kwargs)
-
-        self.part_of_tracklist = kwargs.get("part_of_tracklist", False)
-
-        if isinstance(kwargs.get("meta"), TrackMetadata):
-            self.meta = kwargs["meta"]
-
-        if (u := kwargs.get("cover_url")) is not None:
-            logger.debug("Cover url: %s", u)
-            self.cover_url = u
-
-    def load_meta(self, **kwargs):
-        """Send a request to the client to get metadata for this Track.
-
-        Usually only called for single tracks and last.fm playlists.
-        """
-        assert self.id is not None, "id must be set before loading metadata"
-
-        source = self.client.source
-
-        self.resp = self.client.get(self.id, media_type="track")
-        self.meta = TrackMetadata(
-            track=self.resp, source=source
-        )  # meta dict -> TrackMetadata object
-
-        # Because the cover urls are not parsed when only the track metadata
-        # is loaded, we need to do this ourselves
-
-        # Default to large if chosen size is not available
-        self.cover_url = self.meta.cover_urls.get(
-            kwargs.get("embed_cover_size", "large"),
-            self.meta.cover_urls.get("large"),
-        )
-
-    def _prepare_download(self, **kwargs):
-        """Do preprocessing before downloading items.
-
-        It creates the directories, downloads cover art, and (optionally)
-        downloads booklets.
-
-        :param kwargs:
-        """
-        # args override attributes
-        self.quality = min(
-            kwargs["quality"], self.client.max_quality, self.meta.quality
-        )
-
-        self.folder = kwargs["parent_folder"] or self.folder
-
-        if not self.part_of_tracklist and kwargs["add_singles_to_folder"]:
-            self.folder = os.path.join(
-                self.folder,
-                clean_format(
-                    kwargs.get("folder_format", FOLDER_FORMAT),
-                    self.meta.get_album_formatter(self.quality),
-                    restrict=kwargs.get("restrict_filenames", False),
-                ),
-            )
-
-        self.file_format = kwargs.get("track_format", TRACK_FORMAT)
-
-        self.folder = sanitize_filepath(self.folder, platform="auto")
-        self.format_final_path(
-            restrict=kwargs.get("restrict_filenames", False)
-        )  # raises: ItemExists
-
-        os.makedirs(self.folder, exist_ok=True)
-
-        if hasattr(self, "cover_url"):
-            try:
-                self.download_cover(
-                    width=kwargs.get("max_artwork_width", 999999),
-                    height=kwargs.get("max_artwork_height", 999999),
-                )  # only downloads for playlists and singles
-            except ItemExists as e:
-                logger.debug(e)
-
-        self.path = os.path.join(gettempdir(), f"{hash(self.id)}_{self.quality}.tmp")
-
-    def download(  # noqa
-        self,
-        quality: int = 3,
-        parent_folder: str = "StreamripDownloads",
-        progress_bar: bool = True,
-        **kwargs,
-    ):
-        """Download the track.
-
-        :param quality: (0, 1, 2, 3, 4)
-        :type quality: int
-        :param folder: folder to download the files to
-        :type folder: Optional[Union[str, os.PathLike]]
-        :param progress_bar: turn on/off progress bar
-        :type progress_bar: bool
-        """
-        if not self.part_of_tracklist and not self.client.source == "soundcloud":
-            secho(f"Downloading {self!s}\n", bold=True)
-
-        self._prepare_download(
-            quality=quality,
-            parent_folder=parent_folder,
-            progress_bar=progress_bar,
-            **kwargs,
-        )
-
-        if self.client.source == "soundcloud":
-            # soundcloud client needs whole dict to get file url
-            url_id = self.resp
-        else:
-            url_id = self.id
-
-        try:
-            dl_info = self.client.get_file_url(url_id, self.quality)
-        except Exception as e:
-            logger.debug(repr(e))
-            raise NonStreamable(e)
-
-        if self.client.source == "qobuz":
-            if not self.__validate_qobuz_dl_info(dl_info):
-                raise NonStreamable("Track is not available for download")
-
-            self.sampling_rate = dl_info.get("sampling_rate")
-            self.bit_depth = dl_info.get("bit_depth")
-
-        # --------- Download Track ----------
-        if self.client.source in ("qobuz", "tidal"):
-            logger.debug("Downloadable URL found: %s", dl_info.get("url"))
-            try:
-                download_url = dl_info["url"]
-            except KeyError as e:
-                if restrictions := dl_info["restrictions"]:
-                    # Turn CamelCase code into a readable sentence
-                    words = re.findall(r"([A-Z][a-z]+)", restrictions[0]["code"])
-                    raise NonStreamable(
-                        words[0] + " " + " ".join(map(str.lower, words[1:])) + "."
-                    )
-
-                secho(f"Panic: {e} dl_info = {dl_info}", fg="red")
-                raise NonStreamable
-
-            _quick_download(download_url, self.path, desc=self._progress_desc)
-
-        elif isinstance(self.client, DeezloaderClient):
-            _quick_download(dl_info["url"], self.path, desc=self._progress_desc)
-
-        elif self.client.source == "deezer":
-            # We can only find out if the requested quality is available
-            # after the streaming request is sent for deezer
-
-            try:
-                stream = DownloadStream(
-                    dl_info["url"], source="deezer", item_id=self.id
-                )
-            except NonStreamable:
-                self.id = dl_info["fallback_id"]
-                dl_info = self.client.get_file_url(self.id, self.quality)
-                assert isinstance(dl_info, dict)
-                stream = DownloadStream(
-                    dl_info["url"], source="deezer", item_id=self.id
-                )
-
-            stream_size = len(stream)
-            stream_quality = dl_info["size_to_quality"][stream_size]
-            if self.quality != stream_quality:
-                # The chosen quality is not available
-                self.quality = stream_quality
-                self.format_final_path(
-                    restrict=kwargs.get("restrict_filenames", False)
-                )  # If the extension is different
-
-            with open(self.path, "wb") as file:
-                for chunk in tqdm_stream(stream, desc=self._progress_desc):
-                    file.write(chunk)
-
-        elif self.client.source == "soundcloud":
-            self._soundcloud_download(dl_info)
-
-        else:
-            raise InvalidSourceError(self.client.source)
-
-        if (
-            self.client.source == "tidal"
-            and isinstance(dl_info, dict)
-            and dl_info.get("enc_key", False)
-        ):
-            out_path = f"{self.path}_dec"
-            logger.debug("Decrypting MQA file")
-            decrypt_mqa_file(self.path, out_path, dl_info["enc_key"])
-            self.path = out_path
-
-        if not kwargs.get("stay_temp", False):
-            self.move(self.final_path)
-
-        logger.debug("Downloaded: %s -> %s", self.path, self.final_path)
-
-        self.downloaded = True
-
-        if not kwargs.get("keep_cover", True) and hasattr(self, "cover_path"):
-            os.remove(self.cover_path)
-
-    def __validate_qobuz_dl_info(self, info: dict) -> bool:
-        """Check if the download info dict returned by Qobuz is downloadable.
-
-        :param info:
-        :type info: dict
-        :rtype: bool
-        """
-        return all(
-            (
-                info.get("sampling_rate"),
-                info.get("bit_depth"),
-                not info.get("sample"),
-            )
-        )
-
-    def move(self, path: str):
-        """Move the Track and set self.path to the new path.
-
-        :param path:
-        :type path: str
-        """
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-
-        try:
-            shutil.move(self.path, path)
-        except FileNotFoundError as e:
-            # This sometimes happens when using Music.app's Auto folder
-            logger.debug("%s during shutil.move", e)
-            os.makedirs(os.path.dirname(path), exist_ok=True)
-            shutil.move(self.path, path)
-
-        self.path = path
-
-    def _soundcloud_download(self, dl_info: dict):
-        """Download a soundcloud track.
-
-        This requires a seperate function because there are three methods that
-        can be used to download a track:
-            * original file downloads
-            * direct mp3 downloads
-            * hls stream ripping
-        All three of these need special processing.
-
-        :param dl_info:
-        :type dl_info: dict
-        :rtype: str
-        """
-        # logger.debug("dl_info: %s", dl_info)
-        if dl_info["type"] == "mp3":
-            import m3u8
-            import requests
-
-            parsed_m3u = m3u8.loads(
-                requests.get(dl_info["url"]).content.decode("utf-8")
-            )
-            self.path += ".mp3"
-
-            with DownloadPool(segment.uri for segment in parsed_m3u.segments) as pool:
-
-                bar = get_tqdm_bar(len(pool), desc=self._progress_desc, unit="Chunk")
-
-                def update_tqdm_bar():
-                    bar.update(1)
-
-                pool.download(callback=update_tqdm_bar)
-
-                concat_audio_files(pool.files, self.path, "mp3")
-
-        elif dl_info["type"] == "original":
-            _quick_download(dl_info["url"], self.path, desc=self._progress_desc)
-
-            # if a wav is returned, convert to flac
-            engine = converter.FLAC(self.path)
-            self.path = f"{self.path}.flac"
-            engine.convert(custom_fn=self.path)
-
-            self.final_path = self.final_path.replace(".mp3", ".flac")
-            self.quality = 2
-
-    @property
-    def type(self) -> str:
-        """Return "track".
-
-        :rtype: str
-        """
-        return "track"
-
-    @property
-    def _progress_desc(self) -> str:
-        """Get the description that is used on the progress bar.
-
-        :rtype: str
-        """
-        return style(f"Track {self.meta.tracknumber:02}", fg="blue")
-
-    def download_cover(self, width=999999, height=999999):
-        """Download the cover art, if cover_url is given."""
-        self.cover_path = os.path.join(gettempdir(), f"cover{hash(self.cover_url)}.jpg")
-        logger.debug("Downloading cover from %s", self.cover_url)
-
-        if not os.path.exists(self.cover_path):
-            _cover_download(self.cover_url, self.cover_path)
-            downsize_image(self.cover_path, width, height)
-        else:
-            logger.debug("Cover already exists, skipping download")
-            raise ItemExists(self.cover_path)
-
-    def format_final_path(self, restrict: bool = False) -> str:
-        """Return the final filepath of the downloaded file.
-
-        This uses the `get_formatter` method of TrackMetadata, which returns
-        a dict with the keys allowed in formatter strings, and their values in
-        the TrackMetadata object.
-        """
-        formatter = self.meta.get_formatter(max_quality=self.quality)
-        logger.debug("Track meta formatter %s", formatter)
-        filename = clean_format(self.file_format, formatter, restrict=restrict)
-        self.final_path = os.path.join(self.folder, filename)[:250].strip() + ext(
-            self.quality, self.client.source
-        )
-
-        logger.debug("Formatted path: %s", self.final_path)
-
-        if os.path.isfile(self.final_path):  # track already exists
-            self.downloaded = True
-            self.tagged = True
-            self.path = self.final_path
-            raise ItemExists(self.final_path)
-
-        return self.final_path
-
-    @classmethod
-    def from_album_meta(cls, album: TrackMetadata, track: dict, client: Client):
-        """Return a new Track object initialized with info.
-
-        :param album: album metadata returned by API
-        :param pos: index of the track
-        :param client: qopy client object
-        :type client: Client
-        :raises: IndexError
-        """
-        meta = TrackMetadata(album=album, track=track, source=client.source)
-        return cls(client=client, meta=meta, id=track["id"], part_of_tracklist=True)
-
-    @classmethod
-    def from_api(cls, item: dict, client: Client):
-        """Return a new Track initialized from search result.
-
-        :param item:
-        :type item: dict
-        :param client:
-        :type client: Client
-        """
-        meta = TrackMetadata(track=item, source=client.source)
-        cover_url: Optional[str]
-        try:
-            if client.source == "qobuz":
-                cover_url = item["album"]["image"]["large"]
-            elif client.source == "tidal":
-                cover_url = tidal_cover_url(item["album"]["cover"], 640)
-            elif client.source == "deezer":
-                cover_url = item["album"]["cover_big"]
-            elif client.source == "soundcloud":
-                if (small_url := item["artwork_url"]) is not None:
-                    cover_url = small_url.replace("large", "t500x500")
-                else:
-                    raise KeyError
-            else:
-                raise InvalidSourceError(client.source)
-
-        except KeyError:
-            logger.debug("No cover found")
-            cover_url = None
-
-        return cls(
-            client=client,
-            meta=meta,
-            id=item["id"],
-            cover_url=cover_url,
-        )
-
-    def tag(  # noqa
-        self,
-        album_meta: dict = None,
-        cover: Union[Picture, APIC, MP4Cover] = None,
-        embed_cover: bool = True,
-        exclude_tags: Optional[Sequence] = None,
-        **kwargs,
-    ):
-        """Tag the track using the stored metadata.
-
-        The info stored in the TrackMetadata object (self.meta) can be updated
-        with album metadata if necessary. The cover must be a mutagen cover-type
-        object that already has the bytes loaded.
-
-        :param album_meta: album metadata to update Track with
-        :type album_meta: dict
-        :param cover: initialized mutagen cover object
-        :type cover: Union[Picture, APIC]
-        :param embed_cover: Embed cover art into file
-        :type embed_cover: bool
-        """
-        assert isinstance(self.meta, TrackMetadata), "meta must be TrackMetadata"
-        if not self.downloaded:
-            logger.info(
-                "Track %s not tagged because it was not downloaded",
-                self["title"],
-            )
-            return
-
-        if self.tagged:
-            logger.info(
-                "Track %s not tagged because it is already tagged",
-                self["title"],
-            )
-            return
-
-        if album_meta is not None:
-            self.meta.add_album_meta(album_meta)  # extend meta with album info
-
-        # TODO: make this cleaner
-        if self.converted:
-            if self.container == "FLAC":
-                audio = FLAC(self.path)
-            elif self.container in ("AAC", "ALAC", "MP4"):
-                audio = MP4(self.path)
-            elif self.container == "MP3":
-                audio = ID3()
-                try:
-                    audio = ID3(self.path)
-                except ID3NoHeaderError:
-                    audio = ID3()
-        else:
-            if self.quality in (2, 3, 4):
-                self.container = "FLAC"
-                logger.debug("Tagging file with %s container", self.container)
-                audio = FLAC(self.path)
-            elif self.quality <= 1:
-                if self.client.source == "tidal":
-                    self.container = "AAC"
-                    audio = MP4(self.path)
-                else:
-                    self.container = "MP3"
-                    try:
-                        audio = ID3(self.path)
-                    except ID3NoHeaderError:
-                        audio = ID3()
-
-                logger.debug("Tagging file with %s container", self.container)
-            else:
-                raise InvalidQuality(f'Invalid quality: "{self.quality}"')
-
-        # automatically generate key, value pairs based on container
-        tags = self.meta.tags(
-            self.container,
-            set(exclude_tags) if exclude_tags is not None else None,
-        )
-        for k, v in tags:
-            logger.debug("Setting %s tag to %s", k, v)
-            audio[k] = v
-
-        if embed_cover and cover is None:
-            cover = (
-                Tracklist.get_cover_obj(
-                    self.cover_path, self.container, self.client.source
-                )
-                if hasattr(self, "cover_path")
-                else None
-            )
-
-        if isinstance(audio, FLAC):
-            if embed_cover and cover:
-                audio.add_picture(cover)
-            audio.save()
-        elif isinstance(audio, ID3):
-            if embed_cover and cover:
-                audio.add(cover)
-            audio.save(self.path, "v2_version=3")
-        elif isinstance(audio, MP4):
-            if cover:
-                audio["covr"] = [cover]
-            audio.save()
-        else:
-            raise ValueError(f"Unknown container type: {audio}")
-
-        self.tagged = True
-
-    def convert(self, codec: str = "ALAC", **kwargs):
-        """Convert the track to another codec.
-
-        Valid values for codec:
-            * FLAC
-            * ALAC
-            * MP3
-            * OPUS
-            * OGG
-            * VORBIS
-            * AAC
-            * M4A
-
-        :param codec: the codec to convert the track to
-        :type codec: str
-        :param kwargs:
-        """
-        if not self.downloaded:
-            logger.debug("Track not downloaded, skipping conversion")
-            secho("Track not downloaded, skipping conversion", fg="magenta")
-            return
-
-        CONV_CLASS = {
-            "FLAC": converter.FLAC,
-            "ALAC": converter.ALAC,
-            "MP3": converter.LAME,
-            "OPUS": converter.OPUS,
-            "OGG": converter.Vorbis,
-            "VORBIS": converter.Vorbis,
-            "AAC": converter.AAC,
-            "M4A": converter.AAC,
-        }
-
-        try:
-            self.container = codec.upper()
-        except AttributeError:
-            secho("Error: No audio codec chosen to convert to.", fg="red")
-            exit()
-
-        if not hasattr(self, "final_path"):
-            self.format_final_path(kwargs.get("restrict_filenames", False))
-
-        if not os.path.isfile(self.path):
-            logger.info("File %s does not exist. Skipping conversion.", self.path)
-            secho(f"{self!s} does not exist. Skipping conversion.", fg="red")
-            return
-
-        assert (
-            self.container in CONV_CLASS
-        ), f"Invalid codec {codec}. Must be in {CONV_CLASS.keys()}"
-
-        engine = CONV_CLASS[self.container](
-            filename=self.path,
-            sampling_rate=kwargs.get("sampling_rate"),
-            remove_source=kwargs.get("remove_source", True),
-        )
-        engine.convert()
-        self.path = engine.final_fn
-        self.final_path = self.final_path.replace(
-            ext(self.quality, self.client.source), f".{engine.container}"
-        )
-
-        if not kwargs.get("stay_temp", False):
-            self.move(self.final_path)
-
-        self.converted = True
-
-    @property
-    def title(self) -> str:
-        """Get the title of the track.
-
-        :rtype: str
-        """
-        try:
-            _title = self.meta.title
-        except AttributeError:
-            raise Exception("Track must be loaded before accessing title")
-
-        if self.meta.explicit:
-            _title = f"{_title} (Explicit)"
-        return _title
-
-    def get(self, *keys, default=None) -> Any:
-        """Safe get method that allows for layered access.
-
-        :param keys:
-        :param default:
-        """
-        return safe_get(self.meta, *keys, default=default)  # type: ignore
-
-    def set(self, key, val):
-        """Set attribute `key` to `val`.
-
-        Equivalent to __setitem__. Implemented only for consistency.
-
-        :param key:
-        :param val:
-        """
-        self.__setitem__(key, val)
-
-    def __getitem__(self, key: str) -> Any:
-        """Dict-like interface for Track metadata.
-
-        :param key:
-        """
-        return getattr(self.meta, key)
-
-    def __setitem__(self, key: str, val: Any):
-        """Dict-like interface for Track metadata.
-
-        :param key:
-        :param val:
-        """
-        setattr(self.meta, key, val)
-
-    def __repr__(self) -> str:
-        """Return a string representation of the track.
-
-        :rtype: str
-        """
-        return f"<Track - {self['title']}>"
-
-    def __str__(self) -> str:
-        """Return a readable string representation of this track.
-
-        :rtype: str
-        """
-        return f"{self['artist']} - {self['title']}"
-
-    def __bool__(self):
-        """Return True."""
-        return True
-
-
-class Video(Media):
-    """Only for Tidal."""
-
-    id = None
-    downloaded_ids: set = set()
-
-    def __init__(self, client: Client, id: str, **kwargs):
-        """Initialize a Video object.
-
-        :param client:
-        :type client: Client
-        :param id: The TIDAL Video ID
-        :type id: str
-        :param kwargs: title, explicit, and tracknumber
-        """
-        self.id = id
-        self.client = client
-
-    def load_meta(self, **kwargs):
-        """Given an id at contruction, get the metadata of the video."""
-        resp = self.client.get(self.id, "video")
-        self.title = resp["title"]
-        self.explicit = resp["explicit"]
-        self.tracknumber = resp["trackNumber"]
-
-    def download(self, **kwargs):
-        """Download the Video.
-
-        :param kwargs:
-        """
-
-        if not kwargs.get("download_videos", True):
-            return
-
-        import m3u8
-        import requests
-
-        # secho(
-        #     f"Downloading {self.title} (Video). This may take a while.",
-        #     fg="blue",
-        # )
-
-        self.parent_folder = kwargs.get("parent_folder", "StreamripDownloads")
-        url = self.client.get_file_url(self.id, video=True)
-
-        parsed_m3u = m3u8.loads(requests.get(url).text)
-        # Asynchronously download the streams
-
-        with DownloadPool(segment.uri for segment in parsed_m3u.segments) as pool:
-            bar = get_tqdm_bar(len(pool), desc=self._progress_desc, unit="Chunk")
-
-            def update_tqdm_bar():
-                bar.update(1)
-
-            pool.download(callback=update_tqdm_bar)
-
-            # Put the filenames in a tempfile that ffmpeg
-            # can read from
-            file_list_path = os.path.join(gettempdir(), "__streamrip_video_files")
-            with open(file_list_path, "w") as file_list:
-                text = "\n".join(f"file '{path}'" for path in pool.files)
-                file_list.write(text)
-
-            # Use ffmpeg to concat the files
-            subprocess.call(
-                (
-                    "ffmpeg",
-                    "-f",
-                    "concat",
-                    "-safe",
-                    "0",
-                    "-i",
-                    file_list_path,
-                    "-c",
-                    "copy",
-                    "-loglevel",
-                    "panic",
-                    self.path,
-                )
-            )
-
-            os.remove(file_list_path)
-
-    def tag(self, *args, **kwargs):
-        """Return False.
-
-        This is a dummy method.
-
-        :param args:
-        :param kwargs:
-        """
-        return False
-
-    @classmethod
-    def from_album_meta(cls, track: dict, client: Client):
-        """Return a new Video object given an album API response.
-
-        :param track: track dict from album
-        :type track: dict
-        :param client:
-        :type client: Client
-        """
-        return cls(
-            client,
-            id=track["id"],
-            title=track["title"],
-            explicit=track["explicit"],
-            tracknumber=track["trackNumber"],
-        )
-
-    def convert(self, *args, **kwargs):
-        """Return None.
-
-        Dummy method.
-
-        :param args:
-        :param kwargs:
-        """
-        pass
-
-    @property
-    def _progress_desc(self) -> str:
-        return style(f"Video {self.tracknumber:02}", fg="blue")
-
-    @property
-    def path(self) -> str:
-        """Get path to download the mp4 file.
-
-        :rtype: str
-        """
-        os.makedirs(self.parent_folder, exist_ok=True)
-        fname = self.title
-        if self.explicit:
-            fname = f"{fname} (Explicit)"
-        if self.tracknumber is not None:
-            fname = f"{self.tracknumber:02}. {fname}"
-
-        return os.path.join(self.parent_folder, f"{fname}.mp4")
-
-    @property
-    def type(self) -> str:
-        """Return "video".
-
-        :rtype: str
-        """
-        return "video"
-
-    def __str__(self) -> str:
-        """Return the title.
-
-        :rtype: str
-        """
-        return self.title
-
-    def __repr__(self) -> str:
-        """Return a string representation of self.
-
-        :rtype: str
-        """
-        return f"<Video - {self.title}>"
-
-    def __bool__(self):
-        """Return True."""
-        return True
-
-
-class YoutubeVideo(Media):
-    """Dummy class implemented for consistency with the Media API."""
-
-    id = None
-    downloaded_ids = set()
-
-    class DummyClient:
-        """Used because YouTube downloads use youtube-dl, not a client."""
-
-        source = "youtube"
-
-    def __init__(self, url: str):
-        """Create a YoutubeVideo object.
-
-        :param url: URL to the youtube video.
-        :type url: str
-        """
-        self.id = url
-        self.client = self.DummyClient()
-
-    def download(
-        self,
-        parent_folder: str = "StreamripDownloads",
-        download_youtube_videos: bool = False,
-        youtube_video_downloads_folder: str = "StreamripDownloads",
-        **kwargs,
-    ):
-        """Download the video using 'youtube-dl'.
-
-        :param parent_folder:
-        :type parent_folder: str
-        :param download_youtube_videos: True if the video should be downloaded.
-        :type download_youtube_videos: bool
-        :param youtube_video_downloads_folder: Folder to put videos if
-        downloaded.
-        :type youtube_video_downloads_folder: str
-        :param kwargs:
-        """
-        secho(f"Downloading url {self.id}", fg="blue")
-        filename_formatter = "%(track_number)s.%(track)s.%(container)s"
-        filename = os.path.join(parent_folder, filename_formatter)
-
-        assert isinstance(self.id, str)
-        p = subprocess.Popen(
-            [
-                "youtube-dl",
-                "-x",  # audio only
-                "-q",  # quiet mode
-                "--add-metadata",
-                "--audio-format",
-                "mp3",
-                "--embed-thumbnail",
-                "-o",
-                filename,
-                self.id,
-            ]
-        )
-
-        if download_youtube_videos:
-            secho("Downloading video stream", fg="blue")
-            pv = subprocess.Popen(
-                [
-                    "youtube-dl",
-                    "-q",
-                    "-o",
-                    os.path.join(
-                        youtube_video_downloads_folder,
-                        "%(title)s.%(container)s",
-                    ),
-                    self.id,
-                ]
-            )
-            pv.wait()
-        p.wait()
-        self.downloaded_ids.add(self.id)
-
-    def load_meta(self, *args, **kwargs):
-        """Return None.
-
-        Dummy method.
-
-        :param args:
-        :param kwargs:
-        """
-        pass
-
-    def tag(self, *args, **kwargs):
-        """Return None.
-
-        Dummy method.
-
-        :param args:
-        :param kwargs:
-        """
-        pass
-
-    def convert(self, *args, **kwargs):
-        raise NotImplementedError
-
-    def type(self):
-        return "youtubevideo"
-
-    def __repr__(self, *args, **kwargs):
-        return f"YoutubeVideo({self.url})"
-
-    def __str__(self):
-        return repr(self)
-
-    def __bool__(self):
-        """Return True."""
-        return True
-
-
-class Booklet:
-    """Only for Qobuz."""
-
-    id = None
-
-    def __init__(self, resp: dict):
-        """Initialize from the `goodies` field of the Qobuz API response.
-
-        Usage:
-        >>> album_meta = client.get('v4m7e0qiorycb', 'album')
-        >>> booklet = Booklet(album_meta['goodies'][0])
-        >>> booklet.download()
-
-        :param resp:
-        :type resp: dict
-        """
-        self.url: str
-        self.description: str
-
-        self.__dict__.update(resp)
-
-    def download(self, parent_folder: str, **kwargs):
-        """Download the Booklet.
-
-        :param parent_folder:
-        :type parent_folder: str
-        :param kwargs:
-        """
-        fn = clean_filename(self.description, restrict=kwargs.get("restrict_filenames"))
-        filepath = os.path.join(parent_folder, f"{fn}.pdf")
-
-        _quick_download(self.url, filepath, "Booklet")
-
-    def type(self) -> str:
-        """Return "booklet".
-
-        :rtype: str
-        """
-        return "booklet"
-
-    def __bool__(self):
-        """Return True."""
-        return True
-
-
-class Tracklist(list):
-    """A base class for tracklist-like objects.
-
-    Implements methods to give it dict-like behavior. If a Tracklist
-    subclass is subscripted with [s: str], it will return an attribute s.
-    If it is subscripted with [i: int] it will return the i'th track in
-    the tracklist.
-    """
-
-    id = None
-    # anything not in parentheses or brackets
-    essence_regex = re.compile(r"([^\(]+)(?:\s*[\(\[][^\)][\)\]])*")
-
-    def download(self, **kwargs):
-        """Download all of the items in the tracklist.
-
-        :param kwargs:
-        """
-        self._prepare_download(**kwargs)
-        if kwargs.get("conversion", False):
-            has_conversion = kwargs["conversion"]["enabled"]
-        else:
-            has_conversion = False
-            kwargs["stay_temp"] = False
-
-        if has_conversion:
-            target = self._download_and_convert_item
-        else:
-            target = self._download_item
-
-        # TODO: make this function return the items that have not been downloaded
-        failed_downloads: List[Tuple[str, str, str]] = []
-        if kwargs.get("concurrent_downloads", True):
-            echo()  # To separate cover progress bars and the rest
-            with concurrent.futures.ThreadPoolExecutor(
-                kwargs.get("max_connections", 3)
-            ) as executor:
-                future_map = {
-                    executor.submit(target, item, **kwargs): item for item in self
-                }
-                try:
-                    concurrent.futures.wait(future_map.keys())
-                    for future in future_map.keys():
-                        try:
-                            future.result()
-                        except ItemExists:
-                            item = future_map[future]
-                            secho(f"{item!s} exists. Skipping.", fg="yellow")
-                        except NonStreamable as e:
-                            item = future_map[future]
-                            e.print(item)
-                            failed_downloads.append(
-                                (item.client.source, item.type, item.id)
-                            )
-
-                except (KeyboardInterrupt, SystemExit):
-                    executor.shutdown()
-                    echo("Aborted! May take some time to shutdown.")
-                    exit()
-
-        else:
-            for item in self:
-                if self.client.source != "soundcloud":
-                    # soundcloud only gets metadata after `target` is called
-                    # message will be printed in `target`
-                    secho(f'\nDownloading "{item!s}"', bold=True, fg="green")
-                try:
-                    target(item, **kwargs)
-                except ItemExists:
-                    secho(f"{item!s} exists. Skipping.", fg="yellow")
-                except NonStreamable as e:
-                    e.print(item)
-                    failed_downloads.append((item.client.source, item.type, item.id))
-
-        self.downloaded = True
-
-        if failed_downloads:
-            raise PartialFailure(failed_downloads)
-
-    def _download_and_convert_item(self, item: Media, **kwargs):
-        """Download and convert an item.
-
-        :param item:
-        :param kwargs: should contain a `conversion` dict.
-        """
-        self._download_item(item, **kwargs)
-        item.convert(**kwargs["conversion"])
-
-    def _download_item(self, item: Media, **kwargs: Any):
-        """Abstract method.
-
-        :param item:
-        :param kwargs:
-        """
-        raise NotImplementedError
-
-    def _prepare_download(**kwargs):
-        """Abstract method.
-
-        :param kwargs:
-        """
-        raise NotImplementedError
-
-    def get(self, key: Union[str, int], default=None):
-        """Get an item if key is int, otherwise get an attr.
-
-        :param key: If it is a str, get an attribute. If an int, get the item
-        at the index.
-        :type key: Union[str, int]
-        :param default:
-        """
-        if isinstance(key, str):
-            if hasattr(self, key):
-                return getattr(self, key)
-
-            return default
-
-        if isinstance(key, int):
-            if 0 <= key < len(self):
-                return self[key]
-
-            return default
-
-    def set(self, key, val):
-        """For consistency with `Tracklist.get`.
-
-        :param key:
-        :param val:
-        """
-        self.__setitem__(key, val)
-
-    def convert(self, codec="ALAC", **kwargs):
-        """Convert every item in `self`.
-
-        Deprecated. Use _download_and_convert_item instead.
-
-        :param codec:
-        :param kwargs:
-        """
-        if sr := kwargs.get("sampling_rate"):
-            if sr < 44100:
-                logger.warning(
-                    "Sampling rate %d is lower than 44.1kHz."
-                    "This may cause distortion and ruin the track.",
-                    kwargs["sampling_rate"],
-                )
-            else:
-                logger.debug("Downsampling to %skHz", sr / 1000)
-
-        for track in self:
-            track.convert(codec, **kwargs)
-
-    @classmethod
-    def from_api(cls, item: dict, client: Client):
-        """Create an Album object from an API response.
-
-        :param resp: response dict
-        :type resp: dict
-        :param source: in ('qobuz', 'deezer', 'tidal')
-        :type source: str
-        """
-        info = cls._parse_get_resp(item, client=client)
-
-        # equivalent to Album(client=client, **info)
-        return cls(client=client, **info)  # type: ignore
-
-    @staticmethod
-    def get_cover_obj(cover_path: str, container: str, source: str):
-        """Return an initialized cover object that is reused for every track.
-
-        :param cover_path: Path to the image, must be a JPEG.
-        :type cover_path: str
-        :param quality: quality ID
-        :type quality: int
-        :rtype: Union[Picture, APIC]
-        """
-
-        def flac_mp3_cover_obj(cover):
-            cover_obj = cover()
-            cover_obj.type = 3
-            cover_obj.mime = "image/jpeg"
-            with open(cover_path, "rb") as img:
-                cover_obj.data = img.read()
-
-            return cover_obj
-
-        if container == "FLAC":
-            cover = Picture
-        elif container == "MP3":
-            cover = APIC
-        elif container in ("AAC", "ALAC", "MP4"):
-            cover = MP4Cover
-        else:
-            raise Exception(container)
-
-        if cover is Picture:
-            size_ = os.path.getsize(cover_path)
-            if size_ > FLAC_MAX_BLOCKSIZE:
-                raise TooLargeCoverArt(
-                    f"Not suitable for Picture embed: {size_ / 10 ** 6} MB"
-                )
-            return flac_mp3_cover_obj(cover)
-
-        elif cover is APIC:
-            return flac_mp3_cover_obj(cover)
-
-        elif cover is MP4Cover:
-            with open(cover_path, "rb") as img:
-                return cover(img.read(), imageformat=MP4Cover.FORMAT_JPEG)
-
-    def download_message(self):
-        """Get the message to display after calling `Tracklist.download`.
-
-        :rtype: str
-        """
-        secho(
-            f"\n\nDownloading {self.title} ({self.__class__.__name__})\n",
-            fg="magenta",
-            bold=True,
-        )
-
-    @staticmethod
-    def _parse_get_resp(item, client):
-        """Abstract.
-
-        :param item:
-        :param client:
-        """
-        raise NotImplementedError
-
-    @staticmethod
-    def essence(album: str) -> str:
-        """Ignore text in parens/brackets, return all lowercase.
-
-        Used to group two albums that may be named similarly, but not exactly
-        the same.
-        """
-        match = Tracklist.essence_regex.match(album)
-        if match:
-            return match.group(1).strip().lower()
-
-        return album
-
-    @property
-    def type(self) -> str:
-        """Return "booklet".
-
-        :rtype: str
-        """
-        return "booklet"
-
-    @property
-    def downloaded_ids(self):
-        """Return the IDs of tracks that have been downloaded."""
-        raise NotImplementedError
-
-    def __getitem__(self, key):
-        """Get an item if key is int, otherwise get an attr.
-
-        :param key:
-        """
-        if isinstance(key, str):
-            return getattr(self, key)
-
-        if isinstance(key, int):
-            return super().__getitem__(key)
-
-    def __setitem__(self, key, val):
-        """Set an item if key is int, otherwise set an attr.
-
-        :param key:
-        :param val:
-        """
-        if isinstance(key, str):
-            setattr(self, key, val)
-
-        if isinstance(key, int):
-            super().__setitem__(key, val)
-
-    def __bool__(self):
-        """Return True."""
-        return True
-
-
-class Album(Tracklist, Media):
-    """Represents a downloadable album.
-
-    >>> resp = client.get('fleetwood mac rumours', 'album')
-    >>> album = Album.from_api(resp['items'][0], client)
-    >>> album.load_meta()
-    >>> album.download()
-
-    """
-
-    downloaded_ids: set = set()
-    id = None
-
-    def __init__(self, client: Client, **kwargs):
-        """Create a new Album object.
-
-        :param client: a qopy client instance
-        :param album_id: album id returned by qobuz api
-        :type album_id: Union[str, int]
-        :param kwargs:
-        """
-        self.client = client
-
-        self.sampling_rate = None
-        self.bit_depth = None
-        self.container: Optional[str] = None
-
-        self.disctotal: int
-        self.tracktotal: int
-        self.albumartist: str
-
-        # usually an unpacked TrackMetadata.asdict()
-        self.__dict__.update(kwargs)
-
-        # to improve from_api method speed
-        if kwargs.get("load_on_init", False):
-            self.load_meta()
-
-        self.loaded = False
-        self.downloaded = False
-
-    def load_meta(self, **kwargs):
-        """Load detailed metadata from API using the id."""
-        assert hasattr(self, "id"), "id must be set to load metadata"
-        resp = self.client.get(self.id, media_type="album")
-
-        # update attributes based on response
-        self.meta = self._parse_get_resp(resp, self.client)
-        self.__dict__.update(self.meta.asdict())  # used for identification
-
-        if not self.get("streamable", False):
-            raise NonStreamable(f"This album is not streamable ({self.id} ID)")
-
-        self._load_tracks(resp, kwargs.get("download_videos", True))
-        self.loaded = True
-
-    @classmethod
-    def from_api(cls, resp: dict, client: Client):
-        """Create an Album object from an API response.
-
-        :param resp:
-        :type resp: dict
-        :param client:
-        :type client: Client
-        """
-        if client.source == "soundcloud":
-            return Playlist.from_api(resp, client)
-
-        info = cls._parse_get_resp(resp, client)
-        return cls(client, **info.asdict())
-
-    def _prepare_download(self, **kwargs):
-        """Prepare the download of the album.
-
-        :param kwargs:
-        """
-        # Generate the folder name
-        self.folder_format = kwargs.get("folder_format", FOLDER_FORMAT)
-        self.quality = min(
-            kwargs.get("quality", 3),
-            self.client.max_quality,
-            self.meta.get("quality", 5),
-        )
-
-        self.container = get_container(self.quality, self.client.source)
-        # necessary to format the folder
-        if self.container in ("AAC", "MP3"):
-            # lossy codecs don't have these metrics
-            self.bit_depth = self.sampling_rate = None
-
-        parent_folder = kwargs.get("parent_folder", "StreamripDownloads")
-        if self.folder_format:
-            self.folder = self._get_formatted_folder(
-                parent_folder,
-                restrict=kwargs.get("restrict_filenames", False),
-                truncate=kwargs.get("truncate_filenames", True),
-            )
-        else:
-            self.folder = parent_folder
-
-        os.makedirs(self.folder, exist_ok=True)
-
-        self.download_message()
-
-        cover_path: Optional[str] = (
-            _choose_and_download_cover(
-                self.cover_urls,
-                kwargs.get("embed_cover_size", "large"),
-                self.folder,
-                kwargs.get("keep_hires_cover", True),
-                (
-                    kwargs.get("max_artwork_width", 1e9),
-                    kwargs.get("max_artwork_height", 1e9),
-                ),
-            )
-            if self.cover_urls
-            else None
-        )
-
-        if cover_path and kwargs.get("embed_cover", True):  # embed by default
-            logger.debug("Getting cover_obj from %s", cover_path)
-            # container generated when formatting folder name
-            self.cover_obj = self.get_cover_obj(
-                cover_path, self.container, self.client.source
-            )
-        else:
-            self.cover_obj = None
-
-        # Download the booklet if applicable
-        if (
-            self.get("booklets")
-            and kwargs.get("download_booklets", True)
-            and not any(f.endswith(".pdf") for f in os.listdir(self.folder))
-        ):
-            secho("\nDownloading booklets", bold=True)
-            for item in self.booklets:
-                Booklet(item).download(parent_folder=self.folder)
-
-    def _download_item(self, item: Media, **kwargs: Any):
-        """Download an item.
-
-        :param track: The item.
-        :type track: Union[Track, Video]
-        :param quality:
-        :type quality: int
-        :param kwargs:
-        :rtype: bool
-        """
-        logger.debug("Downloading track to %s", self.folder)
-        if (
-            self.disctotal > 1
-            and isinstance(item, Track)
-            and kwargs.get("folder_format")
-        ):
-            disc_folder = os.path.join(self.folder, f"Disc {item.meta.discnumber}")
-            kwargs["parent_folder"] = disc_folder
-        else:
-            kwargs["parent_folder"] = self.folder
-
-        quality = kwargs.pop("quality", 3)
-        item.download(quality=min(self.quality, quality), **kwargs)
-
-        logger.debug("tagging tracks")
-        # deezer tracks come tagged
-        if kwargs.get("tag_tracks", True):
-            item.tag(
-                cover=self.cover_obj,
-                embed_cover=kwargs.get("embed_cover", True),
-                exclude_tags=kwargs.get("exclude_tags"),
-            )
-
-        self.downloaded_ids.add(item.id)
-
-    @staticmethod
-    def _parse_get_resp(resp: dict, client: Client) -> TrackMetadata:
-        """Parse information from a client.get(query, 'album') call.
-
-        :param resp:
-        :type resp: dict
-        :rtype: dict
-        """
-        meta = TrackMetadata(album=resp, source=client.source)
-        meta.id = resp["id"]
-        return meta
-
-    def _load_tracks(self, resp, download_videos: bool = True):
-        """Load the tracks into self from an API response.
-
-        This uses a classmethod to convert an item into a Track object, which
-        stores the metadata inside a TrackMetadata object.
-        """
-        logging.debug("Loading %d tracks to album", self.tracktotal)
-        for track in _get_tracklist(resp, self.client.source):
-            if track.get("type") == "Music Video":
-                if download_videos:
-                    self.append(Video.from_album_meta(track, self.client))
-            else:
-                self.append(
-                    Track.from_album_meta(
-                        album=self.meta, track=track, client=self.client
-                    )
-                )
-
-    def _get_formatter(self) -> dict:
-        """Get a formatter that is used for naming folders and previews.
-
-        :rtype: dict
-        """
-        fmt = {key: self.get(key) for key in ALBUM_KEYS}
-
-        # Get minimum of both bit depth and sampling rate
-        stats = tuple(
-            min(stat1, stat2)
-            for stat1, stat2 in zip(
-                (self.meta.bit_depth, self.meta.sampling_rate),
-                get_stats_from_quality(self.quality),
-            )
-            if stat1 is not None and stat2 is not None
-        )
-        logger.debug("Sampling rate, bit depth = %s", stats)
-
-        if not stats:
-            stats = (None, None)
-
-        # The quality chosen is not the maximum available quality
-        if stats != (fmt.get("sampling_rate"), fmt.get("bit_depth")):
-            fmt["bit_depth"] = stats[0]
-            fmt["sampling_rate"] = stats[1]
-
-        if sr := fmt.get("sampling_rate"):
-            if sr % 1000 == 0:
-                # truncate the decimal .0 when converting to str
-                fmt["sampling_rate"] = int(sr / 1000)
-            else:
-                fmt["sampling_rate"] = sr / 1000
-
-        logger.debug("Formatter: %s", fmt)
-        return fmt
-
-    def _get_formatted_folder(
-        self, parent_folder: str, restrict: bool = False, truncate: bool = True
-    ) -> str:
-        """Generate the folder name for this album.
-
-        :param parent_folder:
-        :type parent_folder: str
-        :param quality:
-        :type quality: int
-        :rtype: str
-        """
-
-        formatted_folder = clean_format(
-            self.folder_format,
-            self._get_formatter(),
-            restrict=restrict,
-        )
-        if truncate and len(formatted_folder) > 120:
-            formatted_folder = formatted_folder[:120]
-
-        return os.path.join(parent_folder, formatted_folder)
-
-    @property
-    def title(self) -> str:
-        """Get the title of the album.
-
-        :rtype: str
-        """
-        return self.album
-
-    @title.setter
-    def title(self, val: str):
-        """Set the title of the Album.
-
-        :param val:
-        :type val: str
-        """
-        self.album = val
-
-    def __repr__(self) -> str:
-        """Return a string representation of this Album object.
-
-        :rtype: str
-        """
-        # Avoid AttributeError if load_on_init key is not set
-        if hasattr(self, "albumartist"):
-            return f"<Album: {self.albumartist} - {self.title}>"
-
-        return f"<Album: V/A - {self.title}>"
-
-    def __str__(self) -> str:
-        """Return a readable string representation of this album.
-
-        :rtype: str
-        """
-        return f"{self['albumartist']} - {self['title']}"
-
-    def __len__(self) -> int:
-        """Get the length of the album.
-
-        :rtype: int
-        """
-        return self.tracktotal
-
-    def __hash__(self):
-        """Hash the album."""
-        return hash(self.id)
-
-
-class Playlist(Tracklist, Media):
-    """Represents a downloadable playlist.
-
-    Usage:
-    >>> resp = client.search('hip hop', 'playlist')
-    >>> pl = Playlist.from_api(resp['items'][0], client)
-    >>> pl.load_meta()
-    >>> pl.download()
-    """
-
-    id = None
-    downloaded_ids: set = set()
-
-    def __init__(self, client: Client, **kwargs):
-        """Create a new Playlist object.
-
-        :param client: a qopy client instance
-        :param album_id: playlist id returned by qobuz api
-        :type album_id: Union[str, int]
-        :param kwargs:
-        """
-        self.name: str
-        self.client = client
-        logger.debug(kwargs)
-
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-        # to improve from_api method speed
-        if kwargs.get("load_on_init"):
-            self.load_meta()
-
-        self.loaded = False
-
-    @classmethod
-    def from_api(cls, resp: dict, client: Client):
-        """Return a Playlist object from an API response.
-
-        :param resp: a single search result entry of a playlist
-        :type resp: dict
-        :param client:
-        :type client: Client
-        """
-        info = cls._parse_get_resp(resp, client)
-        return cls(client, **info)
-
-    def load_meta(self, **kwargs):
-        """Send a request to fetch the tracklist from the api.
-
-        :param new_tracknumbers: replace the tracknumber with playlist position
-        :type new_tracknumbers: bool
-        :param kwargs:
-        """
-        self.meta = self.client.get(self.id, media_type="playlist")
-        logger.debug(self.meta)
-        self._load_tracks(**kwargs)
-        self.loaded = True
-
-    def _load_tracks(self, new_tracknumbers: bool = True, **kwargs):
-        """Parse the tracklist returned by the API.
-
-        :param new_tracknumbers: replace tracknumber tag with playlist position
-        :type new_tracknumbers: bool
-        """
-        if self.client.source == "qobuz":
-            self.name = self.meta["name"]
-            self.image = self.meta["images"]
-            self.creator = safe_get(self.meta, "owner", "name", default="Qobuz")
-
-            tracklist = self.meta["tracks"]["items"]
-
-            def meta_args(track):
-                return {"track": track, "album": track["album"]}
-
-        elif self.client.source == "tidal":
-            self.name = self.meta["title"]
-            self.image = tidal_cover_url(
-                self.meta["image"] or self.meta["squareImage"], 640
-            )
-            self.creator = safe_get(self.meta, "creator", "name", default="TIDAL")
-
-            tracklist = self.meta["tracks"]
-
-            def meta_args(track):
-                return {
-                    "track": track,
-                    "source": self.client.source,
-                }
-
-        elif self.client.source == "deezer":
-            self.name = self.meta["title"]
-            self.image = self.meta["picture_big"]
-            self.creator = safe_get(self.meta, "creator", "name", default="Deezer")
-
-            tracklist = self.meta["tracks"]
-
-        elif self.client.source == "soundcloud":
-            self.name = self.meta["title"]
-            # self.image = self.meta.get("artwork_url").replace("large", "t500x500")
-            self.creator = self.meta["user"]["username"]
-            tracklist = self.meta["tracks"]
-
-        else:
-            raise NotImplementedError
-
-        self.tracktotal = len(tracklist)
-        if self.client.source == "soundcloud":
-            # No meta is included in soundcloud playlist
-            # response, so it is loaded at download time
-            for track in tracklist:
-                self.append(Track(self.client, id=track["id"]))
-        else:
-            for track in tracklist:
-                meta = TrackMetadata(track=track, source=self.client.source)
-                cover_urls = get_cover_urls(track["album"], self.client.source)
-                cover_url = (
-                    cover_urls[kwargs.get("embed_cover_size", "large")]
-                    if cover_urls is not None
-                    else None
-                )
-
-                self.append(
-                    Track(
-                        self.client,
-                        id=track.get("id"),
-                        meta=meta,
-                        cover_url=cover_url,
-                        part_of_tracklist=True,
-                    )
-                )
-
-        logger.debug("Loaded %d tracks from playlist %s", len(self), self.name)
-
-    def _prepare_download(self, parent_folder: str = "StreamripDownloads", **kwargs):
-        if kwargs.get("folder_format"):
-            fname = clean_filename(self.name, kwargs.get("restrict_filenames", False))
-            self.folder = os.path.join(parent_folder, fname)
-        else:
-            self.folder = parent_folder
-
-        # Used for safe concurrency with tracknumbers instead of an object
-        # level that stores an index
-        self.__indices = iter(range(1, len(self) + 1))
-        self.download_message()
-
-    def _download_item(self, item: Media, **kwargs):
-        assert isinstance(item, Track)
-
-        kwargs["parent_folder"] = self.folder
-        if self.client.source == "soundcloud":
-            item.load_meta()
-
-        if kwargs.get("set_playlist_to_album", False):
-            item.meta.album = self.name
-            item.meta.albumartist = self.creator
-
-        if kwargs.get("new_tracknumbers", True):
-            item.meta.tracknumber = next(self.__indices)
-            item.meta.discnumber = 1
-
-        item.download(**kwargs)
-
-        item.tag(
-            embed_cover=kwargs.get("embed_cover", True),
-            exclude_tags=kwargs.get("exclude_tags"),
-        )
-
-        self.downloaded_ids.add(item.id)
-
-    @staticmethod
-    def _parse_get_resp(item: dict, client: Client) -> dict:
-        """Parse information from a search result returned by a client.search call.
-
-        :param item:
-        :type item: dict
-        :param client:
-        :type client: Client
-        """
-        if client.source == "qobuz":
-            return {
-                "name": item["name"],
-                "id": item["id"],
-            }
-        elif client.source == "tidal":
-            return {
-                "name": item["title"],
-                "id": item["uuid"],
-            }
-        elif client.source == "deezer":
-            return {
-                "name": item["title"],
-                "id": item["id"],
-            }
-        elif client.source == "soundcloud":
-            return {
-                "name": item["title"],
-                "id": item["permalink_url"],
-                "description": item["description"],
-                "popularity": f"{item['likes_count']} likes",
-                "tracktotal": len(item["tracks"]),
-            }
-
-        raise InvalidSourceError(client.source)
-
-    @property
-    def title(self) -> str:
-        """Get the title.
-
-        :rtype: str
-        """
-        return self.name
-
-    def __repr__(self) -> str:
-        """Return a string representation of this Playlist object.
-
-        :rtype: str
-        """
-        return f"<Playlist: {self.name}>"
-
-    def tag(self):
-        """Raise NotImplementedError."""
-        raise NotImplementedError
-
-    def __str__(self) -> str:
-        """Return a readable string representation of this track.
-
-        :rtype: str
-        """
-        return f"{self.name} ({len(self)} tracks)"
-
-
-class Artist(Tracklist, Media):
-    """Represents a downloadable artist.
-
-    Usage:
-    >>> resp = client.get('fleetwood mac', 'artist')
-    >>> artist = Artist.from_api(resp['items'][0], client)
-    >>> artist.load_meta()
-    >>> artist.download()
-    """
-
-    id = None
-    downloaded_ids: set = set()
-
-    def __init__(self, client: Client, **kwargs):
-        """Create a new Artist object.
-
-        :param client: a qopy client instance
-        :param album_id: artist id returned by qobuz api
-        :type album_id: Union[str, int]
-        :param kwargs:
-        """
-        self.client = client
-        self.downloaded_ids = set()
-
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-        # to improve from_api method speed
-        if kwargs.get("load_on_init"):
-            self.load_meta()
-
-        self.loaded = False
-
-    def load_meta(self, **kwargs):
-        """Send an API call to get album info based on id."""
-        self.meta = self.client.get(self.id, media_type="artist")
-        self._load_albums()
-        self.loaded = True
-
-    # override
-    def download(self, **kwargs):
-        """Download all items in self.
-
-        :param kwargs:
-        """
-        iterator = self._prepare_download(**kwargs)
-        for item in iterator:
-            self._download_item(item, **kwargs)
-
-    def _load_albums(self):
-        """Load Album objects to self.
-
-        This parses the response of client.get(query, 'artist') responses.
-        """
-        if self.client.source == "qobuz":
-            self.name = self.meta["name"]
-            albums = self.meta["albums"]["items"]
-
-        elif self.client.source == "tidal":
-            self.name = self.meta["name"]
-            albums = self.meta["albums"]
-
-        elif self.client.source == "deezer":
-            self.name = self.meta["name"]
-            albums = self.meta["albums"]
-
-        else:
-            raise InvalidSourceError(self.client.source)
-
-        for album in albums:
-            logger.debug("Appending album: %s", album.get("title"))
-            self.append(Album.from_api(album, self.client))
-
-    def _prepare_download(
-        self,
-        parent_folder: str = "StreamripDownloads",
-        filters: tuple = (),
-        **kwargs,
-    ) -> Iterable:
-        """Prepare the download.
-
-        :param parent_folder:
-        :type parent_folder: str
-        :param filters:
-        :type filters: tuple
-        :param kwargs:
-        :rtype: Iterable
-        """
-        if kwargs.get("folder_format"):
-            folder = clean_filename(self.name, kwargs.get("restrict_filenames", False))
-            self.folder = os.path.join(parent_folder, folder)
-        else:
-            self.folder = parent_folder
-
-        logger.debug("Artist folder: %s", self.folder)
-        logger.debug("Length of tracklist %d", len(self))
-        logger.debug("Filters: %s", filters)
-
-        final: Iterable
-        if "repeats" in filters:
-            final = self._remove_repeats(bit_depth=max, sampling_rate=min)
-            filters = tuple(f for f in filters if f != "repeats")
-        else:
-            final = self
-
-        if isinstance(filters, tuple) and self.client.source == "qobuz":
-            filter_funcs = (getattr(self, f"_{filter_}") for filter_ in filters)
-            for func in filter_funcs:
-                final = filter(func, final)
-
-        self.download_message()
-        return final
-
-    def _download_item(self, item: Media, **kwargs):
-        """Download an item.
-
-        :param item:
-        :param parent_folder:
-        :type parent_folder: str
-        :param quality:
-        :type quality: int
-        :param kwargs:
-        :rtype: bool
-        """
-        try:
-            item.load_meta()
-        except NonStreamable as e:
-            e.print(item)
-            return
-
-        kwargs.pop("parent_folder")
-        # always an Album
-        try:
-            item.download(
-                parent_folder=self.folder,
-                **kwargs,
-            )
-        except PartialFailure:
-            pass
-
-        self.downloaded_ids.update(item.downloaded_ids)
-
-    @property
-    def title(self) -> str:
-        """Get the artist name.
-
-        Implemented for consistency.
-
-        :rtype: str
-        """
-        return self.name
-
-    @classmethod
-    def from_api(cls, item: dict, client: Client, source: str = "qobuz"):
-        """Create an Artist object from the api response of Qobuz, Tidal, or Deezer.
-
-        :param resp: response dict
-        :type resp: dict
-        :param source: in ('qobuz', 'deezer', 'tidal')
-        :type source: str
-        """
-        logging.debug("Loading item from API")
-        info = cls._parse_get_resp(item, client)
-
-        # equivalent to Artist(client=client, **info)
-        return cls(client=client, **info)
-
-    @staticmethod
-    def _parse_get_resp(item: dict, client: Client) -> dict:
-        """Parse a result from a client.search call.
-
-        :param item: the item to parse
-        :type item: dict
-        :param client:
-        :type client: Client
-        """
-        if client.source in ("qobuz", "deezer"):
-            info = {
-                "name": item.get("name"),
-                "id": item.get("id"),
-            }
-        elif client.source == "tidal":
-            info = {
-                "name": item["name"],
-                "id": item["id"],
-            }
-        else:
-            raise InvalidSourceError(client.source)
-
-        return info
-
-    # ----------- Filters --------------
-
-    TYPE_REGEXES = {
-        "remaster": re.compile(r"(?i)(re)?master(ed)?"),
-        "extra": re.compile(
-            r"(?i)(anniversary|deluxe|live|collector|demo|expanded|remix)"
-        ),
-    }
-
-    def _remove_repeats(self, bit_depth=max, sampling_rate=max) -> Generator:
-        """Remove the repeated albums from self.
-
-        May remove different versions of the same album.
-
-        :param bit_depth: either max or min functions
-        :param sampling_rate: either max or min functions
-        """
-        groups: Dict[str, list] = {}
-        for album in self:
-            if (t := self.essence(album.title)) not in groups:
-                groups[t] = []
-            groups[t].append(album)
-
-        for group in groups.values():
-            assert bit_depth in (min, max) and sampling_rate in (min, max)
-            best_bd = bit_depth(a["bit_depth"] for a in group)
-            best_sr = sampling_rate(a["sampling_rate"] for a in group)
-            for album in group:
-                if album["bit_depth"] == best_bd and album["sampling_rate"] == best_sr:
-                    yield album
-                    break
-
-    def _non_studio_albums(self, album: Album) -> bool:
-        """Filter non-studio-albums.
-
-        :param artist: usually self
-        :param album: the album to check
-        :type album: Album
-        :rtype: bool
-        """
-        return (
-            album["albumartist"] != "Various Artists"
-            and self.TYPE_REGEXES["extra"].search(album.title) is None
-        )
-
-    def _features(self, album: Album) -> bool:
-        """Filter features.
-
-        This will download only albums where the requested
-        artist is the album artist.
-
-        :param artist: usually self
-        :param album: the album to check
-        :type album: Album
-        :rtype: bool
-        """
-        return self["name"] == album["albumartist"]
-
-    def _extras(self, album: Album) -> bool:
-        """Filter extras.
-
-        :param artist: usually self
-        :param album: the album to check
-        :type album: Album
-        :rtype: bool
-        """
-        return self.TYPE_REGEXES["extra"].search(album.title) is None
-
-    def _non_remasters(self, album: Album) -> bool:
-        """Filter non remasters.
-
-        :param artist: usually self
-        :param album: the album to check
-        :type album: Album
-        :rtype: bool
-        """
-        return self.TYPE_REGEXES["remaster"].search(album.title) is not None
-
-    def _non_albums(self, album: Album) -> bool:
-        """Filter releases that are not albums.
-
-        :param artist: usually self
-        :param album: the album to check
-        :type album: Album
-        :rtype: bool
-        """
-        return len(album) > 1
-
-    # --------- Magic Methods --------
-
-    def __repr__(self) -> str:
-        """Return a string representation of this Artist object.
-
-        :rtype: str
-        """
-        return f"<Artist: {self.name}>"
-
-    def __str__(self) -> str:
-        """Return a readable string representation of this Artist.
-
-        :rtype: str
-        """
-        return self.name
-
-    def __hash__(self):
-        """Hash self."""
-        return hash(self.id)
-
-
-class Label(Artist):
-    """Represents a downloadable Label."""
-
-    id = None
-
-    def load_meta(self, **kwargs):
-        """Load metadata given an id."""
-        assert self.client.source == "qobuz", "Label source must be qobuz"
-
-        resp = self.client.get(self.id, "label")
-        self.name = resp["name"]
-        for album in resp["albums"]["items"]:
-            self.append(Album.from_api(album, client=self.client))
-
-        self.loaded = True
-
-    def __repr__(self):
-        """Return a string representation of the Label."""
-        return f"<Label - {self.name}>"
-
-    def __str__(self) -> str:
-        """Return the name of the Label.
-
-        :rtype: str
-        """
-        return self.name
-
-
-# ---------- misc utility functions -----------
-
-
-def _get_tracklist(resp: dict, source: str) -> list:
-    """Return the tracklist from an API response.
-
-    :param resp:
-    :type resp: dict
-    :param source:
-    :type source: str
-    :rtype: list
-    """
-    if source == "qobuz":
-        return resp["tracks"]["items"]
-    if source in ("tidal", "deezer"):
-        return resp["tracks"]
-
-    raise NotImplementedError(source)
-
-
-def _quick_download(url: str, path: str, desc: str = None):
-    with open(path, "wb") as file:
-        for chunk in tqdm_stream(DownloadStream(url), desc=desc):
-            file.write(chunk)
-
-
-def _cover_download(url: str, path: str):
-    _quick_download(url, path, style("Cover", fg="blue"))
-
-
-def _choose_and_download_cover(
-    cover_urls: dict,
-    preferred_size: str,
-    directory: str,
-    keep_hires_cover: bool = True,
-    downsize: Tuple[int, int] = (999999, 999999),
-) -> Optional[str]:
-    # choose optimal cover size and download it
-
-    hashcode: str = hashlib.md5(
-        "".join(
-            sorted(
-                map(
-                    str,
-                    cover_urls.values(),
-                )
-            )
-        ).encode("utf-8", errors="ignore")
-    ).hexdigest()
-    # hashcode: str = hashlib.md5(str(sorted_list(cover_urls.values())).encode('utf-8', errors='replace')).hexdigest()
-
-    temp_cover_path = os.path.join(gettempdir(), f"cover_{hashcode}.jpg")
-
-    secho(f"Downloading cover art ({preferred_size})", bold=True)
-
-    assert (
-        preferred_size in cover_urls
-    ), f"Invalid cover size. Must be in {cover_urls.keys()}"
-
-    embed_cover_url = cover_urls[preferred_size]
-
-    logger.debug("Chosen cover url: %s", embed_cover_url)
-    if not os.path.exists(temp_cover_path):
-        # Sometimes a size isn't available. When this is the case, find
-        # the first `not None` url.
-        if embed_cover_url is None:
-            urls = tuple(filter(None, cover_urls.values()))
-            if len(urls) == 0:
-                return None
-            embed_cover_url = urls[0]
-
-        logger.debug("Downloading cover from url %s", embed_cover_url)
-
-        _cover_download(embed_cover_url, temp_cover_path)
-
-    hires_cov_path = os.path.join(directory, "cover.jpg")
-    if keep_hires_cover and not os.path.exists(hires_cov_path):
-        logger.debug("Downloading hires cover")
-        _cover_download(cover_urls["original"], hires_cov_path)
-
-    cover_size = os.path.getsize(temp_cover_path)
-    if cover_size > FLAC_MAX_BLOCKSIZE:  # 16.77 MB
-        secho(
-            f"Downgrading embedded cover size, too large ({cover_size}).",
-            fg="bright_yellow",
-        )
-        # The "large" cover is usually 600x600px, which is less than 16.7 MB
-        _cover_download(cover_urls["large"], temp_cover_path)
-        # If the large cover is still too large, downsize to 600x600px
-        if os.path.getsize(temp_cover_path) > FLAC_MAX_BLOCKSIZE:
-            logger.debug("Large sized cover too large, downsizing to 600x600px")
-            downsize_image(temp_cover_path, 600, 600)
-
-    downsize_image(temp_cover_path, *downsize)
-
-    return temp_cover_path
+    @abstractmethod
+    async def resolve(self) -> Media:
+        """Fetch metadata and resolve into a downloadable `Media` object."""
+        raise NotImplemented
diff --git a/src/metadata.py b/streamrip/metadata.py
similarity index 91%
rename from src/metadata.py
rename to streamrip/metadata.py
index 8a8d527..b8cced7 100644
--- a/src/metadata.py
+++ b/streamrip/metadata.py
@@ -6,6 +6,7 @@ import logging
 import re
 from collections import OrderedDict
 from dataclasses import dataclass
+from string import Formatter
 from typing import Generator, Hashable, Iterable, Optional, Type, Union
 
 from .constants import (
@@ -19,7 +20,7 @@ from .constants import (
     TRACK_KEYS,
 )
 from .exceptions import InvalidContainerError, InvalidSourceError
-from .utils import get_cover_urls, get_quality_id, safe_get
+from .utils import get_cover_urls, get_quality_id
 
 logger = logging.getLogger("streamrip")
 
@@ -82,6 +83,9 @@ class TrackMetadata:
             return cls.from_deezer(album, resp)
         raise Exception
 
+    def format_track_path(self, formatter: str):
+        pass
+
 
 @dataclass(slots=True)
 class TrackInfo:
@@ -219,3 +223,23 @@ class AlbumInfo:
     booklets = None
     work: Optional[str] = None
 
+
+_formatter = Formatter()
+
+
+def keys_in_format_string(s: str):
+    """Returns the items in {} in a format string."""
+    return [f[1] for f in _formatter.parse(s) if f[1] is not None]
+
+
+def safe_get(d: dict, *keys, default=None):
+    """Nested __getitem__ calls with a default value.
+
+    Use to avoid key not found errors.
+    """
+    _d = d
+    for k in keys:
+        _d = _d.get(k, {})
+    if _d == {}:
+        return default
+    return _d
diff --git a/streamrip/progress.py b/streamrip/progress.py
new file mode 100644
index 0000000..9a83e60
--- /dev/null
+++ b/streamrip/progress.py
@@ -0,0 +1,27 @@
+from typing import Optional
+
+from click import style
+from tqdm import tqdm
+
+THEMES = {
+    "plain": None,
+    "dainty": (
+        "{desc} |{bar}| "
+        + style("{remaining}", fg="magenta")
+        + " left at "
+        + style("{rate_fmt}{postfix} ", fg="cyan", bold=True)
+    ),
+}
+
+
+def get_progress_bar(total, theme="dainty", desc: Optional[str] = None, unit="B"):
+    theme = THEMES[theme]
+    return tqdm(
+        total=total,
+        unit=unit,
+        unit_scale=True,
+        unit_divisor=1024,
+        desc=desc,
+        dynamic_ncols=True,
+        bar_format=theme,
+    )
diff --git a/src/prompter.py b/streamrip/prompter.py
similarity index 100%
rename from src/prompter.py
rename to streamrip/prompter.py
diff --git a/src/qobuz_client.py b/streamrip/qobuz_client.py
similarity index 100%
rename from src/qobuz_client.py
rename to streamrip/qobuz_client.py
diff --git a/src/qobuz_spoofer.py b/streamrip/qobuz_spoofer.py
similarity index 100%
rename from src/qobuz_spoofer.py
rename to streamrip/qobuz_spoofer.py
diff --git a/src/soundcloud_client.py b/streamrip/soundcloud_client.py
similarity index 100%
rename from src/soundcloud_client.py
rename to streamrip/soundcloud_client.py
diff --git a/streamrip/tagger.py b/streamrip/tagger.py
new file mode 100644
index 0000000..2e52bd4
--- /dev/null
+++ b/streamrip/tagger.py
@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generator
+
+from mutagen.flac import FLAC, Picture
+from mutagen.id3 import APIC, ID3, ID3NoHeaderError
+from mutagen.mp4 import MP4, MP4Cover
+
+from .metadata import TrackMetadata
+
+
+class Container(Enum):
+    FLAC = 1
+    AAC = 2
+    MP3 = 3
+
+    def get_mutagen_class(self, path: str):
+        if self == Container.FLAC:
+            return FLAC(path)
+        elif self == Container.AAC:
+            return MP4(path)
+        elif self == Container.MP3:
+            try:
+                return ID3(path)
+            except ID3NoHeaderError:
+                return ID3()
+        # unreachable
+        return {}
+
+    def get_tag_pairs(self, meta) -> Generator:
+        if self == Container.FLAC:
+            return self._tag_flac(meta)
+        elif self == Container.MP3:
+            return self._tag_mp3(meta)
+        elif self == Container.AAC:
+            return self._tag_aac(meta)
+        # unreachable
+        yield
+
+
+    def _tag_flac(self, meta):
+        for k, v in FLAC_KEY.items():
+            tag = getattr(meta, k)
+            if tag:
+                if k in {
+                    "tracknumber",
+                    "discnumber",
+                    "tracktotal",
+                    "disctotal",
+                }:
+                    tag = f"{int(tag):02}"
+
+                yield (v, str(tag))
+
+
+    def _tag_mp3(self, meta):
+        for k, v in MP3_KEY.items():
+            if k == "tracknumber":
+                text = f"{meta.tracknumber}/{meta.tracktotal}"
+            elif k == "discnumber":
+                text = f"{meta.discnumber}/{meta.disctotal}"
+            else:
+                text = getattr(self, k)
+
+            if text is not None and v is not None:
+                yield (v.__name__, v(encoding=3, text=text))
+
+    def _tag_aac(self, meta):
+        for k, v in MP4_KEY.items():
+            if k == "tracknumber":
+                text = [(meta.tracknumber, meta.tracktotal)]
+            elif k == "discnumber":
+                text = [(meta.discnumber, meta.disctotal)]
+            else:
+                text = getattr(self, k)
+
+            if v is not None and text is not None:
+                yield (v, text)
+
+
+@dataclass(slots=True)
+class Tagger:
+    meta: TrackMetadata
+
+    def tag(self, path: str, embed_cover: bool, covers: Cover):
+        ext = path.split(".")[-1].upper()
+        if ext == "flac":
+            container = Container.FLAC
+        elif ext == "m4a":
+            container = Container.AAC
+        elif ext == "mp3":
+            container = Container.MP3
+        else:
+            raise Exception(f"Invalid extension {ext}")
+
+        audio = container.get_mutagen_class(path)
+        tags = container.get_tag_pairs(self.meta)
+        for k, v in tags:
+            audio[k] = v
+
+        c = 
diff --git a/src/tidal_client.py b/streamrip/tidal_client.py
similarity index 100%
rename from src/tidal_client.py
rename to streamrip/tidal_client.py
diff --git a/streamrip/track.py b/streamrip/track.py
new file mode 100644
index 0000000..f6f50ed
--- /dev/null
+++ b/streamrip/track.py
@@ -0,0 +1,83 @@
+import os
+from dataclasses import dataclass
+
+from . import converter
+from .client import Client
+from .config import Config
+from .downloadable import Downloadable
+from .media import Media, Pending
+from .metadata import AlbumMetadata, TrackMetadata
+from .progress import get_progress_bar
+
+
+@dataclass(slots=True)
+class Track(Media):
+    meta: TrackMetadata
+    downloadable: Downloadable
+    config: Config
+    folder: str
+    download_path: str = ""
+
+    async def preprocess(self):
+        folder = self._get_folder(self.folder)
+        os.makedirs(folder, exist_ok=True)
+        # Run in background while track downloads?
+        # Don't download again if part of album
+        await self._download_cover()
+
+    async def download(self):
+        async with get_progress_bar(self.config, self.downloadable.size()) as bar:
+            await self.downloadable.download(
+                self.download_path, lambda x: bar.update(x)
+            )
+
+    async def postprocess(self):
+        await self._tag()
+        await self._convert()
+
+    async def _tag(self):
+        t = Tagger(self.meta)
+        t.tag(self.download_path)
+
+    async def _convert(self):
+        CONV_CLASS = {
+            "FLAC": converter.FLAC,
+            "ALAC": converter.ALAC,
+            "MP3": converter.LAME,
+            "OPUS": converter.OPUS,
+            "OGG": converter.Vorbis,
+            "VORBIS": converter.Vorbis,
+            "AAC": converter.AAC,
+            "M4A": converter.AAC,
+        }
+        c = self.config.session.conversion
+        codec = c.codec
+        engine = CONV_CLASS[codec.upper()](
+            filename=self.download_path,
+            sampling_rate=c.sampling_rate,
+            remove_source=True,  # always going to delete the old file
+        )
+        engine.convert()
+        self.download_path = engine.final_fn  # because the extension changed
+
+    def _get_folder(self, parent: str) -> str:
+        formatter = self.config.session.filepaths.track_format
+        track_path = self.meta.format_track_path(formatter)
+        return os.path.join(self.folder, track_path)
+
+
+@dataclass(slots=True)
+class PendingTrack(Pending):
+    id: str
+    album: AlbumMetadata
+    client: Client
+    config: Config
+    folder: str
+
+    async def resolve(self) -> Track:
+        resp = await self.client.get_metadata({"id": self.id}, "track")
+        meta = TrackMetadata.from_resp(self.album, self.client.source, resp)
+        quality = getattr(self.config.session, self.client.source).quality
+        assert isinstance(quality, int)
+        downloadable = await self.client.get_downloadable(self.id, quality)
+        return Track(meta, downloadable, self.config, self.folder)
diff --git a/src/user_paths.py b/streamrip/user_paths.py
similarity index 100%
rename from src/user_paths.py
rename to streamrip/user_paths.py
diff --git a/streamrip/utils.py b/streamrip/utils.py
deleted file mode 100644
index c6d3dda..0000000
--- a/streamrip/utils.py
+++ /dev/null
@@ -1,476 +0,0 @@
-"""Miscellaneous utility functions."""
-
-from __future__ import annotations
-
-import base64
-import itertools
-import logging
-import os
-import shutil
-import subprocess
-import tempfile
-from string import Formatter
-from typing import Dict, Hashable, Iterator, List, Optional, Tuple, Union
-
-import requests
-from click import secho, style
-from pathvalidate import sanitize_filename
-from requests.packages import urllib3
-from tqdm import tqdm
-
-from .constants import COVER_SIZES, MAX_FILES_OPEN, TIDAL_COVER_URL
-from .exceptions import FfmpegError, InvalidQuality, InvalidSourceError
-
-urllib3.disable_warnings()
-logger = logging.getLogger("streamrip")
-
-
-def concat_audio_files(paths: List[str], out: str, ext: str):
-    logger.debug("Concatenating %d files", len(paths))
-    if len(paths) == 1:
-        shutil.move(paths[0], out)
-        return
-
-    it = iter(paths)
-    num_batches = len(paths) // MAX_FILES_OPEN + (
-        1 if len(paths) % MAX_FILES_OPEN != 0 else 0
-    )
-    logger.debug(
-        "Using %d batches with max file limit of %d", num_batches, MAX_FILES_OPEN
-    )
-    tempdir = tempfile.gettempdir()
-    outpaths = [
-        os.path.join(
-            tempdir, f"__streamrip_ffmpeg_{hash(paths[i*MAX_FILES_OPEN])}.{ext}"
-        )
-        for i in range(num_batches)
-    ]
-
-    for p in outpaths:
-        try:
-            os.remove(p)  # in case of failure
-        except FileNotFoundError:
-            pass
-
-    logger.debug("Batch outfiles: %s", outpaths)
-
-    for i in range(num_batches):
-        logger.debug("Batch %d", i)
-        proc = subprocess.run(
-            (
-                "ffmpeg",
-                "-i",
-                f"concat:{'|'.join(itertools.islice(it, MAX_FILES_OPEN))}",
-                "-acodec",
-                "copy",
-                "-loglevel",
-                "panic",
-                outpaths[i],
-            ),
-            # capture_output=True,
-        )
-        if proc.returncode != 0:
-            raise FfmpegError(proc.stderr)
-
-    concat_audio_files(outpaths, out, ext)
-
-
-def clean_filename(fn: str, restrict=False) -> str:
-    path = sanitize_filename(fn)
-    if restrict:
-        from string import printable
-
-        allowed_chars = set(printable)
-        path = "".join(c for c in path if c in allowed_chars)
-
-    return path
-
-
-__QUALITY_MAP: Dict[str, Dict[int, Union[int, str, Tuple[int, str]]]] = {
-    "qobuz": {
-        1: 5,
-        2: 6,
-        3: 7,
-        4: 27,
-    },
-    "deezer": {
-        0: (9, "MP3_128"),
-        1: (3, "MP3_320"),
-        2: (1, "FLAC"),
-    },
-    "tidal": {
-        0: "LOW",  # AAC
-        1: "HIGH",  # AAC
-        2: "LOSSLESS",  # CD Quality
-        3: "HI_RES",  # MQA
-    },
-    "deezloader": {
-        0: 128,
-        1: 320,
-        2: 1411,
-    },
-}
-
-
-def get_quality(quality_id: int, source: str) -> Union[str, int, Tuple[int, str]]:
-    """Get the source-specific quality id.
-
-    :param quality_id: the universal quality id (0, 1, 2, 4)
-    :type quality_id: int
-    :param source: qobuz, tidal, or deezer
-    :type source: str
-    :rtype: Union[str, int]
-    """
-    return __QUALITY_MAP[source][quality_id]
-
-
-def get_quality_id(bit_depth: Optional[int], sampling_rate: Optional[int]):
-    """Get the universal quality id from bit depth and sampling rate.
-
-    :param bit_depth:
-    :type bit_depth: Optional[int]
-    :param sampling_rate:
-    :type sampling_rate: Optional[int]
-    """
-    # XXX: Should `0` quality be supported?
-    if bit_depth is None or sampling_rate is None:  # is lossy
-        return 1
-
-    if bit_depth == 16:
-        return 2
-
-    if bit_depth == 24:
-        if sampling_rate <= 96:
-            return 3
-
-        return 4
-
-
-def get_stats_from_quality(
-    quality_id: int,
-) -> Tuple[Optional[int], Optional[int]]:
-    """Get bit depth and sampling rate based on the quality id.
-
-    :param quality_id:
-    :type quality_id: int
-    :rtype: Tuple[Optional[int], Optional[int]]
-    """
-    if quality_id <= 1:
-        return (None, None)
-    elif quality_id == 2:
-        return (16, 44100)
-    elif quality_id == 3:
-        return (24, 96000)
-    elif quality_id == 4:
-        return (24, 192000)
-    else:
-        raise InvalidQuality(quality_id)
-
-
-def clean_format(formatter: str, format_info, restrict: bool = False):
-    """Format track or folder names sanitizing every formatter key.
-
-    :param formatter:
-    :type formatter: str
-    :param kwargs:
-    """
-    fmt_keys = filter(None, (i[1] for i in Formatter().parse(formatter)))
-    # fmt_keys = (i[1] for i in Formatter().parse(formatter) if i[1] is not None)
-
-    logger.debug("Formatter keys: %s", formatter)
-
-    clean_dict = {}
-    for key in fmt_keys:
-        logger.debug(repr(key))
-        logger.debug(format_info.get(key))
-        if isinstance(format_info.get(key), (str, float)):
-            logger.debug("1")
-            clean_dict[key] = clean_filename(str(format_info[key]), restrict=restrict)
-        elif key == "explicit":
-            logger.debug("3")
-            clean_dict[key] = " (Explicit) " if format_info.get(key, False) else ""
-        elif isinstance(format_info.get(key), int):  # track/discnumber
-            logger.debug("2")
-            clean_dict[key] = f"{format_info[key]:02}"
-        else:
-            clean_dict[key] = "Unknown"
-
-    return formatter.format(**clean_dict)
-
-
-def tidal_cover_url(uuid, size):
-    """Generate a tidal cover url.
-
-    :param uuid:
-    :param size:
-    """
-    possibles = (80, 160, 320, 640, 1280)
-    assert size in possibles, f"size must be in {possibles}"
-
-    # A common occurance is a valid size but no uuid
-    if not uuid:
-        return None
-    return TIDAL_COVER_URL.format(uuid=uuid.replace("-", "/"), height=size, width=size)
-
-
-def decrypt_mqa_file(in_path, out_path, encryption_key):
-    """Decrypt an MQA file.
-
-    :param in_path:
-    :param out_path:
-    :param encryption_key:
-    """
-    try:
-        from Crypto.Cipher import AES
-        from Crypto.Util import Counter
-    except (ImportError, ModuleNotFoundError):
-        secho(
-            "To download this item in MQA, you need to run ",
-            fg="yellow",
-            nl=False,
-        )
-        secho("pip3 install pycryptodome --upgrade", fg="blue", nl=False)
-        secho(".")
-        exit()
-
-    # Do not change this
-    master_key = "UIlTTEMmmLfGowo/UC60x2H45W6MdGgTRfo/umg4754="
-
-    # Decode the base64 strings to ascii strings
-    master_key = base64.b64decode(master_key)
-    security_token = base64.b64decode(encryption_key)
-
-    # Get the IV from the first 16 bytes of the securityToken
-    iv = security_token[:16]
-    encrypted_st = security_token[16:]
-
-    # Initialize decryptor
-    decryptor = AES.new(master_key, AES.MODE_CBC, iv)
-
-    # Decrypt the security token
-    decrypted_st = decryptor.decrypt(encrypted_st)
-
-    # Get the audio stream decryption key and nonce from the decrypted security token
-    key = decrypted_st[:16]
-    nonce = decrypted_st[16:24]
-
-    counter = Counter.new(64, prefix=nonce, initial_value=0)
-    decryptor = AES.new(key, AES.MODE_CTR, counter=counter)
-
-    with open(in_path, "rb") as enc_file:
-        dec_bytes = decryptor.decrypt(enc_file.read())
-        with open(out_path, "wb") as dec_file:
-            dec_file.write(dec_bytes)
-
-
-def ext(quality: int, source: str):
-    """Get the extension of an audio file.
-
-    :param quality:
-    :type quality: int
-    :param source:
-    :type source: str
-    """
-    if quality <= 1:
-        if source == "tidal":
-            return ".m4a"
-        else:
-            return ".mp3"
-    else:
-        return ".flac"
-
-
-def gen_threadsafe_session(
-    headers: dict = None, pool_connections: int = 100, pool_maxsize: int = 100
-) -> requests.Session:
-    """Create a new Requests session with a large poolsize.
-
-    :param headers:
-    :type headers: dict
-    :param pool_connections:
-    :type pool_connections: int
-    :param pool_maxsize:
-    :type pool_maxsize: int
-    :rtype: requests.Session
-    """
-    if headers is None:
-        headers = {}
-
-    session = requests.Session()
-    adapter = requests.adapters.HTTPAdapter(pool_connections=100, pool_maxsize=100)
-    session.mount("https://", adapter)
-    session.headers.update(headers)
-    return session
-
-
-def decho(message, fg=None):
-    """Debug echo the message.
-
-    :param message:
-    :param fg: ANSI color with which to display the message on the
-    screen
-    """
-    secho(message, fg=fg)
-    logger.debug(message)
-
-
-def get_container(quality: int, source: str) -> str:
-    """Get the file container given the quality.
-
-    `container` can also be the the codec; both work.
-
-    :param quality: quality id
-    :type quality: int
-    :param source:
-    :type source: str
-    :rtype: str
-    """
-    if quality >= 2:
-        return "FLAC"
-
-    if source == "tidal":
-        return "AAC"
-
-    return "MP3"
-
-
-def get_cover_urls(resp: dict, source: str) -> Optional[dict]:
-    """Parse a response dict containing cover info according to the source.
-
-    :param resp:
-    :type resp: dict
-    :param source:
-    :type source: str
-    :rtype: dict
-    """
-
-    if source == "qobuz":
-        cover_urls = resp["image"]
-        cover_urls["original"] = "org".join(cover_urls["large"].rsplit("600", 1))
-        return cover_urls
-
-    if source == "tidal":
-        uuid = resp["cover"]
-        if not uuid:
-            return None
-        return {
-            sk: tidal_cover_url(uuid, size)
-            for sk, size in zip(COVER_SIZES, (160, 320, 640, 1280))
-        }
-
-    if source == "deezer":
-        resp_keys = ("cover", "cover_medium", "cover_large", "cover_xl")
-        resp_keys_fallback = (
-            "picture",
-            "picture_medium",
-            "picture_large",
-            "picture_xl",
-        )
-        cover_urls = {
-            sk: resp.get(rk, resp.get(rkf))  # size key, resp key, resp key fallback
-            for sk, rk, rkf in zip(
-                COVER_SIZES,
-                resp_keys,
-                resp_keys_fallback,
-            )
-        }
-
-        if cover_urls["large"] is None and resp.get("cover_big") is not None:
-            cover_urls["large"] = resp["cover_big"]
-
-        return cover_urls
-
-    if source == "soundcloud":
-        cover_url = (resp["artwork_url"] or resp["user"].get("avatar_url")).replace(
-            "large", "t500x500"
-        )
-
-        cover_urls = {"large": cover_url}
-
-        return cover_urls
-
-    raise InvalidSourceError(source)
-
-
-def downsize_image(filepath: str, width: int, height: int):
-    """Downsize an image.
-
-    If either the width or the height is greater than the image's width or
-    height, that dimension will not be changed.
-
-    :param filepath:
-    :type filepath: str
-    :param width:
-    :type width: int
-    :param height:
-    :type height: int
-    :raises: ValueError
-    """
-    if width == -1 or height == -1:
-        return
-
-    from PIL import Image, UnidentifiedImageError
-
-    try:
-        image = Image.open(filepath)
-    except UnidentifiedImageError:
-        secho("Cover art not found, skipping downsize.", fg="red")
-        return
-
-    width = min(width, image.width)
-    height = min(height, image.height)
-
-    resized_image = image.resize((width, height))
-    resized_image.save(filepath)
-
-
-TQDM_THEMES = {
-    "plain": None,
-    "dainty": (
-        "{desc} |{bar}| "
-        + style("{remaining}", fg="magenta")
-        + " left at "
-        + style("{rate_fmt}{postfix} ", fg="cyan", bold=True)
-    ),
-}
-
-TQDM_DEFAULT_THEME = "dainty"
-
-TQDM_BAR_FORMAT = TQDM_THEMES["dainty"]
-
-
-def set_progress_bar_theme(theme: str):
-    """Set the theme of the tqdm progress bar.
-
-    :param theme:
-    :type theme: str
-    """
-    global TQDM_BAR_FORMAT
-    TQDM_BAR_FORMAT = TQDM_THEMES[theme]
-
-
-def tqdm_stream(iterator, desc: Optional[str] = None) -> Iterator[bytes]:
-    """Return a tqdm bar with presets appropriate for downloading large files.
-
-    :param iterator:
-    :type iterator: DownloadStream
-    :param desc: Description to add for the progress bar
-    :type desc: Optional[str]
-    :rtype: Iterator
-    """
-    with get_tqdm_bar(len(iterator), desc=desc) as bar:
-        for chunk in iterator:
-            bar.update(len(chunk))
-            yield chunk
-
-
-def get_tqdm_bar(total, desc: Optional[str] = None, unit="B"):
-    return tqdm(
-        total=total,
-        unit=unit,
-        unit_scale=True,
-        unit_divisor=1024,
-        desc=desc,
-        dynamic_ncols=True,
-        bar_format=TQDM_BAR_FORMAT,
-    )
diff --git a/src/validation_regexps.py b/streamrip/validation_regexps.py
similarity index 100%
rename from src/validation_regexps.py
rename to streamrip/validation_regexps.py
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000..f23a461
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,183 @@
+import shutil
+
+import pytest
+
+from streamrip.config import *
+
+SAMPLE_CONFIG = "tests/test_config.toml"
+
+
+# Define a fixture to create a sample ConfigData instance for testing
+@pytest.fixture
+def sample_config_data() -> ConfigData:
+    # Create a sample ConfigData instance here
+    # You can customize this to your specific needs for testing
+    with open(SAMPLE_CONFIG) as f:
+        config_data = ConfigData.from_toml(f.read())
+    return config_data
+
+
+# Define a fixture to create a sample Config instance for testing
+@pytest.fixture
+def sample_config() -> Config:
+    # Create a sample Config instance here
+    # You can customize this to your specific needs for testing
+    config = Config(SAMPLE_CONFIG)
+    return config
+
+
+def test_sample_config_data_properties(sample_config_data):
+    # Test the properties of ConfigData
+    assert sample_config_data.modified is False  # Ensure initial state is not modified
+
+
+def test_sample_config_data_modification(sample_config_data):
+    # Test modifying ConfigData and checking modified property
+    sample_config_data.set_modified()
+    assert sample_config_data._modified is True
+
+
+def test_sample_config_data_fields(sample_config_data):
+    test_config = ConfigData(
+        toml=None,  # type: ignore
+        downloads=DownloadsConfig(
+            folder="test_folder",
+            source_subdirectories=False,
+            concurrency=True,
+            max_connections=3,
+            requests_per_minute=-1,
+        ),
+        qobuz=QobuzConfig(
+            use_auth_token=False,
+            email_or_userid="test@gmail.com",
+            password_or_token="test_pwd",
+            app_id="12345",
+            quality=3,
+            download_booklets=True,
+            secrets=["secret1", "secret2"],
+        ),
+        tidal=TidalConfig(
+            user_id="userid",
+            country_code="countrycode",
+            access_token="accesstoken",
+            refresh_token="refreshtoken",
+            token_expiry="tokenexpiry",
+            quality=3,
+            download_videos=True,
+        ),
+        deezer=DeezerConfig(
+            arl="testarl", quality=2, use_deezloader=True, deezloader_warnings=True
+        ),
+        soundcloud=SoundcloudConfig(
+            client_id="clientid", app_version="appverison", quality=0
+        ),
+        youtube=YoutubeConfig(
+            video_downloads_folder="videodownloadsfolder",
+            quality=0,
+            download_videos=False,
+        ),
+        lastfm=LastFmConfig(source="qobuz", fallback_source="deezer"),
+        filepaths=FilepathsConfig(
+            add_singles_to_folder=False,
+            folder_format="{albumartist} - {title} ({year}) [{container}] [{bit_depth}B-{sampling_rate}kHz]",
+            track_format="{tracknumber}. {artist} - {title}{explicit}",
+            restrict_characters=False,
+            truncate=True,
+        ),
+        artwork=ArtworkConfig(
+            embed=True, size="large", max_width=-1, max_height=-1, keep_hires_cover=True
+        ),
+        metadata=MetadataConfig(
+            set_playlist_to_album=True, new_playlist_tracknumbers=True, exclude=[]
+        ),
+        qobuz_filters=QobuzDiscographyFilterConfig(
+            extras=False,
+            repeats=False,
+            non_albums=False,
+            features=False,
+            non_studio_albums=False,
+            non_remaster=False,
+        ),
+        theme=ThemeConfig(progress_bar="dainty"),
+        database=DatabaseConfig(
+            downloads_enabled=True,
+            downloads_path="downloadspath",
+            failed_downloads_enabled=True,
+            failed_downloads_path="faileddownloadspath",
+        ),
+        conversion=ConversionConfig(
+            enabled=False,
+            codec="ALAC",
+            sampling_rate=48000,
+            bit_depth=24,
+            lossy_bitrate=320,
+        ),
+        _modified=False,
+    )
+    assert sample_config_data.downloads == test_config.downloads
+    assert sample_config_data.qobuz == test_config.qobuz
+    assert sample_config_data.tidal == test_config.tidal
+    assert sample_config_data.deezer == test_config.deezer
+    assert sample_config_data.soundcloud == test_config.soundcloud
+    assert sample_config_data.youtube == test_config.youtube
+    assert sample_config_data.lastfm == test_config.lastfm
+    assert sample_config_data.artwork == test_config.artwork
+    assert sample_config_data.filepaths == test_config.filepaths
+    assert sample_config_data.metadata == test_config.metadata
+    assert sample_config_data.qobuz_filters == test_config.qobuz_filters
+    assert sample_config_data.theme == test_config.theme
+    assert sample_config_data.database == test_config.database
+    assert sample_config_data.conversion == test_config.conversion
+
+
+def test_config_save_file_called_on_del(sample_config, mocker):
+    sample_config.file.set_modified()
+    mockf = mocker.Mock()
+
+    sample_config.save_file = mockf
+    sample_config.__del__()
+    mockf.assert_called_once()
+
+
+def test_config_update_on_save():
+    tmp_config_path = "tests/config2.toml"
+    shutil.copy(SAMPLE_CONFIG, tmp_config_path)
+    conf = Config(tmp_config_path)
+    conf.file.downloads.folder = "new_folder"
+    conf.file.set_modified()
+    conf.save_file()
+    conf2 = Config(tmp_config_path)
+    os.remove(tmp_config_path)
+
+    assert conf2.session.downloads.folder == "new_folder"
+
+
+def test_config_update_on_del():
+    tmp_config_path = "tests/config2.toml"
+    shutil.copy(SAMPLE_CONFIG, tmp_config_path)
+    conf = Config(tmp_config_path)
+    conf.file.downloads.folder = "new_folder"
+    conf.file.set_modified()
+    del conf
+    conf2 = Config(tmp_config_path)
+    os.remove(tmp_config_path)
+
+    assert conf2.session.downloads.folder == "new_folder"
+
+
+def test_config_dont_update_without_set_modified():
+    tmp_config_path = "tests/config2.toml"
+    shutil.copy(SAMPLE_CONFIG, tmp_config_path)
+    conf = Config(tmp_config_path)
+    conf.file.downloads.folder = "new_folder"
+    del conf
+    conf2 = Config(tmp_config_path)
+    os.remove(tmp_config_path)
+
+    assert conf2.session.downloads.folder == "test_folder"
+
+
+# Other tests for the Config class can be added as needed
+
+if __name__ == "__main__":
+    pytest.main()
diff --git a/tests/test_config.toml b/tests/test_config.toml
new file mode 100644
index 0000000..22640bc
--- /dev/null
+++ b/tests/test_config.toml
@@ -0,0 +1,178 @@
+[downloads]
+# Folder where tracks are downloaded to
+folder = "test_folder"
+# Put Qobuz albums in a 'Qobuz' folder, Tidal albums in 'Tidal' etc.
+source_subdirectories = false
+
+# Download (and convert) tracks all at once, instead of sequentially. 
+# If you are converting the tracks, or have fast internet, this will 
+# substantially improve processing speed.
+concurrency = true
+# The maximum number of tracks to download at once
+# If you have very fast internet, you will benefit from a higher value,
+# A value that is too high for your bandwidth may cause slowdowns
+max_connections = 3
+# Max number of API requests to handle per minute
+# Set to -1 for no limit
+requests_per_minute = -1
+
+[qobuz]
+# 1: 320kbps MP3, 2: 16/44.1, 3: 24/<=96, 4: 24/>=96
+quality = 3
+# This will download booklet pdfs that are included with some albums
+download_booklets = true
+
+# Authenticate to Qobuz using auth token? Value can be true/false only
+use_auth_token = false
+# Enter your userid if the above use_auth_token is set to true, else enter your email
+email_or_userid = "test@gmail.com"
+# Enter your auth token if the above use_auth_token is set to true, else enter the md5 hash of your plaintext password
+password_or_token = "test_pwd"
+# Do not change
+app_id = "12345"
+# Do not change
+secrets = ['secret1', 'secret2']
+
+[tidal]
+# 0: 256kbps AAC, 1: 320kbps AAC, 2: 16/44.1 "HiFi" FLAC, 3: 24/44.1 "MQA" FLAC
+quality = 3
+# This will download videos included in Video Albums.
+download_videos = true
+
+# Do not change any of the fields below
+user_id = "userid"
+country_code = "countrycode"
+access_token = "accesstoken"
+refresh_token = "refreshtoken"
+# Tokens last 1 week after refresh. This is the Unix timestamp of the expiration
+# time. If you haven't used streamrip in more than a week, you may have to log
+# in again using `rip config --tidal`
+token_expiry = "tokenexpiry"
+
+[deezer]
+# 0, 1, or 2
+# This only applies to paid Deezer subscriptions. Those using deezloader
+# are automatically limited to quality = 1
+quality = 2
+# An authentication cookie that allows streamrip to use your Deezer account
+# See https://github.com/nathom/streamrip/wiki/Finding-Your-Deezer-ARL-Cookie
+# for instructions on how to find this
+arl = "testarl"
+# This allows for free 320kbps MP3 downloads from Deezer
+# If an arl is provided, deezloader is never used
+use_deezloader = true
+# This warns you when the paid deezer account is not logged in and rip falls
+# back to deezloader, which is unreliable
+deezloader_warnings = true
+
+[soundcloud]
+# Only 0 is available for now
+quality = 0
+# This changes periodically, so it needs to be updated
+client_id = "clientid"
+app_version = "appverison"
+
+[youtube]
+# Only 0 is available for now
+quality = 0
+# Download the video along with the audio
+download_videos = false
+# The path to download the videos to
+video_downloads_folder = "videodownloadsfolder"
+
+# This stores a list of item IDs so that repeats are not downloaded.
+[database]
+downloads_enabled = true
+downloads_path = "downloadspath"
+
+# If a download fails, the item ID is stored here. Then, `rip repair` can be
+# called to retry the downloads
+failed_downloads_enabled = true
+failed_downloads_path = "faileddownloadspath"
+
+# Convert tracks to a codec after downloading them.
+[conversion]
+enabled = false
+# FLAC, ALAC, OPUS, MP3, VORBIS, or AAC
+codec = "ALAC"
+# In Hz. Tracks are downsampled if their sampling rate is greater than this. 
+# Value of 48000 is recommended to maximize quality and minimize space
+sampling_rate = 48000
+# Only 16 and 24 are available. It is only applied when the bit depth is higher
+# than this value.
+bit_depth = 24
+# Only applicable for lossy codecs
+lossy_bitrate = 320
+
+# Filter a Qobuz artist's discography. Set to 'true' to turn on a filter.
+[qobuz_filters]
+# Remove Collectors Editions, live recordings, etc.
+extras = false
+# Picks the highest quality out of albums with identical titles.
+repeats = false
+# Remove EPs and Singles
+non_albums = false
+# Remove albums whose artist is not the one requested
+features = false
+# Skip non studio albums
+non_studio_albums = false
+# Only download remastered albums
+non_remaster = false
+
+[artwork]
+# Write the image to the audio file
+embed = true
+# The size of the artwork to embed. Options: thumbnail, small, large, original.
+# "original" images can be up to 30MB, and may fail embedding. 
+# Using "large" is recommended.
+size = "large"
+# Both of these options limit the size of the embedded artwork. If their values
+# are larger than the actual dimensions of the image, they will be ignored.
+# If either value is -1, the image is left untouched.
+max_width = -1
+max_height = -1
+# Save the cover image at the highest quality as a seperate jpg file
+keep_hires_cover = true
+
+[metadata]
+# Sets the value of the 'ALBUM' field in the metadata to the playlist's name. 
+# This is useful if your music library software organizes tracks based on album name.
+set_playlist_to_album = true
+# Replaces the original track's tracknumber with it's position in the playlist
+new_playlist_tracknumbers = true
+# The following metadata tags won't be applied
+# See https://github.com/nathom/streamrip/wiki/Metadata-Tag-Names for more info
+exclude = []
+
+# Changes the folder and file names generated by streamrip.
+[filepaths]
+# Create folders for single tracks within the downloads directory using the folder_format
+# template
+add_singles_to_folder = false
+# Available keys: "albumartist", "title", "year", "bit_depth", "sampling_rate",
+# "container", "id", and "albumcomposer"
+folder_format = "{albumartist} - {title} ({year}) [{container}] [{bit_depth}B-{sampling_rate}kHz]"
+# Available keys: "tracknumber", "artist", "albumartist", "composer", "title",
+# and "albumcomposer"
+track_format = "{tracknumber}. {artist} - {title}{explicit}"
+# Only allow printable ASCII characters in filenames.
+restrict_characters = false
+# Truncate the filename if it is greater than 120 characters
+# Setting this to false may cause downloads to fail on some systems
+truncate = true
+
+# Last.fm playlists are downloaded by searching for the titles of the tracks
+[lastfm]
+# The source on which to search for the tracks.
+source = "qobuz"
+# If no results were found with the primary source, the item is searched for 
+# on this one.
+fallback_source = "deezer"
+
+[theme]
+# Options: "dainty" or "plain"
+progress_bar = "dainty"
+
+[misc]
+# Metadata to identify this config file. Do not change.
+version = "2.0"
diff --git a/tests/test_download.py b/tests/test_download.py
deleted file mode 100644
index becee0f..0000000
--- a/tests/test_download.py
+++ /dev/null
@@ -1,20 +0,0 @@
-import os
-import time
-from pprint import pprint
-
-from streamrip.downloadtools import DownloadPool
-
-
-def test_downloadpool(tmpdir):
-    start = time.perf_counter()
-    with DownloadPool(
-        (f"https://pokeapi.co/api/v2/pokemon/{number}" for number in range(1, 151)),
-        tempdir=tmpdir,
-    ) as pool:
-        pool.download()
-        assert len(os.listdir(tmpdir)) == 151
-
-    # the tempfiles should be removed at this point
-    assert len(os.listdir(tmpdir)) == 0
-
-    print(f"Finished in {time.perf_counter() - start}s")
diff --git a/tests/tests.py b/tests/tests.py
deleted file mode 100644
index 5954254..0000000
--- a/tests/tests.py
+++ /dev/null
@@ -1,119 +0,0 @@
-import os
-import shutil
-import subprocess
-
-from click import echo, secho
-
-test_urls = {
-    "qobuz": "https://www.qobuz.com/us-en/album/blackest-blue-morcheeba/h4nngz0wgqesc",
-    "tidal": "https://tidal.com/browse/album/183284294",
-    "deezer": "https://www.deezer.com/us/album/225281222",
-    "soundcloud": "https://soundcloud.com/dj-khaled/sets/khaled-khaled",
-}
-
-
-def reset_config():
-    global cfg_path
-    global new_cfg_path
-
-    p = subprocess.Popen(
-        ["rip", "config", "-p"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
-    )
-    out, err = p.communicate()
-    cfg_path = out.decode("utf-8").strip()
-    # cfg_path = re.search(
-    #     r"(/[\w\d\s]+(?:/[\w\d \.]+)*)", out.decode("utf-8")
-    # ).group(1)
-    new_cfg_path = f"{cfg_path}.tmp"
-    shutil.copy(cfg_path, new_cfg_path)
-    subprocess.Popen(["rip", "config", "--update"])
-
-
-def restore_config():
-    global cfg_path
-    global new_cfg_path
-
-    os.remove(cfg_path)
-    shutil.move(new_cfg_path, cfg_path)
-
-
-def download_albums():
-    rip_url = ["rip", "-nd", "-u"]
-    procs = []
-    for url in test_urls.values():
-        procs.append(subprocess.run([*rip_url, url]))
-
-    for p in procs:
-        echo(p)
-
-
-def check_album_dl_success(folder, correct):
-    if set(os.listdir(folder)) != set(correct):
-        secho(f"Check for {folder} failed!", fg="red")
-    else:
-        secho(f"Check for {folder} succeeded!", fg="green")
-
-
-def main():
-    reset_config()
-    download_albums()
-    check_album_dl_success(
-        "/Users/nathan/StreamripDownloads/Morcheeba - Blackest Blue (2021) [FLAC] [24B-44.1kHz]",
-        {
-            "04. Morcheeba - Say It's Over.flac",
-            "01. Morcheeba - Cut My Heart Out.flac",
-            "02. Morcheeba - Killed Our Love.flac",
-            "07. Morcheeba - Namaste.flac",
-            "03. Morcheeba - Sounds Of Blue.flac",
-            "10. Morcheeba - The Edge Of The World.flac",
-            "08. Morcheeba - The Moon.flac",
-            "09. Morcheeba - Falling Skies.flac",
-            "cover.jpg",
-            "05. Morcheeba - Sulphur Soul.flac",
-            "06. Morcheeba - Oh Oh Yeah.flac",
-        },
-    )
-
-    check_album_dl_success(
-        "/Users/nathan/StreamripDownloads/KHALED KHALED",
-        {
-            "05. DJ Khaled - I DID IT (feat. Post Malone, Megan Thee Stallion, Lil Baby & DaBaby).mp3",
-            "09. DJ Khaled - THIS IS MY YEAR (feat. A Boogie Wit Da Hoodie, Big Sean, Rick Ross & Puff Daddy).mp3",
-            "01. DJ Khaled - THANKFUL (feat. Lil Wayne & Jeremih).mp3",
-            "12. DJ Khaled - I CAN HAVE IT ALL (feat. Bryson Tiller, H.E.R. & Meek Mill).mp3",
-            "02. DJ Khaled - EVERY CHANCE I GET (feat. Lil Baby & Lil Durk).mp3",
-            "08. DJ Khaled - POPSTAR (feat. Drake).mp3",
-            "13. DJ Khaled - GREECE (feat. Drake).mp3",
-            "04. DJ Khaled - WE GOING CRAZY (feat. H.E.R. & Migos).mp3",
-            "10. DJ Khaled - SORRY NOT SORRY (Harmonies by The Hive) [feat. Nas, JAY-Z & James Fauntleroy].mp3",
-            "03. DJ Khaled - BIG PAPER (feat. Cardi B).mp3",
-            "14. DJ Khaled - WHERE YOU COME FROM (feat. Buju Banton, Capleton & Bounty Killer).mp3",
-            "07. DJ Khaled - BODY IN MOTION (feat. Bryson Tiller, Lil Baby & Roddy Ricch).mp3",
-            "06. DJ Khaled - LET IT GO (feat. Justin Bieber & 21 Savage).mp3",
-            "11. DJ Khaled - JUST BE (feat. Justin Timberlake).mp3",
-        },
-    )
-
-    check_album_dl_success(
-        "/Users/nathan/StreamripDownloads/Paul Weller - Fat Pop (2021) [FLAC] [24B-44.1kHz]",
-        {
-            "01. Paul Weller - Cosmic Fringes.flac",
-            "11. Paul Weller - In Better Times.flac",
-            "05. Paul Weller - Glad Times.flac",
-            "08. Paul Weller - That Pleasure.flac",
-            "04. Paul Weller - Shades Of Blue.flac",
-            "12. Paul Weller - Still Glides The Stream.flac",
-            "03. Paul Weller - Fat Pop.flac",
-            "cover.jpg",
-            "02. Paul Weller - True.flac",
-            "09. Paul Weller - Failed.flac",
-            "06. Paul Weller - Cobweb  Connections.flac",
-            "10. Paul Weller - Moving Canvas.flac",
-            "07. Paul Weller - Testify.flac",
-        },
-    )
-    restore_config()
-
-
-if __name__ == "__main__":
-    main()