diff --git a/streamrip/bases.py b/streamrip/bases.py
index b7d0f3a..f532985 100644
--- a/streamrip/bases.py
+++ b/streamrip/bases.py
@@ -1,4 +1,6 @@
-"""These are the lower level classes that are handled by Album, Playlist,
+"""Bases that handle parsing and downloading media.
+
+These are the lower level classes that are handled by Album, Playlist,
 and the other objects. They can also be downloaded individually, for example,
 as a single track.
 """
@@ -103,7 +105,6 @@ class Track:
 
     def load_meta(self):
         """Send a request to the client to get metadata for this Track."""
-
         assert self.id is not None, "id must be set before loading metadata"
 
         self.resp = self.client.get(self.id, media_type="track")
@@ -128,7 +129,8 @@ class Track:
             self.cover_url = None
 
     def _prepare_download(self, **kwargs):
-        """This function does preprocessing to prepare for downloading tracks.
+        """Do preprocessing before downloading items.
+
         It creates the directories, downloads cover art, and (optionally)
         downloads booklets.
 
@@ -269,7 +271,7 @@ class Track:
         )
 
     def move(self, path: str):
-        """Moves the Track and sets self.path to the new path.
+        """Move the Track and set self.path to the new path.
 
         :param path:
         :type path: str
@@ -279,8 +281,10 @@ class Track:
         self.path = path
 
     def _soundcloud_download(self, dl_info: dict):
-        """Downloads a soundcloud track. This requires a seperate function
-        because there are three methods that can be used to download a track:
+        """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
@@ -319,15 +323,14 @@ class Track:
 
     @property
     def _progress_desc(self) -> str:
-        """The description that is used on the progress bar.
+        """Get the description that is used on the progress bar.
 
         :rtype: str
         """
         return click.style(f"Track {int(self.meta.tracknumber):02}", fg="blue")
 
     def download_cover(self):
-        """Downloads the cover art, if cover_url is given."""
-
+        """Download the cover art, if cover_url is given."""
         if not hasattr(self, "cover_url"):
             return False
 
@@ -362,8 +365,7 @@ class Track:
 
     @classmethod
     def from_album_meta(cls, album: TrackMetadata, track: dict, client: Client):
-        """Return a new Track object initialized with info from the album dicts
-        returned by client.get calls.
+        """Return a new Track object initialized with info.
 
         :param album: album metadata returned by API
         :param pos: index of the track
@@ -371,14 +373,12 @@ class Track:
         :type client: Client
         :raises IndexError
         """
-
         meta = TrackMetadata(album=album, track=track, source=client.source)
         return cls(client=client, meta=meta, id=track["id"])
 
     @classmethod
     def from_api(cls, item: dict, client: Client):
-        """Given a track dict from an API, return a new Track object
-        initialized with the proper values.
+        """Return a new Track initialized from search result.
 
         :param item:
         :type item: dict
@@ -501,7 +501,7 @@ class Track:
         self.tagged = True
 
     def convert(self, codec: str = "ALAC", **kwargs):
-        """Converts the track to another codec.
+        """Convert the track to another codec.
 
         Valid values for codec:
             * FLAC
@@ -565,7 +565,7 @@ class Track:
 
     @property
     def title(self) -> str:
-        """The title of the track.
+        """Get the title of the track.
 
         :rtype: str
         """
@@ -586,8 +586,9 @@ class Track:
         return safe_get(self.meta, *keys, default=default)
 
     def set(self, key, val):
-        """Equivalent to __setitem__. Implemented only for
-        consistency.
+        """Set attribute `key` to `val`.
+
+        Equivalent to __setitem__. Implemented only for consistency.
 
         :param key:
         :param val:
@@ -617,8 +618,7 @@ class Track:
         return f"<Track - {self['title']}>"
 
     def __str__(self) -> str:
-        """Return a readable string representation of
-        this track.
+        """Return a readable string representation of this track.
 
         :rtype: str
         """
@@ -629,6 +629,14 @@ class Video:
     """Only for Tidal."""
 
     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
         self.title = kwargs.get("title", "MusicVideo")
@@ -660,7 +668,9 @@ class Video:
         return False  # so that it is not tagged
 
     def tag(self, *args, **kwargs):
-        """Dummy method.
+        """Return False.
+
+        This is a dummy method.
 
         :param args:
         :param kwargs:
@@ -669,10 +679,9 @@ class Video:
 
     @classmethod
     def from_album_meta(cls, track: dict, client: Client):
-        """Given an video response dict from an album, return a new
-        Video object from the information.
+        """Return a new Video object given an album API response.
 
-        :param track:
+        :param track: track dict from album
         :type track: dict
         :param client:
         :type client: Client
@@ -687,7 +696,7 @@ class Video:
 
     @property
     def path(self) -> str:
-        """The path to download the mp4 file.
+        """Get path to download the mp4 file.
 
         :rtype: str
         """
@@ -701,9 +710,17 @@ class Video:
         return os.path.join(self.parent_folder, f"{fname}.mp4")
 
     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}>"
 
 
@@ -711,9 +728,9 @@ class Booklet:
     """Only for Qobuz."""
 
     def __init__(self, resp: dict):
-        """Initialized from the `goodies` field of the Qobuz API
-        response.
+        """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()
@@ -750,8 +767,7 @@ class Tracklist(list):
     essence_regex = re.compile(r"([^\(]+)(?:\s*[\(\[][^\)][\)\]])*")
 
     def download(self, **kwargs):
-        """Uses the _prepare_download and _download_item methods to download
-        all of the tracks contained in the Tracklist.
+        """Download all of the items in the tracklist.
 
         :param kwargs:
         """
@@ -790,7 +806,7 @@ class Tracklist(list):
         self.downloaded = True
 
     def _download_and_convert_item(self, item, **kwargs):
-        """Downloads and converts an item.
+        """Download and convert an item.
 
         :param item:
         :param kwargs: should contain a `conversion` dict.
@@ -814,7 +830,7 @@ class Tracklist(list):
         raise NotImplementedError
 
     def get(self, key: Union[str, int], default=None):
-        """A safe `get` method similar to `dict.get`.
+        """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.
@@ -842,7 +858,8 @@ class Tracklist(list):
         self.__setitem__(key, val)
 
     def convert(self, codec="ALAC", **kwargs):
-        """Converts every item in `self`.
+        """Convert every item in `self`.
+
         Deprecated. Use _download_and_convert_item instead.
 
         :param codec:
@@ -863,8 +880,7 @@ class Tracklist(list):
 
     @classmethod
     def from_api(cls, item: dict, client: Client):
-        """Create an Album object from the api response of Qobuz, Tidal,
-        or Deezer.
+        """Create an Album object from an API response.
 
         :param resp: response dict
         :type resp: dict
@@ -878,12 +894,11 @@ class Tracklist(list):
 
     @staticmethod
     def get_cover_obj(cover_path: str, container: str, source: str):
-        """Given the path to an image and a quality id, return an initialized
-        cover object that can be used for every track in the album.
+        """Return an initialized cover object that is reused for every track.
 
-        :param cover_path:
+        :param cover_path: Path to the image, must be a JPEG.
         :type cover_path: str
-        :param quality:
+        :param quality: quality ID
         :type quality: int
         :rtype: Union[Picture, APIC]
         """
@@ -922,7 +937,7 @@ class Tracklist(list):
                 return cover(img.read(), imageformat=MP4Cover.FORMAT_JPEG)
 
     def download_message(self):
-        """The message to display after calling `Tracklist.download`.
+        """Get the message to display after calling `Tracklist.download`.
 
         :rtype: str
         """
@@ -943,6 +958,7 @@ class Tracklist(list):
     @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.
         """
@@ -953,6 +969,10 @@ class Tracklist(list):
         return album
 
     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)
 
@@ -960,6 +980,11 @@ class Tracklist(list):
             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)
 
@@ -971,19 +996,37 @@ class YoutubeVideo:
     """Dummy class implemented for consistency with the Media API."""
 
     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.url = url
         self.client = self.DummyClient()
 
     def download(
         self,
-        parent_folder="StreamripDownloads",
-        download_youtube_videos=False,
-        youtube_video_downloads_folder="StreamripDownloads",
+        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:
+        """
         click.secho(f"Downloading url {self.url}", fg="blue")
         filename_formatter = "%(track_number)s.%(track)s.%(container)s"
         filename = os.path.join(parent_folder, filename_formatter)
@@ -1020,7 +1063,21 @@ class YoutubeVideo:
         p.wait()
 
     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
diff --git a/streamrip/cli.py b/streamrip/cli.py
index e809ef0..41e7ba6 100644
--- a/streamrip/cli.py
+++ b/streamrip/cli.py
@@ -1,3 +1,5 @@
+"""The streamrip command line interface."""
+
 import logging
 import os
 from getpass import getpass
@@ -34,6 +36,7 @@ if not os.path.isdir(CACHE_DIR):
 @click.option("-t", "--text", metavar="PATH")
 @click.option("-nd", "--no-db", is_flag=True)
 @click.option("--debug", is_flag=True)
+@click.version_option(prog_name='streamrip')
 @click.pass_context
 def cli(ctx, **kwargs):
     """Streamrip: The all-in-one Qobuz, Tidal, SoundCloud, and Deezer music downloader.
@@ -124,7 +127,6 @@ def filter_discography(ctx, **kwargs):
 
     For basic filtering, use the `--repeats` and `--features` filters.
     """
-
     filters = kwargs.copy()
     filters.pop("urls")
     config.session["filters"] = filters
@@ -178,7 +180,7 @@ def search(ctx, **kwargs):
 @click.option("-l", "--list", default="ideal-discography")
 @click.pass_context
 def discover(ctx, **kwargs):
-    """Searches for albums in Qobuz's featured lists.
+    """Search for albums in Qobuz's featured lists.
 
     Avaiable options for `--list`:
 
@@ -229,7 +231,7 @@ def discover(ctx, **kwargs):
 @click.argument("URL")
 @click.pass_context
 def lastfm(ctx, source, url):
-    """Searches for tracks from a last.fm playlist on a given source.
+    """Search for tracks from a last.fm playlist on a given source.
 
     Examples:
 
@@ -241,7 +243,6 @@ def lastfm(ctx, source, url):
 
         Download a playlist using Tidal as the source
     """
-
     if source is not None:
         config.session["lastfm"]["source"] = source
 
@@ -290,8 +291,10 @@ def config(ctx, **kwargs):
 
 
 def none_chosen():
+    """Print message if nothing was chosen."""
     click.secho("No items chosen, exiting.", fg="bright_red")
 
 
 def main():
+    """Run the main program."""
     cli(obj={})
diff --git a/streamrip/clients.py b/streamrip/clients.py
index 51f80bf..1a7c17a 100644
--- a/streamrip/clients.py
+++ b/streamrip/clients.py
@@ -1,3 +1,5 @@
+"""The clients that interact with the service APIs."""
+
 import base64
 import hashlib
 import json
@@ -85,11 +87,14 @@ class Client(ABC):
 
 
 class QobuzClient(Client):
+    """QobuzClient."""
+
     source = "qobuz"
     max_quality = 4
 
     # ------- Public Methods -------------
     def __init__(self):
+        """Create a QobuzClient object."""
         self.logged_in = False
 
     def login(self, **kwargs):
@@ -134,6 +139,12 @@ class QobuzClient(Client):
         self.logged_in = True
 
     def get_tokens(self) -> Tuple[str, Sequence[str]]:
+        """Return app id and secrets.
+
+        These can be saved and reused.
+
+        :rtype: Tuple[str, Sequence[str]]
+        """
         return self.app_id, self.secrets
 
     def search(
@@ -172,16 +183,29 @@ class QobuzClient(Client):
         return self._api_search(query, media_type, limit)
 
     def get(self, item_id: Union[str, int], media_type: str = "album") -> dict:
+        """Get an item from the API.
+
+        :param item_id:
+        :type item_id: Union[str, int]
+        :param media_type:
+        :type media_type: str
+        :rtype: dict
+        """
         return self._api_get(media_type, item_id=item_id)
 
     def get_file_url(self, item_id, quality=3) -> dict:
+        """Get the downloadble file url for a track.
+
+        :param item_id:
+        :param quality:
+        :rtype: dict
+        """
         return self._api_get_file_url(item_id, quality=quality)
 
     # ---------- Private Methods ---------------
 
     def _gen_pages(self, epoint: str, params: dict) -> Generator:
-        """When there are multiple pages of results, this lazily
-        yields them.
+        """When there are multiple pages of results, this yields them.
 
         :param epoint:
         :type epoint: str
@@ -210,7 +234,7 @@ class QobuzClient(Client):
             yield page
 
     def _validate_secrets(self):
-        """Checks if the secrets are usable."""
+        """Check if the secrets are usable."""
         for secret in self.secrets:
             if self._test_secret(secret):
                 self.sec = secret
@@ -220,8 +244,7 @@ class QobuzClient(Client):
             raise InvalidAppSecretError(f"Invalid secrets: {self.secrets}")
 
     def _api_get(self, media_type: str, **kwargs) -> dict:
-        """Internal function that sends the request for metadata to the
-        Qobuz API.
+        """Request metadata from the Qobuz API.
 
         :param media_type:
         :type media_type: str
@@ -254,7 +277,7 @@ class QobuzClient(Client):
         return response
 
     def _api_search(self, query: str, media_type: str, limit: int = 500) -> Generator:
-        """Internal function that sends a search request to the API.
+        """Send a search request to the API.
 
         :param query:
         :type query: str
@@ -289,8 +312,7 @@ class QobuzClient(Client):
         return self._gen_pages(epoint, params)
 
     def _api_login(self, email: str, pwd: str):
-        """Internal function that logs into the api to get the user
-        authentication token.
+        """Log into the api to get the user authentication token.
 
         :param email:
         :type email: str
@@ -322,7 +344,7 @@ class QobuzClient(Client):
     def _api_get_file_url(
         self, track_id: Union[str, int], quality: int = 3, sec: str = None
     ) -> dict:
-        """Internal function that gets the file url given an id.
+        """Get the file url given a track id.
 
         :param track_id:
         :type track_id: Union[str, int]
@@ -367,7 +389,7 @@ class QobuzClient(Client):
         return response
 
     def _api_request(self, epoint: str, params: dict) -> Tuple[dict, int]:
-        """The function that handles all requests to the API.
+        """Send a request to the API.
 
         :param epoint:
         :type epoint: str
@@ -384,7 +406,7 @@ class QobuzClient(Client):
             raise
 
     def _test_secret(self, secret: str) -> bool:
-        """Tests a secret.
+        """Test the authenticity of a secret.
 
         :param secret:
         :type secret: str
@@ -399,10 +421,13 @@ class QobuzClient(Client):
 
 
 class DeezerClient(Client):
+    """DeezerClient."""
+
     source = "deezer"
     max_quality = 2
 
     def __init__(self):
+        """Create a DeezerClient."""
         self.session = gen_threadsafe_session()
 
         # no login required
@@ -418,7 +443,6 @@ class DeezerClient(Client):
         :param limit:
         :type limit: int
         """
-
         # TODO: use limit parameter
         response = self.session.get(
             f"{DEEZER_BASE}/search/{media_type}", params={"q": query}
@@ -428,6 +452,12 @@ class DeezerClient(Client):
         return response.json()
 
     def login(self, **kwargs):
+        """Return None.
+
+        Dummy method.
+
+        :param kwargs:
+        """
         logger.debug("Deezer does not require login call, returning")
 
     def get(self, meta_id: Union[str, int], media_type: str = "album"):
@@ -466,12 +496,15 @@ class DeezerClient(Client):
 
 
 class TidalClient(Client):
+    """TidalClient."""
+
     source = "tidal"
     max_quality = 3
 
     # ----------- Public Methods --------------
 
     def __init__(self):
+        """Create a TidalClient."""
         self.logged_in = False
 
         self.device_code = None
@@ -578,7 +611,7 @@ class TidalClient(Client):
         }
 
     def get_tokens(self) -> dict:
-        """Used for saving them for later use.
+        """Return tokens to save for later use.
 
         :rtype: dict
         """
@@ -595,10 +628,11 @@ class TidalClient(Client):
 
     # ------------ Utilities to login -------------
 
-    def _login_new_user(self, launch=True):
-        """This will launch the browser and ask the user to log into tidal.
+    def _login_new_user(self, launch: bool = True):
+        """Create app url where the user can log in.
 
-        :param launch:
+        :param launch: Launch the browser.
+        :type launch: bool
         """
         login_link = f"https://{self._get_device_code()}"
 
@@ -690,7 +724,9 @@ class TidalClient(Client):
         return True
 
     def _refresh_access_token(self):
-        """The access token expires in a week, so it must be refreshed.
+        """Refresh the access token given a refresh token.
+
+        The access token expires in a week, so it must be refreshed.
         Requires a refresh token.
         """
         data = {
@@ -715,7 +751,9 @@ class TidalClient(Client):
         self._update_authorization()
 
     def _login_by_access_token(self, token, user_id=None):
-        """This is the method used to login after the access token has been saved.
+        """Login using the access token.
+
+        Used after the initial authorization.
 
         :param token:
         :param user_id: Not necessary.
@@ -741,7 +779,7 @@ class TidalClient(Client):
 
     @property
     def authorization(self):
-        """The auth header."""
+        """Get the auth header."""
         return {"authorization": f"Bearer {self.access_token}"}
 
     # ------------- Fetch data ------------------
@@ -777,7 +815,7 @@ class TidalClient(Client):
         return item
 
     def _api_request(self, path: str, params=None) -> dict:
-        """The function that handles all tidal API requests.
+        """Handle Tidal API requests.
 
         :param path:
         :type path: str
@@ -793,8 +831,7 @@ class TidalClient(Client):
         return r
 
     def _get_video_stream_url(self, video_id: str) -> str:
-        """Videos have to be ripped from an hls stream, so they require
-        seperate processing.
+        """Get the HLS video stream url.
 
         :param video_id:
         :type video_id: str
@@ -820,7 +857,7 @@ class TidalClient(Client):
         return url_info[-1]
 
     def _api_post(self, url, data, auth=None):
-        """Function used for posting to tidal API.
+        """Post to the Tidal API.
 
         :param url:
         :param data:
@@ -831,11 +868,14 @@ class TidalClient(Client):
 
 
 class SoundCloudClient(Client):
+    """SoundCloudClient."""
+
     source = "soundcloud"
     max_quality = 0
     logged_in = True
 
     def __init__(self):
+        """Create a SoundCloudClient."""
         self.session = gen_threadsafe_session(headers={"User-Agent": AGENT})
 
     def login(self):
@@ -906,8 +946,7 @@ class SoundCloudClient(Client):
         return resp
 
     def _get(self, path, params=None, no_base=False, resp_obj=False):
-        """The lower level of `SoundCloudClient.get` that handles request
-        parameters and other options.
+        """Send a request to the SoundCloud API.
 
         :param path:
         :param params:
diff --git a/streamrip/config.py b/streamrip/config.py
index 45a492e..88fb273 100644
--- a/streamrip/config.py
+++ b/streamrip/config.py
@@ -108,6 +108,13 @@ class Config:
     }
 
     def __init__(self, path: str = None):
+        """Create a Config object with state.
+
+        A YAML file is created at `path` if there is none.
+
+        :param path:
+        :type path: str
+        """
         # to access settings loaded from yaml file
         self.file: Dict[str, Any] = copy.deepcopy(self.defaults)
         self.session: Dict[str, Any] = copy.deepcopy(self.defaults)
@@ -124,7 +131,7 @@ class Config:
             self.load()
 
     def update(self):
-        """Resets the config file except for credentials."""
+        """Reset the config file except for credentials."""
         self.reset()
         temp = copy.deepcopy(self.defaults)
         temp["qobuz"].update(self.file["qobuz"])
@@ -133,12 +140,10 @@ class Config:
 
     def save(self):
         """Save the config state to file."""
-
         self.dump(self.file)
 
     def reset(self):
         """Reset the config file."""
-
         if not os.path.isdir(CONFIG_DIR):
             os.makedirs(CONFIG_DIR, exist_ok=True)
 
@@ -146,7 +151,6 @@ class Config:
 
     def load(self):
         """Load infomation from the config files, making a deepcopy."""
-
         with open(self._path) as cfg:
             for k, v in yaml.load(cfg).items():
                 self.file[k] = v
@@ -204,20 +208,14 @@ class Config:
 
         raise InvalidSourceError(source)
 
-    def __getitem__(self, key):
-        assert key in ("file", "defaults", "session")
-        return getattr(self, key)
-
-    def __setitem__(self, key, val):
-        assert key in ("file", "session")
-        setattr(self, key, val)
-
     def __repr__(self):
+        """Return a string representation of the config."""
         return f"Config({pformat(self.session)})"
 
 
 class ConfigDocumentation:
     """Documentation is stored in this docstring.
+
     qobuz:
         quality: 1: 320kbps MP3, 2: 16/44.1, 3: 24/<=96, 4: 24/>=96
         download_booklets: This will download booklet pdfs that are included with some albums
@@ -263,12 +261,13 @@ class ConfigDocumentation:
     """
 
     def __init__(self):
+        """Create a new ConfigDocumentation object."""
         # not using ruamel because its super slow
         self.docs = []
         doctext = self.__doc__
         # get indent level, key, and documentation
         keyval = re.compile(r"( *)([\w_]+):\s*(.*)")
-        lines = (line[4:] for line in doctext.split("\n")[1:-1])
+        lines = (line[4:] for line in doctext.split("\n")[2:-1])
 
         for line in lines:
             info = list(keyval.match(line).groups())
@@ -322,11 +321,24 @@ class ConfigDocumentation:
                     self.docs.remove(to_remove)
 
     @cache
-    def _get_key_regex(self, spaces, key):
+    def _get_key_regex(self, spaces: str, key: str) -> re.Pattern:
+        """Get a regex that matches a key in YAML.
+
+        :param spaces: a string spaces that represent the indent level.
+        :type spaces: str
+        :param key: the key to match.
+        :type key: str
+        :rtype: re.Pattern
+        """
         regex = rf"{spaces}{key}:(?:$|\s+?(.+))"
         return re.compile(regex)
 
     def strip_comments(self, path: str):
+        """Remove single-line comments from a file.
+
+        :param path:
+        :type path: str
+        """
         with open(path, "r") as f:
             lines = [line for line in f.readlines() if not line.strip().startswith("#")]
 
@@ -337,9 +349,10 @@ class ConfigDocumentation:
 # ------------- ~~ Experimental ~~ ----------------- #
 
 def load_yaml(path: str):
-    """A custom YAML parser optimized for use with streamrip.
+    """Load a streamrip config YAML file.
 
-    Warning: this is not fully compliant with YAML.
+    Warning: this is not fully compliant with YAML. It was made for use
+    with streamrip.
 
     :param path:
     :type path: str
@@ -406,10 +419,19 @@ class StringWalker:
     """A fancier str iterator."""
 
     def __init__(self, s: str):
+        """Create a StringWalker object.
+
+        :param s:
+        :type s: str
+        """
         self.__val = s.replace('\n', '')
         self.__pos = 0
 
     def __next__(self) -> str:
+        """Get the next char.
+
+        :rtype: str
+        """
         try:
             c = self.__val[self.__pos]
             self.__pos += 1
@@ -418,7 +440,13 @@ class StringWalker:
             raise StopIteration
 
     def __iter__(self):
+        """Get an iterator."""
         return self
 
     def prev(self, step: int = 1):
+        """Un-read a character.
+
+        :param step: The number of steps backward to take.
+        :type step: int
+        """
         self.__pos -= step
diff --git a/streamrip/constants.py b/streamrip/constants.py
index 4fc6d6b..3fac0ce 100644
--- a/streamrip/constants.py
+++ b/streamrip/constants.py
@@ -1,3 +1,5 @@
+"""Constants that are kept in one place."""
+
 import os
 from pathlib import Path
 
diff --git a/streamrip/converter.py b/streamrip/converter.py
index 52ecde8..994dc93 100644
--- a/streamrip/converter.py
+++ b/streamrip/converter.py
@@ -1,3 +1,5 @@
+"""Wrapper classes over FFMPEG."""
+
 import logging
 import os
 import shutil
@@ -31,7 +33,8 @@ class Converter:
         remove_source: bool = False,
         show_progress: bool = False,
     ):
-        """
+        """Create a Converter object.
+
         :param filename:
         :type filename: str
         :param ffmpeg_arg: The codec ffmpeg argument (defaults to an "optimal value")
@@ -42,7 +45,7 @@ class Converter:
         :type bit_depth: Optional[int]
         :param copy_art: Embed the cover art (if found) into the encoded file
         :type copy_art: bool
-        :param remove_source:
+        :param remove_source: Remove the source file after conversion.
         :type remove_source: bool
         """
         logger.debug(locals())
@@ -148,7 +151,8 @@ class Converter:
 
 
 class FLAC(Converter):
-    " Class for FLAC converter. "
+    """Class for FLAC converter."""
+
     codec_name = "flac"
     codec_lib = "flac"
     container = "flac"
@@ -156,8 +160,9 @@ class FLAC(Converter):
 
 
 class LAME(Converter):
-    """
-    Class for libmp3lame converter. Defaul ffmpeg_arg: `-q:a 0`.
+    """Class for libmp3lame converter.
+
+    Default ffmpeg_arg: `-q:a 0`.
 
     See available options:
     https://trac.ffmpeg.org/wiki/Encode/MP3
@@ -170,7 +175,8 @@ class LAME(Converter):
 
 
 class ALAC(Converter):
-    " Class for ALAC converter. "
+    """Class for ALAC converter."""
+
     codec_name = "alac"
     codec_lib = "alac"
     container = "m4a"
@@ -178,8 +184,9 @@ class ALAC(Converter):
 
 
 class Vorbis(Converter):
-    """
-    Class for libvorbis converter. Default ffmpeg_arg: `-q:a 6`.
+    """Class for libvorbis converter.
+
+    Default ffmpeg_arg: `-q:a 6`.
 
     See available options:
     https://trac.ffmpeg.org/wiki/TheoraVorbisEncodingGuide
@@ -192,8 +199,9 @@ class Vorbis(Converter):
 
 
 class OPUS(Converter):
-    """
-    Class for libopus. Default ffmpeg_arg: `-b:a 128 -vbr on`.
+    """Class for libopus.
+
+    Default ffmpeg_arg: `-b:a 128 -vbr on`.
 
     See more:
     http://ffmpeg.org/ffmpeg-codecs.html#libopus-1
@@ -206,8 +214,9 @@ class OPUS(Converter):
 
 
 class AAC(Converter):
-    """
-    Class for libfdk_aac converter. Default ffmpeg_arg: `-b:a 256k`.
+    """Class for libfdk_aac converter.
+
+    Default ffmpeg_arg: `-b:a 256k`.
 
     See available options:
     https://trac.ffmpeg.org/wiki/Encode/AAC
diff --git a/streamrip/core.py b/streamrip/core.py
index 6782d9c..10b7cac 100644
--- a/streamrip/core.py
+++ b/streamrip/core.py
@@ -1,3 +1,5 @@
+"""The stuff that ties everything together for the CLI to use."""
+
 import concurrent.futures
 import html
 import logging
@@ -14,7 +16,7 @@ import requests
 from tqdm import tqdm
 
 from .bases import Track, Video, YoutubeVideo
-from .clients import DeezerClient, QobuzClient, SoundCloudClient, TidalClient
+from .clients import DeezerClient, QobuzClient, SoundCloudClient, TidalClient, Client
 from .config import Config
 from .constants import (
     CONFIG_PATH,
@@ -53,11 +55,17 @@ MEDIA_CLASS: Dict[str, Media] = {
 
 
 class MusicDL(list):
+    """MusicDL."""
+
     def __init__(
         self,
         config: Optional[Config] = None,
     ):
+        """Create a MusicDL object.
 
+        :param config:
+        :type config: Optional[Config]
+        """
         self.url_parse = re.compile(URL_REGEX)
         self.soundcloud_url_parse = re.compile(SOUNDCLOUD_URL_REGEX)
         self.lastfm_url_parse = re.compile(LASTFM_URL_REGEX)
@@ -89,14 +97,13 @@ class MusicDL(list):
             self.db = []
 
     def handle_urls(self, url: str):
-        """Download a url
+        """Download a url.
 
         :param url:
         :type url: str
         :raises InvalidSourceError
         :raises ParsingError
         """
-
         # youtube is handled by youtube-dl, so much of the
         # processing is not necessary
         youtube_urls = self.youtube_url_parse.findall(url)
@@ -121,6 +128,15 @@ class MusicDL(list):
             self.handle_item(source, url_type, item_id)
 
     def handle_item(self, source: str, media_type: str, item_id: str):
+        """Get info and parse into a Media object.
+
+        :param source:
+        :type source: str
+        :param media_type:
+        :type media_type: str
+        :param item_id:
+        :type item_id: str
+        """
         self.assert_creds(source)
 
         client = self.get_client(source)
@@ -134,6 +150,10 @@ class MusicDL(list):
         self.append(item)
 
     def _get_download_args(self) -> dict:
+        """Get the arguments to pass to Media.download.
+
+        :rtype: dict
+        """
         return {
             "database": self.db,
             "parent_folder": self.config.session["downloads"]["folder"],
@@ -162,6 +182,7 @@ class MusicDL(list):
         }
 
     def download(self):
+        """Download all the items in self."""
         try:
             arguments = self._get_download_args()
         except KeyError:
@@ -222,7 +243,13 @@ class MusicDL(list):
             if self.db != [] and hasattr(item, "id"):
                 self.db.add(item.id)
 
-    def get_client(self, source: str):
+    def get_client(self, source: str) -> Client:
+        """Get a client given the source and log in.
+
+        :param source:
+        :type source: str
+        :rtype: Client
+        """
         client = self.clients[source]
         if not client.logged_in:
             self.assert_creds(source)
@@ -230,6 +257,10 @@ class MusicDL(list):
         return client
 
     def login(self, client):
+        """Log into a client, if applicable.
+
+        :param client:
+        """
         creds = self.config.creds(client.source)
         if not client.logged_in:
             while True:
@@ -254,7 +285,7 @@ class MusicDL(list):
                 self.config.save()
 
     def parse_urls(self, url: str) -> List[Tuple[str, str, str]]:
-        """Returns the type of the url and the id.
+        """Return the type of the url and the id.
 
         Compatible with urls of the form:
             https://www.qobuz.com/us-en/{type}/{name}/{id}
@@ -267,7 +298,6 @@ class MusicDL(list):
 
         :raises exceptions.ParsingError
         """
-
         parsed: List[Tuple[str, str, str]] = []
 
         interpreter_urls = self.interpreter_url_parse.findall(url)
@@ -296,7 +326,16 @@ class MusicDL(list):
 
         return parsed
 
-    def handle_lastfm_urls(self, urls):
+    def handle_lastfm_urls(self, urls: str):
+        """Get info from lastfm url, and parse into Media objects.
+
+        This works by scraping the last.fm page and using a regex to
+        find the track titles and artists. The information is queried
+        in a Client.search(query, 'track') call and the first result is
+        used.
+
+        :param urls:
+        """
         # For testing:
         # https://www.last.fm/user/nathan3895/playlists/12058911
         user_regex = re.compile(r"https://www\.last\.fm/user/([^/]+)/playlists/\d+")
@@ -304,8 +343,14 @@ class MusicDL(list):
         lastfm_source = self.config.session["lastfm"]["source"]
 
         def search_query(query: str, playlist: Playlist) -> bool:
-            """Search for a query and add the first result to the given
-            Playlist object."""
+            """Search for a query and add the first result to playlist.
+
+            :param query:
+            :type query: str
+            :param playlist:
+            :type playlist: Playlist
+            :rtype: bool
+            """
             try:
                 track = next(self.search(lastfm_source, query, media_type="track"))
                 if self.config.session["metadata"]["set_playlist_to_album"]:
@@ -361,6 +406,18 @@ class MusicDL(list):
     def search(
         self, source: str, query: str, media_type: str = "album", limit: int = 200
     ) -> Generator:
+        """Universal search.
+
+        :param source:
+        :type source: str
+        :param query:
+        :type query: str
+        :param media_type:
+        :type media_type: str
+        :param limit:
+        :type limit: int
+        :rtype: Generator
+        """
         client = self.get_client(source)
         results = client.search(query, media_type)
 
@@ -392,7 +449,11 @@ class MusicDL(list):
                 if i > limit:
                     return
 
-    def preview_media(self, media):
+    def preview_media(self, media) -> str:
+        """Return a preview string of a Media object.
+
+        :param media:
+        """
         if isinstance(media, Album):
             fmt = (
                 "{albumartist} - {album}\n"
@@ -422,6 +483,15 @@ class MusicDL(list):
     def interactive_search(  # noqa
         self, query: str, source: str = "qobuz", media_type: str = "album"
     ):
+        """Show an interactive menu that contains search results.
+
+        :param query:
+        :type query: str
+        :param source:
+        :type source: str
+        :param media_type:
+        :type media_type: str
+        """
         results = tuple(self.search(source, query, media_type, limit=50))
 
         def title(res):
@@ -502,6 +572,15 @@ class MusicDL(list):
                 return True
 
     def get_lastfm_playlist(self, url: str) -> Tuple[str, list]:
+        """From a last.fm url, find the playlist title and tracks.
+
+        Each page contains 50 results, so `num_tracks // 50 + 1` requests
+        are sent per playlist.
+
+        :param url:
+        :type url: str
+        :rtype: Tuple[str, list]
+        """
         info = []
         words = re.compile(r"[\w\s]+")
         title_tags = re.compile('title="([^"]+)"')
@@ -569,6 +648,11 @@ class MusicDL(list):
             raise Exception
 
     def assert_creds(self, source: str):
+        """Ensure that the credentials for `source` are valid.
+
+        :param source:
+        :type source: str
+        """
         assert source in (
             "qobuz",
             "tidal",
diff --git a/streamrip/db.py b/streamrip/db.py
index 724ce37..795dee8 100644
--- a/streamrip/db.py
+++ b/streamrip/db.py
@@ -1,6 +1,4 @@
-"""A simple wrapper over an sqlite database that stores
-the downloaded media IDs.
-"""
+"""Wrapper over a database that stores item IDs."""
 
 import logging
 import os
@@ -14,7 +12,7 @@ class MusicDB:
     """Simple interface for the downloaded track database."""
 
     def __init__(self, db_path: Union[str, os.PathLike]):
-        """Create a MusicDB object
+        """Create a MusicDB object.
 
         :param db_path: filepath of the database
         :type db_path: Union[str, os.PathLike]
@@ -24,7 +22,7 @@ class MusicDB:
             self.create()
 
     def create(self):
-        """Create a database at `self.path`"""
+        """Create a database at `self.path`."""
         with sqlite3.connect(self.path) as conn:
             try:
                 conn.execute("CREATE TABLE downloads (id TEXT UNIQUE NOT NULL);")
@@ -35,7 +33,7 @@ class MusicDB:
             return self.path
 
     def __contains__(self, item_id: Union[str, int]) -> bool:
-        """Checks whether the database contains an id.
+        """Check whether the database contains an id.
 
         :param item_id: the id to check
         :type item_id: str
@@ -51,7 +49,7 @@ class MusicDB:
             )
 
     def add(self, item_id: str):
-        """Adds an id to the database.
+        """Add an id to the database.
 
         :param item_id:
         :type item_id: str
diff --git a/streamrip/metadata.py b/streamrip/metadata.py
index f14a941..be31062 100644
--- a/streamrip/metadata.py
+++ b/streamrip/metadata.py
@@ -1,4 +1,5 @@
-"""Manages the information that will be embeded in the audio file. """
+"""Manages the information that will be embeded in the audio file."""
+
 from __future__ import annotations
 
 import logging
@@ -24,8 +25,8 @@ logger = logging.getLogger(__name__)
 
 class TrackMetadata:
     """Contains all of the metadata needed to tag the file.
-    Tags contained:
 
+    Tags contained:
         * title
         * artist
         * album
@@ -46,7 +47,6 @@ class TrackMetadata:
         * discnumber
         * tracktotal
         * disctotal
-
     """
 
     def __init__(
@@ -55,8 +55,7 @@ class TrackMetadata:
         album: Optional[Union[TrackMetadata, dict]] = None,
         source="qobuz",
     ):
-        """Creates a TrackMetadata object optionally initialized with
-        dicts returned by the Qobuz API.
+        """Create a TrackMetadata object.
 
         :param track: track dict from API
         :type track: Optional[dict]
@@ -108,9 +107,8 @@ class TrackMetadata:
         elif album is not None:
             self.add_album_meta(album)
 
-    def update(self, meta):
-        """Given a TrackMetadata object (usually from an album), the fields
-        of the current object are updated.
+    def update(self, meta: TrackMetadata):
+        """Update the attributes from another TrackMetadata object.
 
         :param meta:
         :type meta: TrackMetadata
@@ -122,8 +120,7 @@ class TrackMetadata:
                 setattr(self, k, v)
 
     def add_album_meta(self, resp: dict):
-        """Parse the metadata from an resp dict returned by the
-        API.
+        """Parse the metadata from an resp dict returned by the API.
 
         :param dict resp: from API
         """
@@ -226,8 +223,7 @@ class TrackMetadata:
             raise InvalidSourceError(self.__source)
 
     def add_track_meta(self, track: dict):
-        """Parse the metadata from a track dict returned by an
-        API.
+        """Parse the metadata from a track dict returned by an API.
 
         :param track:
         """
@@ -272,7 +268,14 @@ class TrackMetadata:
         if track.get("album"):
             self.add_album_meta(track["album"])
 
-    def _mod_title(self, version, work):
+    def _mod_title(self, version: str, work: str):
+        """Modify title using the version and work.
+
+        :param version:
+        :type version: str
+        :param work:
+        :type work: str
+        """
         if version is not None:
             self.title = f"{self.title} ({version})"
         if work is not None:
@@ -281,6 +284,10 @@ class TrackMetadata:
 
     @property
     def album(self) -> str:
+        """Return the album of the track.
+
+        :rtype: str
+        """
         assert hasattr(self, "_album"), "Must set album before accessing"
 
         album = self._album
@@ -295,12 +302,17 @@ class TrackMetadata:
 
     @album.setter
     def album(self, val):
+        """Set the value of the album.
+
+        :param val:
+        """
         self._album = val
 
     @property
     def artist(self) -> Optional[str]:
-        """Returns the value to set for the artist tag. Defaults to
-        `self.albumartist` if there is no track artist.
+        """Return the value to set for the artist tag.
+
+        Defaults to `self.albumartist` if there is no track artist.
 
         :rtype: str
         """
@@ -314,7 +326,7 @@ class TrackMetadata:
 
     @artist.setter
     def artist(self, val: str):
-        """Sets the internal artist variable to val.
+        """Set the internal artist variable to val.
 
         :param val:
         :type val: str
@@ -323,10 +335,12 @@ class TrackMetadata:
 
     @property
     def genre(self) -> Optional[str]:
-        """Formats the genre list returned by the Qobuz API.
-        >>> meta.genre = ['Pop/Rock', 'Pop/Rock→Rock', 'Pop/Rock→Rock→Alternatif et Indé']
-        >>> meta.genre
-        'Pop, Rock, Alternatif et Indé'
+        """Format the genre list returned by an API.
+
+        It cleans up the Qobuz Response:
+            >>> meta.genre = ['Pop/Rock', 'Pop/Rock→Rock', 'Pop/Rock→Rock→Alternatif et Indé']
+            >>> meta.genre
+            'Pop, Rock, Alternatif et Indé'
 
         :rtype: str
         """
@@ -350,7 +364,8 @@ class TrackMetadata:
 
     @genre.setter
     def genre(self, val: Union[Iterable, dict]):
-        """Sets the internal `genre` field to the given list.
+        """Set the internal `genre` field to the given list.
+
         It is not formatted until it is requested with `meta.genre`.
 
         :param val:
@@ -360,8 +375,7 @@ class TrackMetadata:
 
     @property
     def copyright(self) -> Optional[str]:
-        """Formats the copyright string to use nice-looking unicode
-        characters.
+        """Format the copyright string to use unicode characters.
 
         :rtype: str, None
         """
@@ -377,7 +391,8 @@ class TrackMetadata:
 
     @copyright.setter
     def copyright(self, val: str):
-        """Sets the internal copyright variable to the given value.
+        """Set the internal copyright variable to the given value.
+
         Only formatted when requested.
 
         :param val:
@@ -387,7 +402,7 @@ class TrackMetadata:
 
     @property
     def year(self) -> Optional[str]:
-        """Returns the year published of the track.
+        """Return the year published of the track.
 
         :rtype: str
         """
@@ -402,14 +417,14 @@ class TrackMetadata:
 
     @year.setter
     def year(self, val):
-        """Sets the internal year variable to val.
+        """Set the internal year variable to val.
 
         :param val:
         """
         self._year = val
 
     def get_formatter(self) -> dict:
-        """Returns a dict that is used to apply values to file format strings.
+        """Return a dict that is used to apply values to file format strings.
 
         :rtype: dict
         """
@@ -417,21 +432,22 @@ class TrackMetadata:
         return {k: getattr(self, k) for k in TRACK_KEYS}
 
     def tags(self, container: str = "flac") -> Generator:
-        """Return a generator of (key, value) pairs to use for tagging
-        files with mutagen. The *_KEY dicts are organized in the format
+        """Create a generator of key, value pairs for use with mutagen.
 
-        >>> {attribute_name: key_to_use_for_metadata}
+        The *_KEY dicts are organized in the format:
+
+            >>> {attribute_name: key_to_use_for_metadata}
 
         They are then converted to the format
 
-        >>> {key_to_use_for_metadata: value_of_attribute}
+            >>> {key_to_use_for_metadata: value_of_attribute}
 
         so that they can be used like this:
 
-        >>> audio = MP4(path)
-        >>> for k, v in meta.tags(container='MP4'):
-        ...     audio[k] = v
-        >>> audio.save()
+            >>> audio = MP4(path)
+            >>> for k, v in meta.tags(container='MP4'):
+            ...     audio[k] = v
+            >>> audio.save()
 
         :param container: the container format
         :type container: str
@@ -478,8 +494,7 @@ class TrackMetadata:
                 yield (v.__name__, v(encoding=3, text=text))
 
     def __gen_mp4_tags(self) -> Generator:
-        """Generate key, value pairs to tag ALAC or AAC files in
-        an MP4 container.
+        """Generate key, value pairs to tag ALAC or AAC files.
 
         :rtype: Tuple[str, str]
         """
@@ -495,6 +510,10 @@ class TrackMetadata:
                 yield (v, text)
 
     def asdict(self) -> dict:
+        """Return a dict representation of self.
+
+        :rtype: dict
+        """
         ret = {}
         for attr in dir(self):
             if not attr.startswith("_") and not callable(getattr(self, attr)):
@@ -518,8 +537,7 @@ class TrackMetadata:
         return getattr(self, key)
 
     def get(self, key, default=None):
-        """Returns the requested attribute of the object, with
-        a default value.
+        """Return the requested attribute of the object, with a default value.
 
         :param key:
         :param default:
@@ -534,8 +552,10 @@ class TrackMetadata:
         return default
 
     def set(self, key, val) -> str:
-        """Equivalent to
-        >>> meta[key] = val
+        """Set an attribute.
+
+        Equivalent to:
+            >>> meta[key] = val
 
         :param key:
         :param val:
@@ -544,10 +564,16 @@ class TrackMetadata:
         return self.__setitem__(key, val)
 
     def __hash__(self) -> int:
+        """Get a hash of this.
+
+        Warning: slow.
+
+        :rtype: int
+        """
         return sum(hash(v) for v in self.asdict().values() if isinstance(v, Hashable))
 
     def __repr__(self) -> str:
-        """Returns the string representation of the metadata object.
+        """Return the string representation of the metadata object.
 
         :rtype: str
         """
diff --git a/streamrip/spoofbuz.py b/streamrip/spoofbuz.py
index 5a3fc8d..1923cc2 100644
--- a/streamrip/spoofbuz.py
+++ b/streamrip/spoofbuz.py
@@ -1,4 +1,7 @@
-# Credits to Dash for this tool.
+"""Get app id and secrets for Qobuz.
+
+Credits to Dash for this tool.
+"""
 
 import base64
 import re
@@ -8,7 +11,10 @@ import requests
 
 
 class Spoofer:
+    """Spoofs the information required to stream tracks from Qobuz."""
+
     def __init__(self):
+        """Create a Spoofer."""
         self.seed_timezone_regex = (
             r'[a-z]\.initialSeed\("(?P<seed>[\w=]+)",window\.ut'
             r"imezone\.(?P<timezone>[a-z]+)\)"
@@ -33,11 +39,19 @@ class Spoofer:
         bundle_req = requests.get("https://play.qobuz.com" + bundle_url)
         self.bundle = bundle_req.text
 
-    def get_app_id(self):
-        match = re.search(self.app_id_regex, self.bundle).group("app_id")
-        return str(match)
+    def get_app_id(self) -> str:
+        """Get the app id.
+
+        :rtype: str
+        """
+        match = re.search(self.app_id_regex, self.bundle)
+        if match is not None:
+            return str(match.group("app_id"))
+
+        raise Exception("Could not find app id.")
 
     def get_secrets(self):
+        """Get secrets."""
         seed_matches = re.finditer(self.seed_timezone_regex, self.bundle)
         secrets = OrderedDict()
         for match in seed_matches:
diff --git a/streamrip/tracklists.py b/streamrip/tracklists.py
index 307efbd..294b194 100644
--- a/streamrip/tracklists.py
+++ b/streamrip/tracklists.py
@@ -1,6 +1,4 @@
-"""These classes parse information from Clients into a universal,
-downloadable form.
-"""
+"""These classes parse information from Clients into a universal, downloadable form."""
 
 from __future__ import annotations
 
@@ -72,7 +70,6 @@ class Album(Tracklist):
 
     def load_meta(self):
         """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")
 
@@ -88,6 +85,13 @@ class Album(Tracklist):
 
     @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)
 
@@ -95,6 +99,10 @@ class Album(Tracklist):
         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)
@@ -159,6 +167,17 @@ class Album(Tracklist):
         database: MusicDB = None,
         **kwargs,
     ) -> bool:
+        """Download an item.
+
+        :param track: The item.
+        :type track: Union[Track, Video]
+        :param quality:
+        :type quality: int
+        :param database:
+        :type database: MusicDB
+        :param kwargs:
+        :rtype: bool
+        """
         logger.debug("Downloading track to %s", self.folder)
         if self.disctotal > 1 and isinstance(track, Track):
             disc_folder = os.path.join(self.folder, f"Disc {track.meta.discnumber}")
@@ -189,8 +208,7 @@ class Album(Tracklist):
         return meta
 
     def _load_tracks(self, resp):
-        """Given an album metadata dict returned by the API, append all of its
-        tracks to `self`.
+        """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.
@@ -214,6 +232,10 @@ class Album(Tracklist):
                 )
 
     def _get_formatter(self) -> dict:
+        """Get a formatter that is used for previews in core.py.
+
+        :rtype: dict
+        """
         fmt = dict()
         for key in ALBUM_KEYS:
             # default to None
@@ -228,6 +250,14 @@ class Album(Tracklist):
         return fmt
 
     def _get_formatted_folder(self, parent_folder: str, quality: int) -> str:
+        """Generate the folder name for this album.
+
+        :param parent_folder:
+        :type parent_folder: str
+        :param quality:
+        :type quality: int
+        :rtype: str
+        """
         # necessary to format the folder
         self.container = get_container(quality, self.client.source)
         if self.container in ("AAC", "MP3"):
@@ -240,10 +270,19 @@ class Album(Tracklist):
 
     @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:
@@ -258,17 +297,21 @@ class Album(Tracklist):
         return f"<Album: V/A - {self.title}>"
 
     def __str__(self) -> str:
-        """Return a readable string representation of
-        this album.
+        """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)
 
 
@@ -303,8 +346,7 @@ class Playlist(Tracklist):
 
     @classmethod
     def from_api(cls, resp: dict, client: Client):
-        """Return a Playlist object initialized with information from
-        a search result returned by the API.
+        """Return a Playlist object from an API response.
 
         :param resp: a single search result entry of a playlist
         :type resp: dict
@@ -327,7 +369,7 @@ class Playlist(Tracklist):
         self.loaded = True
 
     def _load_tracks(self, new_tracknumbers: bool = True):
-        """Parses the tracklist returned by the API.
+        """Parse the tracklist returned by the API.
 
         :param new_tracknumbers: replace tracknumber tag with playlist position
         :type new_tracknumbers: bool
@@ -439,8 +481,7 @@ class Playlist(Tracklist):
 
     @staticmethod
     def _parse_get_resp(item: dict, client: Client) -> dict:
-        """Parses information from a search result returned
-        by a client.search call.
+        """Parse information from a search result returned by a client.search call.
 
         :param item:
         :type item: dict
@@ -475,6 +516,10 @@ class Playlist(Tracklist):
 
     @property
     def title(self) -> str:
+        """Get the title.
+
+        :rtype: str
+        """
         return self.name
 
     def __repr__(self) -> str:
@@ -485,8 +530,7 @@ class Playlist(Tracklist):
         return f"<Playlist: {self.name}>"
 
     def __str__(self) -> str:
-        """Return a readable string representation of
-        this track.
+        """Return a readable string representation of this track.
 
         :rtype: str
         """
@@ -530,13 +574,18 @@ class Artist(Tracklist):
 
     # 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):
-        """From the discography returned by client.get(query, 'artist'),
-        generate album objects and append them to 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"]
@@ -560,6 +609,15 @@ class Artist(Tracklist):
     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
+        """
         folder = sanitize_filename(self.name)
         self.folder = os.path.join(parent_folder, folder)
 
@@ -590,6 +648,18 @@ class Artist(Tracklist):
         database: MusicDB = None,
         **kwargs,
     ) -> bool:
+        """Download an item.
+
+        :param item:
+        :param parent_folder:
+        :type parent_folder: str
+        :param quality:
+        :type quality: int
+        :param database:
+        :type database: MusicDB
+        :param kwargs:
+        :rtype: bool
+        """
         try:
             item.load_meta()
         except NonStreamable:
@@ -607,12 +677,17 @@ class Artist(Tracklist):
 
     @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.
+        """Create an Artist object from the api response of Qobuz, Tidal, or Deezer.
 
         :param resp: response dict
         :type resp: dict
@@ -659,8 +734,9 @@ class Artist(Tracklist):
     }
 
     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.
+        """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
@@ -681,9 +757,7 @@ class Artist(Tracklist):
                     break
 
     def _non_studio_albums(self, album: Album) -> bool:
-        """Passed as a parameter by the user.
-
-        This will download only studio albums.
+        """Filter non-studio-albums.
 
         :param artist: usually self
         :param album: the album to check
@@ -696,7 +770,7 @@ class Artist(Tracklist):
         )
 
     def _features(self, album: Album) -> bool:
-        """Passed as a parameter by the user.
+        """Filter features.
 
         This will download only albums where the requested
         artist is the album artist.
@@ -709,9 +783,7 @@ class Artist(Tracklist):
         return self["name"] == album["albumartist"]
 
     def _extras(self, album: Album) -> bool:
-        """Passed as a parameter by the user.
-
-        This will skip any extras.
+        """Filter extras.
 
         :param artist: usually self
         :param album: the album to check
@@ -721,9 +793,7 @@ class Artist(Tracklist):
         return self.TYPE_REGEXES["extra"].search(album.title) is None
 
     def _non_remasters(self, album: Album) -> bool:
-        """Passed as a parameter by the user.
-
-        This will download only remasterd albums.
+        """Filter non remasters.
 
         :param artist: usually self
         :param album: the album to check
@@ -733,7 +803,7 @@ class Artist(Tracklist):
         return self.TYPE_REGEXES["remaster"].search(album.title) is not None
 
     def _non_albums(self, album: Album) -> bool:
-        """This will ignore non-album releases.
+        """Filter releases that are not albums.
 
         :param artist: usually self
         :param album: the album to check
@@ -752,19 +822,22 @@ class Artist(Tracklist):
         return f"<Artist: {self.name}>"
 
     def __str__(self) -> str:
-        """Return a readable string representation of
-        this Artist.
+        """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."""
+
     def load_meta(self):
+        """Load metadata given an id."""
         assert self.client.source == "qobuz", "Label source must be qobuz"
 
         resp = self.client.get(self.id, "label")
@@ -775,11 +848,11 @@ class Label(Artist):
         self.loaded = True
 
     def __repr__(self):
+        """Return a string representation of the Label."""
         return f"<Label - {self.name}>"
 
     def __str__(self) -> str:
-        """Return a readable string representation of
-        this track.
+        """Return the name of the Label.
 
         :rtype: str
         """
@@ -790,7 +863,7 @@ class Label(Artist):
 
 
 def _get_tracklist(resp: dict, source: str) -> list:
-    """Returns the tracklist from an API response.
+    """Return the tracklist from an API response.
 
     :param resp:
     :type resp: dict
diff --git a/streamrip/utils.py b/streamrip/utils.py
index d643014..947bcd4 100644
--- a/streamrip/utils.py
+++ b/streamrip/utils.py
@@ -1,3 +1,5 @@
+"""Miscellaneous utility functions."""
+
 import base64
 import contextlib
 import logging
@@ -24,12 +26,20 @@ logger = logging.getLogger(__name__)
 
 
 def safe_get(d: dict, *keys: Hashable, default=None):
-    """A replacement for chained `get()` statements on dicts:
-    >>> d = {'foo': {'bar': 'baz'}}
-    >>> _safe_get(d, 'baz')
-    None
-    >>> _safe_get(d, 'foo', 'bar')
-    'baz'
+    """Traverse dict layers safely.
+
+    Usage:
+        >>> d = {'foo': {'bar': 'baz'}}
+        >>> _safe_get(d, 'baz')
+        None
+        >>> _safe_get(d, 'foo', 'bar')
+        'baz'
+
+    :param d:
+    :type d: dict
+    :param keys:
+    :type keys: Hashable
+    :param default: the default value to use if a key isn't found
     """
     curr = d
     res = default
@@ -43,10 +53,9 @@ def safe_get(d: dict, *keys: Hashable, default=None):
 
 
 def get_quality(quality_id: int, source: str) -> Union[str, int]:
-    """Given the quality id in (0, 1, 2, 3, 4), return the streaming quality
-    value to send to the api for a given source.
+    """Get the source-specific quality id.
 
-    :param quality_id: the 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
@@ -82,8 +91,7 @@ def get_quality(quality_id: int, source: str) -> Union[str, int]:
 
 
 def get_quality_id(bit_depth: Optional[int], sampling_rate: Optional[int]):
-    """Return a quality id in (5, 6, 7, 27) from bit depth and
-    sampling rate. If None is provided, mp3/lossy is assumed.
+    """Get the universal quality id from bit depth and sampling rate.
 
     :param bit_depth:
     :type bit_depth: Optional[int]
@@ -104,22 +112,8 @@ def get_quality_id(bit_depth: Optional[int], sampling_rate: Optional[int]):
         return 4
 
 
-@contextlib.contextmanager
-def std_out_err_redirect_tqdm():
-    orig_out_err = sys.stdout, sys.stderr
-    try:
-        sys.stdout, sys.stderr = map(DummyTqdmFile, orig_out_err)
-        yield orig_out_err[0]
-    # Relay exceptions
-    except Exception as exc:
-        raise exc
-    # Always restore sys.stdout/err if necessary
-    finally:
-        sys.stdout, sys.stderr = orig_out_err
-
-
 def tqdm_download(url: str, filepath: str, params: dict = None, desc: str = None):
-    """Downloads a file with a progress bar.
+    """Download a file with a progress bar.
 
     :param url: url to direct download
     :param filepath: file to write
@@ -159,7 +153,7 @@ def tqdm_download(url: str, filepath: str, params: dict = None, desc: str = None
 
 
 def clean_format(formatter: str, format_info):
-    """Formats track or folder names sanitizing every formatter key.
+    """Format track or folder names sanitizing every formatter key.
 
     :param formatter:
     :type formatter: str
@@ -182,6 +176,11 @@ def clean_format(formatter: str, format_info):
 
 
 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}"
 
@@ -204,6 +203,12 @@ def init_log(path: Optional[str] = None, level: str = "DEBUG"):
 
 
 def decrypt_mqa_file(in_path, out_path, encryption_key):
+    """Decrypt an MQA file.
+
+    :param in_path:
+    :param out_path:
+    :param encryption_key:
+    """
     # Do not change this
     master_key = "UIlTTEMmmLfGowo/UC60x2H45W6MdGgTRfo/umg4754="
 
@@ -235,6 +240,13 @@ def decrypt_mqa_file(in_path, out_path, encryption_key):
 
 
 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"
@@ -247,6 +259,16 @@ def ext(quality: int, source: str):
 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 = {}
 
@@ -291,8 +313,9 @@ def extract_interpreter_url(url: str) -> str:
 
 
 def get_container(quality: int, source: str) -> str:
-    """Get the "container" given the quality. `container` can also be the
-    the codec; both work.
+    """Get the file container given the quality.
+
+    `container` can also be the the codec; both work.
 
     :param quality: quality id
     :type quality: int