Diamond75/zotify
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

merge into: Diamond75:v1.0-dev
Branches Tags
Diamond75:v1.0-dev
Diamond75:main
...
pull from: Diamond75:main
Branches Tags
Diamond75:v1.0-dev
Diamond75:main

No commits in common. "v1.0-dev" and "main" have entirely different histories.
v1.0-dev ... main

34 changed files with 2185 additions and 3428 deletions
Show stats Expand all files Collapse all files

27
.github/workflows/pushmirror.yml vendored Normal file
View file

@ -0,0 +1,27 @@
name: Push mirror
on:
pull_request:
types: [closed]
jobs:
push:
if: github.event.pull_request.merged == true
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: setup git
run: |
git config user.name "GitHub Actions Bot"
git config user.email "<>"
- name: set upstream
run: |
git remote set-url origin https://x-access-token:${{ secrets.GITEA_TOKEN }}@zotify.xyz/zotify/zotify
git remote add old https://x-access-token:${{ secrets.GH_TOKEN }}@github.com/zotify-dev/zotify
- name: push repo
run: |
git fetch --unshallow old
git push

39
.gitignore vendored
View file

@ -1,5 +1,6 @@
# Byte-compiled / optimized / DLL files
__pycache__/
src/__pycache__/
*.py[cod]
*$py.class
@ -94,22 +95,7 @@ ipython_config.py
# install all needed dependencies.
#Pipfile.lock
# poetry
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
#poetry.lock
# pdm
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
#pdm.lock
# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
# in version control.
# https://pdm.fming.dev/#use-with-ide
.pdm.toml
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
@ -152,13 +138,16 @@ dmypy.json
# Cython debug symbols
cython_debug/
# PyCharm
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
# MacOS file
.DS_Store
.vscode/*
!.vscode/extensions.json
!.vscode/settings.json
# IDE settings
.vscode/
.idea/
# Configuration
.zotify/
#Download Folder
Zotify\ Music/
Zotify\ Podcasts/

15
.vscode/extensions.json vendored
View file

@ -1,15 +0,0 @@
{
// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
// List of extensions which should be recommended for users of this workspace.
"recommendations": [
"matangover.mypy",
"ms-python.black-formatter",
"ms-python.flake8"
],
// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
"unwantedRecommendations": [
]
}

9
.vscode/settings.json vendored
View file

@ -1,9 +0,0 @@
{
"editor.formatOnSave": true,
"editor.codeActionsOnSave": {
"source.organizeImports": "explicit"
},
"[python]": {
"editor.defaultFormatter": "ms-python.black-formatter"
},
}

206
CHANGELOG.md
View file

@ -1,120 +1,120 @@
# STILL IN DEVELOPMENT, EVERYTHING HERE IS SUBJECT TO CHANGE
# Changelog
## UNRELEASED
## 0.6.13
- Only replace chars with _ when required
- Added defaults to README
### Changes
## 0.6.12
- Dockerfile works again
- Fixed lrc file extension replacement
- Fixed lrc file writes breaking on non-utf8 systems
- Changed music-tag package used to a mirror of the repository hosted at zotify.xyz, in case it goes down again.
## 0.6.11
- Add new scope for reading followed artists
- Print API errors by default
### Additions
## 0.6.10
- Fix cover art size once and for all
- Added `--download-real-time` feature back.
- Added implementation for `--skip-previous` as it was included as a config parameter but was unimplemented.
- Added implementation for `--skip-duplicates` as it was included as a config parameter but was unimplemented. Note that tracks must have the trackid metadata for this to work.
- Added `-m` or `--match` flag to match output track filenames to files already existing in the same playlist/album folder and write their corresponding trackid metadata
## 0.6.9
- Fix low resolution cover art
- Fix crash when missing ffmpeg
### Removals
## 0.6.8
- Improve check for direct download availability of podcasts
- `--archive` to be removed as it is not used for `--skip-previous` and `--skip-duplicates`
## 0.6.7
- Temporary fix for upstream protobuf error
### Fixes
## v0.6.6
- Added `-f` / `--followed` option to download every song by all of your followed artists
- Fixed config.json being ignored.
- Fixed redownloading songs that are already present in destination folder. They are no longer redownloaded.
- Fixed `Unsupported content type "playlist"` error when local files are included in the playlist. Local files are skipped.
- Fixed `RuntimeError: Cannot get alternative track` from terminating the program.
- Fixed downloading multiple collections from downloading everything twice.
- Fixed `-d` or `--download` option not detecting the file.
- Fixed `Failed fetching audio key!` error from continuously hitting API rate limits. Implemented a flat rate limiter on calls to API. When usage traffic is high and rate limits are hit on the server end, the current track is skipped and the program will continue at a reduced internal rate limit.
## v0.6.5
- Implemented more stable fix for bug still persisting after v0.6.4
## v1.0.0
## v0.6.4
- Fixed upstream bug causing tracks to not download fully
### BREAKING CHANGES AHEAD
## 0.6.3
- Less stupid single format
- Fixed error in json fetching
- Default to search if no other option is provided
- Most components have been completely rewritten to address some fundamental design issues with the previous codebase, This update will provide a better base for new features in the future.
- ~~Some~~ Most configuration options have been renamed, please check your configuration file.
- There is a new library path for playlists, existing playlists will stay where they are.
## v0.6.2
- Won't crash if downloading a song with no lyrics and `DOWNLOAD_LYRICS` is set to True
- Fixed visual glitch when entering login info
- Saving genre metadata is now optional (disabled by default) and configurable with the `MD_SAVE_GENRES`/`--md-save-genres` option
- Switched to new loading animation that hopefully renders a little better in Windows command shells
- Username and password can now be entered as arguments with `--username` and `--password` - does **not** take priority over credentials.json
- Added option to disable saving credentials `SAVE_CREDENTIALS`/`--save-credentials` - will still use credentials.json if already exists
- Default output format for singles is now `{artist}/Single - {song_name}/{artist} - {song_name}.{ext}`
### Changes
## v0.6.1
- Added support for synced lyrics (unsynced is synced unavailable)
- Can be configured with the `DOWNLOAD_LYRICS` option in config.json or `--download-lyrics=True/False` as a command line argument
- Username and password login has been replaced with username and token
- Genre metadata available for all tracks
- Boolean command line options are now set like `--save-metadata` or `--no-save-metadata` for True or False
- Setting `--config` (formerly `--config-location`) can be set to "None" to not use any config file
- Search result selector now accepts both comma-seperated and hyphen-seperated values at the same time
- Renamed `--liked`/`-l` to `--liked-tracks`/`-lt`
- Renamed `root_path` and `root_podcast_path` to `album_library` and `podcast_library`
- `--username` and `--password` arguments now take priority over saved credentials
- On Linux both `config.json` and `credentials.json` are now kept under `$XDG_CONFIG_HOME/zotify/`, (`~/.config/zotify/` by default).
- The output template used is now based on track info rather than search result category
- Search queries with spaces no longer need to be in quotes
- File metadata no longer uses sanitized file metadata, this will result in more accurate metadata.
- Replaced ffmpy with custom implementation providing more tags
- Fixed artist download missing some tracks
## v0.6
**General changes**
- Added "DOWNLOAD_QUALITY" config option. This can be "normal" (96kbks), "high" (160kpbs), "very-high" (320kpbs, premium only) or "auto" which selects the highest format available for your account automatically.
- The "FORCE_PREMIUM" option has been removed, the same result can be achieved with `--download-quality="very-high"`.
- The "BITRATE" option has been renamed "TRANSCODE_BITRATE" as it now only effects transcodes
- FFmpeg is now semi-optional, not having it installed means you are limited to saving music as ogg vorbis.
- Zotify can now be installed with `pip install https://gitlab.com/team-zotify/zotify/-/archive/main/zotify-main.zip`
- Zotify can be ran from any directory with `zotify [args]`, you no longer need to prefix "python" in the command.
- The -s option now takes search input as a command argument, it will still promt you if no search is given.
- The -ls/--liked-songs option has been shrotened to -l/--liked,
- Singles are now stored in their own folders under the artist folder
- Fixed default config not loading on first run
- Now shows asterisks when entering password
- Switched from os.path to pathlib
- New default config locations:
- Windows: `%AppData%\Roaming\Zotify\config.json`
- Linux: `~/.config/zotify/config.json`
- macOS: `~/Library/Application Support/Zotify/config.json`
- Other/Undetected: `.zotify/config.json`
- You can still use `--config-location` to specify a different location.
- New default credential locations:
- Windows: `%AppData%\Roaming\Zotify\credentials.json`
- Linux: `~/.local/share/zotify/credentials.json`
- macOS: `~/Library/Application Support/Zotify/credentials.json`
- Other/Undetected: `.zotify/credentials.json`
- You can still use `--credentials-location` to specify a different file.
- New default music and podcast locations:
- Windows: `C:\Users\<user>\Music\Zotify Music\` & `C:\Users\<user>\Music\Zotify Podcasts\`
- Linux & macOS: `~/Music/Zotify Music/` & `~/Music/Zotify Podcasts/`
- Other/Undetected: `./Zotify Music/` & `./Zotify Podcasts/`
- You can still use `--root-path` and `--root-podcast-path` respectively to specify a differnt location
### Additions
**Docker**
- Dockerfile is currently broken, it will be fixed soon. \
The Dockerhub image is now discontinued, we will try to switch to GitLab's container registry.
- New library location for playlists `playlist_library`
- Added new command line arguments
- `--library`/`-l` overrides both `album_library` and `podcast_library` options similar to `--output`/`-o`
- `--category`/`-c` will limit search results to a certain type, accepted values are "album", "artist", "playlist", "track", "show", "episode". Accepts multiple choices.
- `--debug` shows full tracebacks on crash instead of just the final error message
- Added new shorthand aliases to some options:
- `-oa` = `--output-album`
- `-opt` = `--output-playlist-track`
- `-ope` = `--output-playlist-episode`
- `-op` = `--output-podcast`
- Search results can be narrowed down using search filters
- Available filters are 'album', 'artist', 'track', 'year', 'upc', 'tag:hipster', 'tag:new', 'isrc', and 'genre'.
- The 'artist' and 'year' filters only shows results from the given year or a range (e.g. 1970-1982).
- The 'album' filter only shows results from the given album(s)
- The 'genre' filter only shows results from the given genre(s)
- The 'isrc' and 'track' filters can be used while searching tracks
- The 'upc', tag:new and tag:hipster filters can only be used while searching albums
- 'tag:new' filter will show albums released within the past two weeks
- 'tag:hipster' will only show albums in the lowest 10% of popularity
- Search has been expanded to include podcasts and episodes
- New output placeholders / metadata tags for tracks
- `{artists}`
- `{album_artist}`
- `{album_artists}`
- `{duration}` (milliseconds)
- `{explicit}`
- `{isrc}`
- `{licensor}`
- `{playlist}`
- `{playlist_number}`
- `{playlist_owner}`
- `{popularity}`
- `{release_date}`
- `{track_number}`
- Genre information is now more accurate and is always enabled
- Added download option for "liked episodes" `--liked-episodes`/`-le`
- Added `save_metadata` option to fully disable writing track metadata
- Added support for ReplayGain
- Added support for transcoding to wav and wavpack formats
- Unsynced lyrics are saved to a txt file instead of lrc
- Unsynced lyrics can now be embedded directly into file metadata (for supported file types)
- Added new option `save_lyrics_file`
- This option only affects the external lyrics files
- Embedded lyrics are controlled with `save_metadata`
**Windows installer**
- The Windows installer is unavilable with this release.
- The current installation system will be replaced and a new version will be available with the next release.
### Removals
- Removed "Zotify" ASCII banner
- Removed search prompt, searches can only be done as cli arguments now.
- Removed song archive files
- Removed `{ext}` option in output formats as file extentions are managed automatically
- Removed `split_album_discs` because the same functionality can be achieved by using output formatting
- Removed `print_api_errors` because API errors are now treated like regular errors
- Removed the following config options due to their corresponding features being removed:
- `bulk_wait_time`
- `chunk_size`
- `download_real_time`
- `md_allgenres`
- `md_genredelimiter`
- `metadata_delimiter`
- `override_auto_wait`
- `retry_attempts`
- `save_genres`
- `temp_download_dir`
## v0.5.2
**General changes**
- Fixed filenaming on Windows
- Fixed removal of special characters metadata
- Can now download different songs with the same name
- Real-time downloads now work correctly
- Removed some debug messages
- Added album_artist metadata
- Added global song archive
- Added SONG_ARCHIVE config value
- Added CREDENTIALS_LOCATION config value
- Added `--download` argument
- Added `--config-location` argument
- Added `--output` for output templating
- Save extra data in .song_ids
- Added options to regulate terminal output
- Direct download support for certain podcasts
**Docker images**
- Remember credentials between container starts
- Use same uid/gid in container as on host
**Windows installer**
- Now comes with full installer
- Dependencies are installed if not found

41
CONTRIBUTING.md Normal file
View file

@ -0,0 +1,41 @@
# Introduction
### Thank you for contributing
Without people like you this project wouldn't be anywhere near as polished and feature-rich as it is now.
### Guidelines
Following these guidelines helps show that you respect the the time and effort spent by the developers and your fellow contributors making this project.
### What we are looking for
Zotify is a community-driven project. There are many different ways to contribute. From providing tutorials and examples to help new users, reporting bugs, requesting new features, writing new code that can be added to the project, or even writing documentation.
### What we aren't looking for
Please don't use the issues section to request help installing or setting up the project. It should be reserved for bugs when running the code, and feature requests. Instead use the support channel in either our Discord or Matrix server.
Please do not make a new pull request just to fix a typo or any small issue like that. We'd rather you just make an issue reporting it and we will fix it in the next commit. This helps to prevent commit spamming.
# Ground rules
### Expectations
* Ensure all code is linted with pylint before pushing.
* Ensure all code passes the [testing criteria](#testing-criteria) (coming soon).
* If you're planning on contributing a new feature, join the Discord or Matrix and discuss it with the Dev Team.
* Please don't commit multiple new features at once.
* Follow the [Python Community Code of Conduct](https://www.python.org/psf/codeofconduct/)
# Your first contribution
Unsure where to start? Have a look for any issues tagged "good first issue". They should be minor bugs that only require a few lines to fix.
Here are a couple of friendly tutorials on making pull requests: http://makeapullrequest.com/ and http://www.firsttimersonly.com/
# Code review process
The dev team looks at Pull Requests around once per day. After feedback has been given we expect responses within one week. After a week we may close the pull request if it isn't showing any activity.
You may be asked by a maintainer to "rebase" your PR, they're saying that a lot of code has changed, and that you need to update your branch so it's easier to merge.
# Community
Come and chat with us on Discord or Matrix. Devs try to respond to mentions at least once per day.

21
Dockerfile Normal file
View file

@ -0,0 +1,21 @@
FROM python:3.9-alpine as base
RUN apk --update add ffmpeg
FROM base as builder
WORKDIR /install
COPY requirements.txt /requirements.txt
RUN apk add gcc libc-dev zlib zlib-dev jpeg-dev
RUN pip install --prefix="/install" -r /requirements.txt
FROM base
COPY --from=builder /install /usr/local/lib/python3.9/site-packages
RUN mv /usr/local/lib/python3.9/site-packages/lib/python3.9/site-packages/* /usr/local/lib/python3.9/site-packages/
COPY zotify /app/zotify
WORKDIR /app
CMD ["python3", "-m", "zotify"]

32
INSTALLATION.md Normal file
View file

@ -0,0 +1,32 @@
### Installing Zotify
> **Windows**
This guide uses *Scoop* (https://scoop.sh) to simplify installing prerequisites and *pipx* to manage Zotify itself.
There are other ways to install and run Zotify on Windows but this is the official recommendation, other methods of installation will not receive support.
- Open PowerShell (cmd will not work)
- Install Scoop by running:
- `Set-ExecutionPolicy RemoteSigned -Scope CurrentUser`
- `irm get.scoop.sh | iex`
- After installing scoop run: `scoop install python ffmpeg-shared git`
- Install pipx:
- `python3 -m pip install --user pipx`
- `python3 -m pipx ensurepath`
Now close PowerShell and reopen it to ensure the pipx command is available.
- Install Zotify with: `pipx install https://get.zotify.xyz`
- Done! Use `zotify --help` for a basic list of commands or check the *README.md* file in Zotify's code repository for full documentation.
> **macOS**
- Open the Terminal app
- Install *Homebrew* (https://brew.sh) by running: `/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`
- After installing Homebrew run: `brew install python@3.11 pipx ffmpeg git`
- Setup pipx: `pipx ensurepath`
- Install Zotify: `pipx install https://get.zotify.xyz`
- Done! Use `zotify --help` for a basic list of commands or check the README.md file in Zotify's code repository for full documentation.
> **Linux (Most Popular Distributions)**
- Install `python3`, `pip` (if a separate package), `ffmpeg`, and `git` from your distribution's package manager or software center.
- Then install pipx, either from your package manager or through pip with: `python3 -m pip install --user pipx`
- Install Zotify `pipx install https://get.zotify.xyz`
- Done! Use `zotify --help` for a basic list of commands or check the README.md file in Zotify's code repository for full documentation.

2
LICENCE → LICENSE
View file

@ -1,4 +1,4 @@
Copyright (c) 2024 Zotify Contributors
Copyright (c) 2022 Zotify Contributors
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages

23
Pipfile
View file

@ -1,23 +0,0 @@
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"
[packages]
librespot = {git = "git+https://github.com/kokarare1212/librespot-python"}
music-tag = {git = "git+https://zotify.xyz/zotify/music-tag"}
mutagen = "*"
pillow = "*"
pkce = "*"
requests = "*"
tqdm = "*"
[dev-packages]
black = "*"
flake8 = "*"
mypy = "*"
types-protobuf = "*"
types-requests = "*"
[requires]
python_version = "3.11"

599
Pipfile.lock generated
View file

@ -1,599 +0,0 @@
{
"_meta": {
"hash": {
"sha256": "9a41882e9856db99151e4f1a3712d4b1562f2997e9a51cfcaf473335cd2db74c"
},
"pipfile-spec": 6,
"requires": {
"python_version": "3.11"
},
"sources": [
{
"name": "pypi",
"url": "https://pypi.org/simple",
"verify_ssl": true
}
]
},
"default": {
"certifi": {
"hashes": [
"sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b",
"sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"
],
"markers": "python_version >= '3.6'",
"version": "==2024.7.4"
},
"charset-normalizer": {
"hashes": [
"sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027",
"sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087",
"sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786",
"sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8",
"sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09",
"sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185",
"sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574",
"sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e",
"sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519",
"sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898",
"sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269",
"sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3",
"sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f",
"sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6",
"sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8",
"sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a",
"sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73",
"sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc",
"sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714",
"sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2",
"sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc",
"sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce",
"sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d",
"sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e",
"sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6",
"sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269",
"sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96",
"sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d",
"sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a",
"sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4",
"sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77",
"sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d",
"sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0",
"sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed",
"sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068",
"sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac",
"sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25",
"sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8",
"sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab",
"sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26",
"sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2",
"sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db",
"sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f",
"sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5",
"sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99",
"sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c",
"sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d",
"sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811",
"sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa",
"sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a",
"sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03",
"sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b",
"sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04",
"sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c",
"sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001",
"sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458",
"sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389",
"sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99",
"sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985",
"sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537",
"sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238",
"sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f",
"sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d",
"sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796",
"sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a",
"sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143",
"sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8",
"sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c",
"sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5",
"sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5",
"sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711",
"sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4",
"sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6",
"sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c",
"sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7",
"sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4",
"sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b",
"sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae",
"sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12",
"sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c",
"sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae",
"sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8",
"sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887",
"sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b",
"sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4",
"sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f",
"sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5",
"sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33",
"sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519",
"sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"
],
"markers": "python_full_version >= '3.7.0'",
"version": "==3.3.2"
},
"defusedxml": {
"hashes": [
"sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69",
"sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"
],
"markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
"version": "==0.7.1"
},
"idna": {
"hashes": [
"sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc",
"sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"
],
"markers": "python_version >= '3.5'",
"version": "==3.7"
},
"ifaddr": {
"hashes": [
"sha256:085e0305cfe6f16ab12d72e2024030f5d52674afad6911bb1eee207177b8a748",
"sha256:cc0cbfcaabf765d44595825fb96a99bb12c79716b73b44330ea38ee2b0c4aed4"
],
"version": "==0.2.0"
},
"librespot": {
"git": "git+https://github.com/kokarare1212/librespot-python",
"ref": "3b46fe560ad829b976ce63e85012cff95b1e0bf3"
},
"music-tag": {
"git": "git+https://zotify.xyz/zotify/music-tag",
"ref": "5c73ddf11a6d65d6575c0e1bb8cce8413f46a433"
},
"mutagen": {
"hashes": [
"sha256:719fadef0a978c31b4cf3c956261b3c58b6948b32023078a2117b1de09f0fc99",
"sha256:edd96f50c5907a9539d8e5bba7245f62c9f520aef333d13392a79a4f70aca719"
],
"index": "pypi",
"markers": "python_version >= '3.7'",
"version": "==1.47.0"
},
"pillow": {
"hashes": [
"sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885",
"sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea",
"sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df",
"sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5",
"sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c",
"sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d",
"sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd",
"sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06",
"sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908",
"sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a",
"sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be",
"sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0",
"sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b",
"sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80",
"sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a",
"sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e",
"sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9",
"sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696",
"sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b",
"sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309",
"sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e",
"sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab",
"sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d",
"sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060",
"sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d",
"sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d",
"sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4",
"sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3",
"sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6",
"sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb",
"sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94",
"sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b",
"sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496",
"sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0",
"sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319",
"sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b",
"sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856",
"sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef",
"sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680",
"sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b",
"sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42",
"sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e",
"sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597",
"sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a",
"sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8",
"sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3",
"sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736",
"sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da",
"sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126",
"sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd",
"sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5",
"sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b",
"sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026",
"sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b",
"sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc",
"sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46",
"sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2",
"sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c",
"sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe",
"sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984",
"sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a",
"sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70",
"sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca",
"sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b",
"sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91",
"sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3",
"sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84",
"sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1",
"sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5",
"sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be",
"sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f",
"sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc",
"sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9",
"sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e",
"sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141",
"sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef",
"sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22",
"sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27",
"sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e",
"sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==10.4.0"
},
"pkce": {
"hashes": [
"sha256:55927e24c7d403b2491ebe182b95d9dcb1807643243d47e3879fbda5aad4471d",
"sha256:9775fd76d8a743d39b87df38af1cd04a58c9b5a5242d5a6350ef343d06814ab6"
],
"index": "pypi",
"markers": "python_version >= '3'",
"version": "==1.0.3"
},
"protobuf": {
"hashes": [
"sha256:06059eb6953ff01e56a25cd02cca1a9649a75a7e65397b5b9b4e929ed71d10cf",
"sha256:097c5d8a9808302fb0da7e20edf0b8d4703274d140fd25c5edabddcde43e081f",
"sha256:284f86a6207c897542d7e956eb243a36bb8f9564c1742b253462386e96c6b78f",
"sha256:32ca378605b41fd180dfe4e14d3226386d8d1b002ab31c969c366549e66a2bb7",
"sha256:3cc797c9d15d7689ed507b165cd05913acb992d78b379f6014e013f9ecb20996",
"sha256:62f1b5c4cd6c5402b4e2d63804ba49a327e0c386c99b1675c8a0fefda23b2067",
"sha256:69ccfdf3657ba59569c64295b7d51325f91af586f8d5793b734260dfe2e94e2c",
"sha256:6f50601512a3d23625d8a85b1638d914a0970f17920ff39cec63aaef80a93fb7",
"sha256:7403941f6d0992d40161aa8bb23e12575637008a5a02283a930addc0508982f9",
"sha256:755f3aee41354ae395e104d62119cb223339a8f3276a0cd009ffabfcdd46bb0c",
"sha256:77053d28427a29987ca9caf7b72ccafee011257561259faba8dd308fda9a8739",
"sha256:7e371f10abe57cee5021797126c93479f59fccc9693dafd6bd5633ab67808a91",
"sha256:9016d01c91e8e625141d24ec1b20fed584703e527d28512aa8c8707f105a683c",
"sha256:9be73ad47579abc26c12024239d3540e6b765182a91dbc88e23658ab71767153",
"sha256:adc31566d027f45efe3f44eeb5b1f329da43891634d61c75a5944e9be6dd42c9",
"sha256:adfc6cf69c7f8c50fd24c793964eef18f0ac321315439d94945820612849c388",
"sha256:af0ebadc74e281a517141daad9d0f2c5d93ab78e9d455113719a45a49da9db4e",
"sha256:cb29edb9eab15742d791e1025dd7b6a8f6fcb53802ad2f6e3adcb102051063ab",
"sha256:cd68be2559e2a3b84f517fb029ee611546f7812b1fdd0aa2ecc9bc6ec0e4fdde",
"sha256:cdee09140e1cd184ba9324ec1df410e7147242b94b5f8b0c64fc89e38a8ba531",
"sha256:db977c4ca738dd9ce508557d4fce0f5aebd105e158c725beec86feb1f6bc20d8",
"sha256:dd5789b2948ca702c17027c84c2accb552fc30f4622a98ab5c51fcfe8c50d3e7",
"sha256:e250a42f15bf9d5b09fe1b293bdba2801cd520a9f5ea2d7fb7536d4441811d20",
"sha256:ff8d8fa42675249bb456f5db06c00de6c2f4c27a065955917b28c4f15978b9c3"
],
"markers": "python_version >= '3.7'",
"version": "==3.20.1"
},
"pycryptodomex": {
"hashes": [
"sha256:0daad007b685db36d977f9de73f61f8da2a7104e20aca3effd30752fd56f73e1",
"sha256:108e5f1c1cd70ffce0b68739c75734437c919d2eaec8e85bffc2c8b4d2794305",
"sha256:19764605feea0df966445d46533729b645033f134baeb3ea26ad518c9fdf212c",
"sha256:1be97461c439a6af4fe1cf8bf6ca5936d3db252737d2f379cc6b2e394e12a458",
"sha256:25cd61e846aaab76d5791d006497134602a9e451e954833018161befc3b5b9ed",
"sha256:2a47bcc478741b71273b917232f521fd5704ab4b25d301669879e7273d3586cc",
"sha256:59af01efb011b0e8b686ba7758d59cf4a8263f9ad35911bfe3f416cee4f5c08c",
"sha256:5dcac11031a71348faaed1f403a0debd56bf5404232284cf8c761ff918886ebc",
"sha256:62a5ec91388984909bb5398ea49ee61b68ecb579123694bffa172c3b0a107079",
"sha256:645bd4ca6f543685d643dadf6a856cc382b654cc923460e3a10a49c1b3832aeb",
"sha256:653b29b0819605fe0898829c8ad6400a6ccde096146730c2da54eede9b7b8baa",
"sha256:69138068268127cd605e03438312d8f271135a33140e2742b417d027a0539427",
"sha256:6e186342cfcc3aafaad565cbd496060e5a614b441cacc3995ef0091115c1f6c5",
"sha256:76bd15bb65c14900d98835fcd10f59e5e0435077431d3a394b60b15864fddd64",
"sha256:7805830e0c56d88f4d491fa5ac640dfc894c5ec570d1ece6ed1546e9df2e98d6",
"sha256:7a710b79baddd65b806402e14766c721aee8fb83381769c27920f26476276c1e",
"sha256:7a7a8f33a1f1fb762ede6cc9cbab8f2a9ba13b196bfaf7bc6f0b39d2ba315a43",
"sha256:82ee7696ed8eb9a82c7037f32ba9b7c59e51dda6f105b39f043b6ef293989cb3",
"sha256:88afd7a3af7ddddd42c2deda43d53d3dfc016c11327d0915f90ca34ebda91499",
"sha256:8af1a451ff9e123d0d8bd5d5e60f8e3315c3a64f3cdd6bc853e26090e195cdc8",
"sha256:8ee606964553c1a0bc74057dd8782a37d1c2bc0f01b83193b6f8bb14523b877b",
"sha256:91852d4480a4537d169c29a9d104dda44094c78f1f5b67bca76c29a91042b623",
"sha256:9c682436c359b5ada67e882fec34689726a09c461efd75b6ea77b2403d5665b7",
"sha256:bc3ee1b4d97081260d92ae813a83de4d2653206967c4a0a017580f8b9548ddbc",
"sha256:bca649483d5ed251d06daf25957f802e44e6bb6df2e8f218ae71968ff8f8edc4",
"sha256:c39778fd0548d78917b61f03c1fa8bfda6cfcf98c767decf360945fe6f97461e",
"sha256:cbe71b6712429650e3883dc81286edb94c328ffcd24849accac0a4dbcc76958a",
"sha256:d00fe8596e1cc46b44bf3907354e9377aa030ec4cd04afbbf6e899fc1e2a7781",
"sha256:d3584623e68a5064a04748fb6d76117a21a7cb5eaba20608a41c7d0c61721794",
"sha256:e48217c7901edd95f9f097feaa0388da215ed14ce2ece803d3f300b4e694abea",
"sha256:f2e497413560e03421484189a6b65e33fe800d3bd75590e6d78d4dfdb7accf3b",
"sha256:ff5c9a67f8a4fba4aed887216e32cbc48f2a6fb2673bb10a99e43be463e15913"
],
"markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
"version": "==3.20.0"
},
"pyogg": {
"hashes": [
"sha256:40f79b288b3a667309890885f4cf53371163b7dae17eb17567fb24ab467eca26",
"sha256:794db340fb5833afb4f493b40f91e3e0f594606fd4b31aea0ebf5be2de9da964",
"sha256:8294b34aa59c90200c4630c2cc4a5b84407209141e8e5d069d7a5be358e94262"
],
"version": "==0.6.14a1"
},
"requests": {
"hashes": [
"sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760",
"sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==2.32.3"
},
"tqdm": {
"hashes": [
"sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644",
"sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb"
],
"index": "pypi",
"markers": "python_version >= '3.7'",
"version": "==4.66.4"
},
"urllib3": {
"hashes": [
"sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472",
"sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"
],
"markers": "python_version >= '3.8'",
"version": "==2.2.2"
},
"websocket-client": {
"hashes": [
"sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526",
"sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"
],
"markers": "python_version >= '3.8'",
"version": "==1.8.0"
},
"zeroconf": {
"hashes": [
"sha256:06203c23a82b69aca9e961da675600dff19026bb22b5d042f18f9e0ff1139ed3",
"sha256:0b0d2ffc4bafbcc4152067bfbc1a67074d23e6100e356424bd985ca8067a2bfd",
"sha256:13beed15eed7e569fd56dbe16c7cb758f81c661d53ec253fbf9cfe7a20e28b7c",
"sha256:1a95025f0949ed0e873e141d482fbbefa223ef90646443e4a1d6d47f50eb89d7",
"sha256:1c932b15848ae6b8e4b2b50c65368e396d000fea95acd473611693dbe5a00096",
"sha256:1f09b692219abf9b1ca28364d6f4eb283a4c676e30c905933d1694cbd321bc4b",
"sha256:28b1721617ddc9bf3d2ba3e2b96234f7539e1dbdcacaf6e94ec31ff7b5ebe620",
"sha256:31c8406f62251aa62f5b67d865007ffd1dd929eae9027166ffa6bccca69253bd",
"sha256:390feb3e7fccdffbf66c9bcd895b1db92e501aa2789d6a8b44e6e027ab80ec14",
"sha256:3ad2fe0cbfebe20612c9a5390075a2b3a258a78928f5b7b5163be1699cc528f0",
"sha256:3bd0cd9435dced8c31491b3ed7c15707acedd11f00451f7fbb57ba3868dd5724",
"sha256:3eb0e57654e139c3ef5b6421053236be4a0add9f0301b01545b11a0552c7c123",
"sha256:4754dfba1af63545dfd0ab26c834c907e1dd3f94c8ee190c3041a6444313aaed",
"sha256:48275e3db89a8d90ff983c3f7b0c6eee2ede3c4e5e75eaf2aa571ea8cb956d95",
"sha256:4dd7d8fdee36cc6bde0bcb08b79375009de7a76d935d1401b6ae4b62505b9ee0",
"sha256:4e83e18722d0bdc2e603f7ca104adf276d5728a664b9e94c99e2d8c02001429c",
"sha256:5354c1cf83d36b2d03ee5774923d30fe838f9371963b42ca46ecba45d3507ff4",
"sha256:5586bc773d6cee4f9a14692f5e6bc6387ddb54b2bfae0db01c0695aac20c420a",
"sha256:56146e66774c30e238088f67be47740ffd4f669c08e76f2e470bd611d7bdae46",
"sha256:59953e8445e69e5fee53381c437d3494f7fac8d7b51f0169d59b69eba8f95063",
"sha256:5b6cfc2b62e6282eabbcb6c7223b0a8c05ed3a326e7b467d06b85a3eeda1bfc8",
"sha256:5c8c2eeb838538fffaa421f9b3f9c671778886595b5aa0d4ef4d000531e721d2",
"sha256:6732b224be7e69f7c77798e50205f8e92646ab59724151d66d8dc97f92e99a77",
"sha256:700bae69eb7c45037deef4a729586f32205d391de38802e2ab89151a7a87d1fc",
"sha256:76d12185c335c14b04b8706b4dd0badc16f4185caeb635419c84e575cef7c980",
"sha256:779d81aac693e57090343ce5b18f477fec993f969aa87660a33e7ce81880ccdf",
"sha256:82678a77e471dd3b0ad5ed47a4a42474af3150819718eff7e36dca32ae591949",
"sha256:87b6e92a869932f4aac3076816a1b987c581b01e49a08e495bef7165be049dfd",
"sha256:9228c512334905338f65825102e47778e5ce034bb4249c3deb22991826ed061f",
"sha256:9ad8bc6e3f168fe8c164634c762d3265c775643defff10e26273623a12d73ae1",
"sha256:9c295b424a271ce5022da83a1274b4cd0f696c5b8e0c190e6a28efde8b36e82d",
"sha256:9d364a929121df5b96af53ac62abdd61fa3a931e74c7a4c80204c961c01a8667",
"sha256:a2fa3a89f6a0cf03a56141dad158634a009a22fbe645c7c01e85edc12a0a239f",
"sha256:a37fe4f302edb8d931a4c386d0944f996e3f54717495636113880c4492ab479f",
"sha256:a49b13ec79edff347b1e7af65f5843719ca151ef071ac6b2ff564bb69d164331",
"sha256:b20036ab22df2fb663f797b110fa82d4798084fcc56c8a264af50989581062be",
"sha256:b3dd7143dfc37a20f7d1ccf32f916ac78c11d3c8bae61438ee06376b1bc535fc",
"sha256:b60b260c70bb77d7f3b666bdd2a2a74cead5e36814f8b4295778bcdd08f65c7e",
"sha256:c50ee0df6b0b06f1dad6261670b5be53c909b9a2b1985bcf65ea5b0d766fd10e",
"sha256:ca46637fcc0386fdbe6bde447184ed981499c8c1b5b5fcaa0f35c3b15528162a",
"sha256:d4bc5e43d02e0848c3174914595dfcebed9b74e65cbdfb1011c5082db7916605",
"sha256:d6c05af8b49c442422ce49565ab41a094b23e0f5692abe1533428cbe35a78f8e",
"sha256:d80bde641349198c8c17684692a8cc40a36a93c0cebd8f1d7c42db7ceeaa17be",
"sha256:db8607a32347da1fd4519cfea441d8b36b44df0c53198ae0471c76fc932a86e0",
"sha256:ddae9592604fe04ec065cc53a321844c3592c812988346136d8ee548127f3d12",
"sha256:e1031c7c5f8516108e7c24190179e6a522183de218a954681a341ee818f8079a",
"sha256:e36f50a963d149bb7152543db9bdbd73f7997e66b57b7956fc17751f55e59625",
"sha256:e7e2c398679c863e810a9af2c5d14542a32d438e3bf5ba0b9d8e119326c33303",
"sha256:f2b26c23efeded0e7fcfd0fb4d638ec4a83d120e1d455267d353090e36479528",
"sha256:f56ec955f43f944985f857c9d23030362df52e14a7c53c64bf8b29cfadebd601",
"sha256:f9a28b0416a36ec32273ee1ac80cc72ff9b06d1cb15a9481dcd5c92bd2bc8f03"
],
"markers": "python_version >= '3.8' and python_version < '4.0'",
"version": "==0.132.2"
}
},
"develop": {
"black": {
"hashes": [
"sha256:257d724c2c9b1660f353b36c802ccece186a30accc7742c176d29c146df6e474",
"sha256:37aae07b029fa0174d39daf02748b379399b909652a806e5708199bd93899da1",
"sha256:415e686e87dbbe6f4cd5ef0fbf764af7b89f9057b97c908742b6008cc554b9c0",
"sha256:48a85f2cb5e6799a9ef05347b476cce6c182d6c71ee36925a6c194d074336ef8",
"sha256:7768a0dbf16a39aa5e9a3ded568bb545c8c2727396d063bbaf847df05b08cd96",
"sha256:7e122b1c4fb252fd85df3ca93578732b4749d9be076593076ef4d07a0233c3e1",
"sha256:88c57dc656038f1ab9f92b3eb5335ee9b021412feaa46330d5eba4e51fe49b04",
"sha256:8e537d281831ad0e71007dcdcbe50a71470b978c453fa41ce77186bbe0ed6021",
"sha256:98e123f1d5cfd42f886624d84464f7756f60ff6eab89ae845210631714f6db94",
"sha256:accf49e151c8ed2c0cdc528691838afd217c50412534e876a19270fea1e28e2d",
"sha256:b1530ae42e9d6d5b670a34db49a94115a64596bc77710b1d05e9801e62ca0a7c",
"sha256:b9176b9832e84308818a99a561e90aa479e73c523b3f77afd07913380ae2eab7",
"sha256:bdde6f877a18f24844e381d45e9947a49e97933573ac9d4345399be37621e26c",
"sha256:be8bef99eb46d5021bf053114442914baeb3649a89dc5f3a555c88737e5e98fc",
"sha256:bf10f7310db693bb62692609b397e8d67257c55f949abde4c67f9cc574492cc7",
"sha256:c872b53057f000085da66a19c55d68f6f8ddcac2642392ad3a355878406fbd4d",
"sha256:d36ed1124bb81b32f8614555b34cc4259c3fbc7eec17870e8ff8ded335b58d8c",
"sha256:da33a1a5e49c4122ccdfd56cd021ff1ebc4a1ec4e2d01594fef9b6f267a9e741",
"sha256:dd1b5a14e417189db4c7b64a6540f31730713d173f0b63e55fabd52d61d8fdce",
"sha256:e151054aa00bad1f4e1f04919542885f89f5f7d086b8a59e5000e6c616896ffb",
"sha256:eaea3008c281f1038edb473c1aa8ed8143a5535ff18f978a318f10302b254063",
"sha256:ef703f83fc32e131e9bcc0a5094cfe85599e7109f896fe8bc96cc402f3eb4b6e"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==24.4.2"
},
"click": {
"hashes": [
"sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28",
"sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"
],
"markers": "python_version >= '3.7'",
"version": "==8.1.7"
},
"flake8": {
"hashes": [
"sha256:2e416edcc62471a64cea09353f4e7bdba32aeb079b6e360554c659a122b1bc6a",
"sha256:48a07b626b55236e0fb4784ee69a465fbf59d79eec1f5b4785c3d3bc57d17aa5"
],
"index": "pypi",
"markers": "python_full_version >= '3.8.1'",
"version": "==7.1.0"
},
"mccabe": {
"hashes": [
"sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325",
"sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"
],
"markers": "python_version >= '3.6'",
"version": "==0.7.0"
},
"mypy": {
"hashes": [
"sha256:0624bdb940255d2dd24e829d99a13cfeb72e4e9031f9492148f410ed30bcab54",
"sha256:0bc71d1fb27a428139dd78621953effe0d208aed9857cb08d002280b0422003a",
"sha256:0bd53faf56de9643336aeea1c925012837432b5faf1701ccca7fde70166ccf72",
"sha256:11965c2f571ded6239977b14deebd3f4c3abd9a92398712d6da3a772974fad69",
"sha256:1a81cf05975fd61aec5ae16501a091cfb9f605dc3e3c878c0da32f250b74760b",
"sha256:2684d3f693073ab89d76da8e3921883019ea8a3ec20fa5d8ecca6a2db4c54bbe",
"sha256:2c63350af88f43a66d3dfeeeb8d77af34a4f07d760b9eb3a8697f0386c7590b4",
"sha256:45df906e8b6804ef4b666af29a87ad9f5921aad091c79cc38e12198e220beabd",
"sha256:4c956b49c5d865394d62941b109728c5c596a415e9c5b2be663dd26a1ff07bc0",
"sha256:64f4a90e3ea07f590c5bcf9029035cf0efeae5ba8be511a8caada1a4893f5525",
"sha256:749fd3213916f1751fff995fccf20c6195cae941dc968f3aaadf9bb4e430e5a2",
"sha256:79c07eb282cb457473add5052b63925e5cc97dfab9812ee65a7c7ab5e3cb551c",
"sha256:7b6343d338390bb946d449677726edf60102a1c96079b4f002dedff375953fc5",
"sha256:886c9dbecc87b9516eff294541bf7f3655722bf22bb898ee06985cd7269898de",
"sha256:a2b43895a0f8154df6519706d9bca8280cda52d3d9d1514b2d9c3e26792a0b74",
"sha256:a32fc80b63de4b5b3e65f4be82b4cfa362a46702672aa6a0f443b4689af7008c",
"sha256:a707ec1527ffcdd1c784d0924bf5cb15cd7f22683b919668a04d2b9c34549d2e",
"sha256:a831671bad47186603872a3abc19634f3011d7f83b083762c942442d51c58d58",
"sha256:b639dce63a0b19085213ec5fdd8cffd1d81988f47a2dec7100e93564f3e8fb3b",
"sha256:b868d3bcff720dd7217c383474008ddabaf048fad8d78ed948bb4b624870a417",
"sha256:c1952f5ea8a5a959b05ed5f16452fddadbaae48b5d39235ab4c3fc444d5fd411",
"sha256:d44be7551689d9d47b7abc27c71257adfdb53f03880841a5db15ddb22dc63edb",
"sha256:e1e30dc3bfa4e157e53c1d17a0dad20f89dc433393e7702b813c10e200843b03",
"sha256:e4fe9f4e5e521b458d8feb52547f4bade7ef8c93238dfb5bbc790d9ff2d770ca",
"sha256:f39918a50f74dc5969807dcfaecafa804fa7f90c9d60506835036cc1bc891dc8",
"sha256:f404a0b069709f18bbdb702eb3dcfe51910602995de00bd39cea3050b5772d08",
"sha256:fca4a60e1dd9fd0193ae0067eaeeb962f2d79e0d9f0f66223a0682f26ffcc809"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==1.11.1"
},
"mypy-extensions": {
"hashes": [
"sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d",
"sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"
],
"markers": "python_version >= '3.5'",
"version": "==1.0.0"
},
"packaging": {
"hashes": [
"sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002",
"sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"
],
"markers": "python_version >= '3.8'",
"version": "==24.1"
},
"pathspec": {
"hashes": [
"sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08",
"sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"
],
"markers": "python_version >= '3.8'",
"version": "==0.12.1"
},
"platformdirs": {
"hashes": [
"sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee",
"sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"
],
"markers": "python_version >= '3.8'",
"version": "==4.2.2"
},
"pycodestyle": {
"hashes": [
"sha256:442f950141b4f43df752dd303511ffded3a04c2b6fb7f65980574f0c31e6e79c",
"sha256:949a39f6b86c3e1515ba1787c2022131d165a8ad271b11370a8819aa070269e4"
],
"markers": "python_version >= '3.8'",
"version": "==2.12.0"
},
"pyflakes": {
"hashes": [
"sha256:1c61603ff154621fb2a9172037d84dca3500def8c8b630657d1701f026f8af3f",
"sha256:84b5be138a2dfbb40689ca07e2152deb896a65c3a3e24c251c5c62489568074a"
],
"markers": "python_version >= '3.8'",
"version": "==3.2.0"
},
"types-protobuf": {
"hashes": [
"sha256:683ba14043bade6785e3f937a7498f243b37881a91ac8d81b9202ecf8b191e9c",
"sha256:688e8f7e8d9295db26bc560df01fb731b27a25b77cbe4c1ce945647f7024f5c1"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==5.27.0.20240626"
},
"types-requests": {
"hashes": [
"sha256:90c079ff05e549f6bf50e02e910210b98b8ff1ebdd18e19c873cd237737c1358",
"sha256:f754283e152c752e46e70942fa2a146b5bc70393522257bb85bd1ef7e019dcc3"
],
"index": "pypi",
"markers": "python_version >= '3.8'",
"version": "==2.32.0.20240712"
},
"typing-extensions": {
"hashes": [
"sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d",
"sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"
],
"markers": "python_version >= '3.8'",
"version": "==4.12.2"
},
"urllib3": {
"hashes": [
"sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472",
"sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"
],
"markers": "python_version >= '3.8'",
"version": "==2.2.2"
}
}
}

250
README.md
View file

@ -1,141 +1,161 @@
![Logo banner](./assets/banner.png)
# Zotify
This is a fork of Zotify's [dev branch](https://github.com/zotify-dev/zotify/tree/v1.0-dev) which hasn't seen any activity for months. This fork will be updated to include missing/unimplemented features and maintained by yours truly until the original developers decide to come home with the milk.
### A highly customizable music and podcast downloader.
A customizable music and podcast downloader. \
Built on [Librespot](https://github.com/kokarare1212/librespot-python).
<p align="center">
<img src="https://i.imgur.com/hGXQWSl.png" width="50%" alt="Zotify logo">
</p>
## Features
### Features
- Downloads at up to 320kbps*
- Downloads directly from the source**
- Downloads podcasts, playlists, liked songs, albums, artists, singles.
- Downloads synced lyrics from the source
- Option to download in real time to appear more legitimate***
- Supports multiple audio formats
- Download directly from URL or use built-in in search
- Bulk downloads from a list of URLs in a text file or parsed directly as arguments
- Save tracks at up to 320kbps<sup>**1**</sup>
- Save to most popular audio formats
- Built in search
- Bulk downloads
- Downloads synced lyrics<sup>**2**</sup>
- Embedded metadata
- Downloads all audio, metadata and lyrics directly, no substituting from other services.
*Free accounts are limited to 160kbps. \
**Audio files are NOT substituted with ones from other sources such as YouTube or Deezer, they are sourced directly. \
***'real time' refers to downloading at the speed it would normally be streamed at (the duration of the track).
**1**: Non-premium accounts are limited to 160kbps \
**2**: Requires premium
### Install
## Installation
```
Dependencies:
Requires Python 3.11 or greater. \
Optionally requires FFmpeg to save tracks as anything other than Ogg Vorbis.
(FFmpeg installation instructions available [here](https://github.com/DraftKinner/zotify/blob/main/INSTALLATION.md))
- Python 3.9 or greater
- FFmpeg
Enter the following command in terminal to install Zotify. \
`python -m pip install git+https://github.com/DraftKinner/zotify.git`
Installation:
## General Usage
### Simplest usage
Downloads specified items. Accepts any combination of track, album, playlist, episode or artists, URLs or URIs. \
`zotify <items to download>`
### Basic options
```text
-p, --playlist Download selection of user's saved playlists
-lt, --liked-tracks Download user's liked tracks
-le, --liked-episodes Download user's liked episodes
-f, --followed Download selection of users followed artists
-s, --search <search> Searches for items to download
python -m pip install git+https://zotify.xyz/zotify/zotify.git
```
<details><summary>All configuration options</summary>
See [INSTALLATION](INSTALLATION.md) for a more detailed and opinionated installation walkthrough.
| Config key | Command line argument | Description | Default |
| ----------------------- | ------------------------- | --------------------------------------------------- | ---------------------------------------------------------- |
| path_credentials | --credentials | Path to credentials file | |
| path_archive | --archive | Path to track archive file | |
| music_library | --music-library | Path to root of music library | |
| podcast_library | --podcast-library | Path to root of podcast library | |
| mixed_playlist_library | --mixed-playlist-library | Path to root of mixed content playlist library | |
| output_album | --output-album | File layout for saved albums | {album_artist}/{album}/{track_number}. {artists} - {title} |
| output_playlist_track | --output-playlist-track | File layout for tracks in a playlist | {playlist}/{playlist_number}. {artists} - {title} |
| output_playlist_episode | --output-playlist-episode | File layout for episodes in a playlist | {playlist}/{playlist_number}. {episode_number} - {title} |
| output_podcast | --output-podcast | File layout for saved podcasts | {podcast}/{episode_number} - {title} |
| download_quality | --download-quality | Audio download quality (auto for highest available) | |
| download_real_time | --download-real-time | Downloads songs as fast as they would be played | |
| audio_format | --audio-format | Audio format of final track output | |
| transcode_bitrate | --transcode-bitrate | Transcoding bitrate (-1 to use download rate) | |
| ffmpeg_path | --ffmpeg-path | Path to ffmpeg binary | |
| ffmpeg_args | --ffmpeg-args | Additional ffmpeg arguments when transcoding | |
| save_credentials | --save-credentials | Save login credentials to a file | |
| replace_existing | --replace-existing | Redownload and replace songs if they already exist | |
| skip_previous | --skip-previous | Skip previously downloaded songs in the playlist | |
| skip_duplicates | --skip-duplicates | Skip downloading existing track to different album | |
### Command line usage
</details>
### Compatibility with official version
Do note that `--skip-previous` and `--skip-duplicates` won't immediately work with playlists and albums downloaded using the official version (both dev and main branches). To make the playlist/album compatible with this fork such that `--skip-previous` and `--skip-duplicates` will both work, simply add the `-m` or `--match` flag to the download command. This will try to match filenames present in the library to ones that are to be downloaded. Note that output formats should match between the current download command and the existing files.
For example:
```
zotify -m <playlist/album_url>
zotify -m -p
zotify -m -d <text_file_with_urls_to_download>
```
This only needs to be done once per existing album or playlist.
Basic command line usage:
zotify <track/album/playlist/episode/artist url> Downloads the track, album, playlist or podcast episode specified as a command line argument. If an artist url is given, all albums by specified artist will be downloaded. Can take multiple urls.
### More about search
- `-c` or `--category` can be used to limit search results to certain categories.
- Available categories are "album", "artist", "playlist", "track", "show" and "episode".
- You can search in multiple categories at once
- You can also narrow down results by using field filters in search queries
- Currently available filters are album, artist, track, year, upc, tag:hipster, tag:new, isrc, and genre.
- Available filters are album, artist, track, year, upc, tag:hipster, tag:new, isrc, and genre.
- The artist and year filters can be used while searching albums, artists and tracks. You can filter on a single year or a range (e.g. 1970-1982).
- The album filter can be used while searching albums and tracks.
- The genre filter can be used while searching artists and tracks.
- The isrc and track filters can be used while searching tracks.
- The upc, tag:new and tag:hipster filters can only be used while searching albums. The tag:new filter will return albums released in the past two weeks and tag:hipster can be used to show only albums in the lowest 10% of popularity.
## Usage as a library
Zotify can be used as a user-friendly library for saving music, podcasts, lyrics and metadata.
Here's a very simple example of downloading a track and its metadata:
```python
from zotify import Session
session = Session.from_userpass(username="username", password="password")
track = session.get_track("4cOdK2wGLETKBW3PvgPWqT")
output = track.create_output("./Music", "{artist} - {title}")
file = track.write_audio_stream(output)
file.write_metadata(track.metadata)
file.write_cover_art(track.get_cover_art())
Basic options:
(nothing) Download the tracks/albums/playlists URLs from the parameter
-d, --download Download all tracks/albums/playlists URLs from the specified file
-p, --playlist Downloads a saved playlist from your account
-l, --liked Downloads all the liked songs from your account
-f, --followed Downloads all songs by all artists you follow
-s, --search Searches for specified track, album, artist or playlist, loads search prompt if none are given.
-h, --help See this message.
```
## Contributing
### Options
Pull requests are always welcome, but if adding an entirely new feature we encourage you to create an issue proposing the feature first so we can ensure it's something that fits the scope of the project.
All these options can either be configured in the config or via the commandline, in case of both the commandline-option has higher priority.
Be aware you have to set boolean values in the commandline like this: `--download-real-time=True`
Zotify aims to be a comprehensive and user-friendly tool for downloading music and podcasts.
It is designed to be simple by default but offer a high level of configuration for users that want it.
All new contributions should follow this principle to keep the program consistent.
| Key (config) | Commandline parameter | Defaults | Description
|------------------------------|----------------------------------|----------|---------------------------------------------------------------------|
| CREDENTIALS_LOCATION | --credentials-location | | The location of the credentials.json
| OUTPUT | --output | | The output location/format (see below)
| SONG_ARCHIVE | --song-archive | | The song_archive file for SKIP_PREVIOUSLY_DOWNLOADED
| ROOT_PATH | --root-path | | Directory where Zotify saves music
| ROOT_PODCAST_PATH | --root-podcast-path | | Directory where Zotify saves podcasts
| SPLIT_ALBUM_DISCS | --split-album-discs | False | Saves each disk in its own folder
| DOWNLOAD_LYRICS | --download-lyrics | True | Downloads synced lyrics in .lrc format, uses unsynced as fallback.
| MD_ALLGENRES | --md-allgenres | False | Save all relevant genres in metadata
| MD_GENREDELIMITER | --md-genredelimiter | , | Delimiter character used to split genres in metadata
| DOWNLOAD_FORMAT | --download-format | ogg | The download audio format (aac, fdk_aac, m4a, mp3, ogg, opus, vorbis)
| DOWNLOAD_QUALITY | --download-quality | auto | Audio quality of downloaded songs (normal, high, very_high*)
| TRANSCODE_BITRATE | --transcode-bitrate | auto | Overwrite the bitrate for ffmpeg encoding
| SKIP_EXISTING_FILES | --skip-existing | True | Skip songs with the same name
| SKIP_PREVIOUSLY_DOWNLOADED | --skip-previously-downloaded | False | Use a song_archive file to skip previously downloaded songs
| RETRY_ATTEMPTS | --retry-attempts | 1 | Number of times Zotify will retry a failed request
| BULK_WAIT_TIME | --bulk-wait-time | 1 | The wait time between bulk downloads
| OVERRIDE_AUTO_WAIT | --override-auto-wait | False | Totally disable wait time between songs with the risk of instability
| CHUNK_SIZE | --chunk-size | 20000 | Chunk size for downloading
| DOWNLOAD_REAL_TIME | --download-real-time | False | Downloads songs as fast as they would be played, should prevent account bans.
| LANGUAGE | --language | en | Language for spotify metadata
| PRINT_SPLASH | --print-splash | False | Show the Zotify logo at startup
| PRINT_SKIPS | --print-skips | True | Show messages if a song is being skipped
| PRINT_DOWNLOAD_PROGRESS | --print-download-progress | True | Show download/playlist progress bars
| PRINT_ERRORS | --print-errors | True | Show errors
| PRINT_DOWNLOADS | --print-downloads | False | Print messages when a song is finished downloading
| TEMP_DOWNLOAD_DIR | --temp-download-dir | | Download tracks to a temporary directory first
## Will my account get banned if I use this tool?
*very-high is limited to premium only
There have been no *confirmed* cases of accounts getting banned as a result of using Zotify.
However, it is still a possiblity and it is recommended you use Zotify with a burner account where possible.
### Configuration
Consider using [Exportify](https://watsonbox.github.io/exportify/) to keep backups of your playlists.
You can find the configuration file in following locations:
| OS | Location
|-----------------|-------------------------------------------------------------------|
| Windows | `C:\Users\<USERNAME>\AppData\Roaming\Zotify\config.json` |
| MacOS | `/Users/<USERNAME>/Library/ApplicationSupport/Zotify/config.json` |
| Linux | `/home/<USERNAME>/.config/zotify/config.json` |
## Disclaimer
To log out, just remove the configuration file. Uninstalling Zotify does not remove the config file.
Using Zotify violates Sp‌otify user guidelines and may get your account suspended.
### Output format
Zotify is intended to be used in compliance with DMCA, Section 1201, for educational, private and fair use, or any simlar laws in other regions.
Zotify contributors are not liable for damages caused by the use of this tool. See the [LICENSE](./LICENCE) file for more details.
With the option `OUTPUT` (or the commandline parameter `--output`) you can specify the output location and format.
The value is relative to the `ROOT_PATH`/`ROOT_PODCAST_PATH` directory and can contain the following placeholder:
| Placeholder | Description
|-----------------|--------------------------------
| {artist} | The song artist
| {album} | The song album
| {song_name} | The song name
| {release_year} | The song release year
| {disc_number} | The disc number
| {track_number} | The track_number
| {id} | The song id
| {track_id} | The track id
| {ext} | The file extension
| {album_id} | (only when downloading albums) ID of the album
| {album_num} | (only when downloading albums) Incrementing track number
| {playlist} | (only when downloading playlists) Name of the playlist
| {playlist_num} | (only when downloading playlists) Incrementing track number
Example values could be:
~~~~
{playlist}/{artist} - {song_name}.{ext}
{playlist}/{playlist_num} - {artist} - {song_name}.{ext}
{artist} - {song_name}.{ext}
{artist}/{album}/{album_num} - {artist} - {song_name}.{ext}
~~~~
### Docker Usage
```
Build the docker image from the Dockerfile:
docker build -t zotify .
Create and run a container from the image:
docker run --rm -v "$PWD/Zotify Music:/root/Music/Zotify Music" -v "$PWD/Zotify Podcasts:/root/Music/Zotify Podcasts" -it zotify
```
### What do I do if I see "Your session has been terminated"?
If you see this, don't worry! Just try logging back in. If you see the incorrect username or password error, reset your password and you should be able to log back in.
### Will my account get banned if I use this tool?
Currently no user has reported their account getting banned after using Zotify.
It is recommended you use Zotify with a burner account.
Alternatively, there is a configuration option labeled ```DOWNLOAD_REAL_TIME```, this limits the download speed to the duration of the song being downloaded thus appearing less suspicious.
This option is much slower and is only recommended for premium users who wish to download songs in 320kbps without buying premium on a burner account.
### Disclaimer
Zotify is intended to be used in compliance with DMCA, Section 1201, for educational, private and fair use. \
Zotify contributors are not responsible for any misuse of the program or source code.
### Contributing
Please refer to [CONTRIBUTING](CONTRIBUTING.md)
### Changelog
Please refer to [CHANGELOG](CHANGELOG.md)

BIN
assets/banner.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 110 KiB

5
pyproject.toml
View file

@ -1,3 +1,6 @@
[build-system]
requires = ["setuptools>=61.0", "wheel"]
requires = [
"setuptools >= 40.9.0",
"wheel",
]
build-backend = "setuptools.build_meta"

12
requirements.txt
View file

@ -1,8 +1,8 @@
librespot@git+https://github.com/kokarare1212/librespot-python
https://github.com/DraftKinner/music-tag/archive/refs/tags/v0.4.7.zip
mutagen
ffmpy
https://github.com/kokarare1212/librespot-python/archive/refs/heads/rewrite.zip
music_tag
Pillow
pkce
requests
protobuf
pwinput
tabulate[widechars]
tqdm
limits

6
requirements_dev.txt
View file

@ -1,6 +0,0 @@
black
flake8
mypy
types-protobuf
types-requests
wheel

55
setup.cfg
View file

@ -1,58 +1,33 @@
[metadata]
name = zotify
version = 0.9.11
version = 0.6.14
author = Zotify Contributors
description = A highly customizable music and podcast downloader
long_description = file: README.md
long_description_content_type = text/markdown
keywords = music, podcast, downloader
licence = Zlib
keywords = python, music, podcast, downloader
licence = Unlicence
classifiers =
Programming Language :: Python :: 3
License :: OSI Approved :: zlib/libpng License
Operating System :: POSIX :: Linux
Operating System :: Microsoft :: Windows
Operating System :: MacOS
Topic :: Multimedia :: Sound/Audio
License :: OSI Approved :: The Unlicense (Unlicense)
Operating System :: OS Independent
[options]
packages = zotify
python_requires = >=3.11
python_requires = >=3.9
install_requires =
librespot@git+https://github.com/kokarare1212/librespot-python
music-tag@https://github.com/DraftKinner/music-tag/archive/refs/tags/v0.4.7.zip
mutagen
librespot@git+https://github.com/kokarare1212/librespot-python.git
ffmpy
music_tag
Pillow
pkce
requests
protobuf==3.20.1
pwinput
tabulate[widechars]
tqdm
limits
[options.package_data]
file: README.md, LICENSE
[options.entry_points]
console_scripts =
zotify = zotify.__main__:main
[flake8]
max-line-length = 160
ignore =
E701
E704
W503
[mypy]
warn_unused_configs = True
[mypy-librespot.*]
ignore_missing_imports = True
[mypy-music_tag]
ignore_missing_imports = True
[mypy-mutagen.*]
ignore_missing_imports = True
[mypy-pwinput]
ignore_missing_imports = True
[mypy-tqdm]
ignore_missing_imports = True

476
zotify/__init__.py
View file

@ -1,476 +0,0 @@
from __future__ import annotations
from enum import IntEnum
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path
from threading import Thread
from typing import Any
from time import time_ns, sleep
from urllib.parse import urlencode, urlparse, parse_qs
from limits import storage, strategies, RateLimitItemPerSecond
from librespot.audio import AudioKeyManager, CdnManager
from librespot.audio.decoders import VorbisOnlyAudioQuality
from librespot.audio.storage import ChannelManager
from librespot.cache import CacheManager
from librespot.core import (
ApResolver,
DealerClient,
EventService,
PlayableContentFeeder,
SearchManager,
ApiClient as LibrespotApiClient,
Session as LibrespotSession,
TokenProvider as LibrespotTokenProvider,
)
from librespot.mercury import MercuryClient
from librespot.metadata import EpisodeId, PlayableId, TrackId
from librespot.proto import Authentication_pb2 as Authentication
from pkce import generate_code_verifier, get_code_challenge
from requests import HTTPError, get, post
from zotify.loader import Loader
from zotify.playable import Episode, Track
from zotify.utils import Quality, RateLimitMode
API_URL = "https://api.sp" + "otify.com/v1/"
AUTH_URL = "https://accounts.sp" + "otify.com/"
REDIRECT_URI = "http://127.0.0.1:4381/login"
CLIENT_ID = "65b70807" + "3fc0480e" + "a92a0772" + "33ca87bd"
SCOPES = [
"app-remote-control",
"playlist-modify",
"playlist-modify-private",
"playlist-modify-public",
"playlist-read",
"playlist-read-collaborative",
"playlist-read-private",
"streaming",
"ugc-image-upload",
"user-follow-modify",
"user-follow-read",
"user-library-modify",
"user-library-read",
"user-modify",
"user-modify-playback-state",
"user-modify-private",
"user-personalized",
"user-read-birthdate",
"user-read-currently-playing",
"user-read-email",
"user-read-play-history",
"user-read-playback-position",
"user-read-playback-state",
"user-read-private",
"user-read-recently-played",
"user-top-read",
]
RATE_LIMIT_API = "rate_limit_api"
RATE_LIMIT_MAX_CONSECUTIVE_HITS = 10
RATE_LIMIT_RESTORE_CONDITION = 15
RATE_LIMIT_INTERVAL_SECS = 30
RATE_LIMIT_CALLS_NORMAL = 9
RATE_LIMIT_CALLS_REDUCED = 3
API_MAX_REQUEST_LIMIT = 50
class Session(LibrespotSession):
def __init__(
self,
session_builder: LibrespotSession.Builder,
language: str = "en",
oauth: OAuth | None = None,
) -> None:
"""
Authenticates user, saves credentials to a file and generates api token.
Args:
session_builder: An instance of the Librespot Session builder
langauge: ISO 639-1 language code
"""
with Loader("Logging in..."):
super(Session, self).__init__(
LibrespotSession.Inner(
session_builder.device_type,
session_builder.device_name,
session_builder.preferred_locale,
session_builder.conf,
session_builder.device_id,
),
ApResolver.get_random_accesspoint(),
)
self.__oauth = oauth
self.__language = language
self.connect()
self.authenticate(session_builder.login_credentials)
self.rate_limiter = RateLimiter()
@staticmethod
def from_file(cred_file: Path | str, language: str = "en") -> Session:
"""
Creates session using saved credentials file
Args:
cred_file: Path to credentials file
language: ISO 639-1 language code for API responses
Returns:
Zotify session
"""
if not isinstance(cred_file, Path):
cred_file = Path(cred_file).expanduser()
config = (
LibrespotSession.Configuration.Builder()
.set_store_credentials(False)
.build()
)
session = LibrespotSession.Builder(config).stored_file(str(cred_file))
return Session(session, language)
@staticmethod
def from_oauth(
oauth: OAuth,
save_file: Path | str | None = None,
language: str = "en",
) -> Session:
"""
Creates a session using OAuth2
Args:
save_file: Path to save login credentials to, optional.
language: ISO 639-1 language code for API responses
Returns:
Zotify session
"""
config = LibrespotSession.Configuration.Builder()
if save_file:
if not isinstance(save_file, Path):
save_file = Path(save_file).expanduser()
save_file.parent.mkdir(parents=True, exist_ok=True)
config.set_stored_credential_file(str(save_file))
else:
config.set_store_credentials(False)
token = oauth.await_token()
builder = LibrespotSession.Builder(config.build())
builder.login_credentials = Authentication.LoginCredentials(
username=oauth.username,
typ=Authentication.AuthenticationType.values()[3],
auth_data=token.access_token.encode(),
)
return Session(builder, language, oauth)
def __get_playable(
self, playable_id: PlayableId, quality: Quality
) -> PlayableContentFeeder.LoadedStream:
if quality.value is None:
quality = Quality.VERY_HIGH if self.is_premium() else Quality.HIGH
return self.content_feeder().load(
playable_id,
VorbisOnlyAudioQuality(quality.value),
False,
None,
)
def get_track(self, track_id: str, quality: Quality = Quality.AUTO) -> Track:
"""
Gets track/episode data and audio stream
Args:
track_id: Base62 ID of track
quality: Audio quality of track when downloaded
Returns:
Track object
"""
return Track(
self.__get_playable(TrackId.from_base62(track_id), quality), self.api()
)
def get_episode(self, episode_id: str) -> Episode:
"""
Gets track/episode data and audio stream
Args:
episode: Base62 ID of episode
Returns:
Episode object
"""
return Episode(
self.__get_playable(EpisodeId.from_base62(episode_id), Quality.NORMAL),
self.api(),
)
def oauth(self) -> OAuth | None:
"""Returns OAuth service"""
return self.__oauth
def language(self) -> str:
"""Returns session language"""
return self.__language
def is_premium(self) -> bool:
"""Returns users premium account status"""
return self.get_user_attribute("type") == "premium"
def authenticate(self, credential: Authentication.LoginCredentials) -> None:
"""
Log in to the thing
Args:
credential: Account login information
"""
self.__authenticate_partial(credential, False)
with self.__auth_lock:
self.__mercury_client = MercuryClient(self)
self.__token_provider = TokenProvider(self)
self.__audio_key_manager = AudioKeyManager(self)
self.__channel_manager = ChannelManager(self)
self.__api = ApiClient(self)
self.__cdn_manager = CdnManager(self)
self.__content_feeder = PlayableContentFeeder(self)
self.__cache_manager = CacheManager(self)
self.__dealer_client = DealerClient(self)
self.__search = SearchManager(self)
self.__event_service = EventService(self)
self.__auth_lock_bool = False
self.__auth_lock.notify_all()
self.mercury().interested_in("sp" + "otify:user:attributes:update", self)
def api(self) -> ApiClient:
# Check rate limiter before making calls to api
while not self.rate_limiter.check():
sleep(1)
self.rate_limiter.hit()
return super().api()
class ApiClient(LibrespotApiClient):
def __init__(self, session: Session):
super(ApiClient, self).__init__(session)
self.__session = session
def invoke_url(
self,
url: str,
params: dict[str, Any] = {},
limit: int = 20,
offset: int = 0,
raw_url: bool = False,
) -> dict[str, Any]:
"""
Requests data from API
Args:
url: API URL and to get data from
params: parameters to be sent in the request
limit: The maximum number of items in the response
offset: The offset of the items returned
Returns:
Dictionary representation of JSON response
"""
headers = {
"Authorization": f"Bearer {self.__get_token()}",
"Accept": "application/json",
"Accept-Language": self.__session.language(),
"app-platform": "WebPlayer",
}
if not raw_url:
params["limit"] = limit
params["offset"] = offset
response = get(API_URL + url, headers=headers, params=params)
else:
response = get(url, headers=headers)
data = response.json()
try:
raise HTTPError(
f"{url}\nAPI Error {data['error']['status']}: {data['error']['message']}"
)
except KeyError:
return data
def __get_token(self) -> str:
return (
self.__session.tokens()
.get_token(
"playlist-read-private", # Private playlists
"user-follow-read", # Followed artists
"user-library-read", # Liked tracks/episodes/etc.
"user-read-private", # Country
)
.access_token
)
class TokenProvider(LibrespotTokenProvider):
def __init__(self, session: Session):
super(TokenProvider, self).__init__(session)
self._session = session
def get_token(self, *scopes) -> TokenProvider.StoredToken:
oauth = self._session.oauth()
if oauth is None:
return super().get_token(*scopes)
return oauth.get_token()
class StoredToken(LibrespotTokenProvider.StoredToken):
def __init__(self, obj):
self.timestamp = int(time_ns() / 1000)
self.expires_in = int(obj["expires_in"])
self.access_token = obj["access_token"]
self.scopes = obj["scope"].split()
self.refresh_token = obj["refresh_token"]
class OAuth:
__code_verifier: str
__server_thread: Thread
__token: TokenProvider.StoredToken
username: str
def __init__(self, username: str):
self.username = username
def auth_interactive(self) -> str:
"""
Starts local server for token callback
Returns:
OAuth URL
"""
self.__server_thread = Thread(target=self.__run_server)
self.__server_thread.start()
self.__code_verifier = generate_code_verifier()
code_challenge = get_code_challenge(self.__code_verifier)
params = {
"client_id": CLIENT_ID,
"response_type": "code",
"redirect_uri": REDIRECT_URI,
"scope": ",".join(SCOPES),
"code_challenge_method": "S256",
"code_challenge": code_challenge,
}
return f"{AUTH_URL}authorize?{urlencode(params)}"
def await_token(self) -> TokenProvider.StoredToken:
"""
Blocks until server thread gets token
Returns:
StoredToken
"""
self.__server_thread.join()
return self.__token
def get_token(self) -> TokenProvider.StoredToken:
"""
Gets a valid token
Returns:
StoredToken
"""
if self.__token is None:
raise RuntimeError("Session isn't authenticated!")
elif self.__token.expired():
self.set_token(self.__token.refresh_token, OAuth.RequestType.REFRESH)
return self.__token
def set_token(self, code: str, request_type: RequestType) -> None:
"""
Fetches and sets stored token
Returns:
StoredToken
"""
token_url = f"{AUTH_URL}api/token"
headers = {"Content-Type": "application/x-www-form-urlencoded"}
if request_type == OAuth.RequestType.LOGIN:
body = {
"grant_type": "authorization_code",
"code": code,
"redirect_uri": REDIRECT_URI,
"client_id": CLIENT_ID,
"code_verifier": self.__code_verifier,
}
elif request_type == OAuth.RequestType.REFRESH:
body = {
"grant_type": "refresh_token",
"refresh_token": code,
"client_id": CLIENT_ID,
}
response = post(token_url, headers=headers, data=body)
if response.status_code != 200:
raise IOError(
f"Error fetching token: {response.status_code}, {response.text}"
)
self.__token = TokenProvider.StoredToken(response.json())
def __run_server(self) -> None:
server_address = ("127.0.0.1", 4381)
httpd = self.OAuthHTTPServer(server_address, self.RequestHandler, self)
httpd.authenticator = self
httpd.serve_forever()
class RequestType(IntEnum):
LOGIN = 0
REFRESH = 1
class OAuthHTTPServer(HTTPServer):
authenticator: OAuth
def __init__(
self,
server_address: tuple[str, int],
RequestHandlerClass: type[BaseHTTPRequestHandler],
authenticator: OAuth,
):
super().__init__(server_address, RequestHandlerClass)
self.authenticator = authenticator
class RequestHandler(BaseHTTPRequestHandler):
def log_message(self, format: str, *args):
return
def do_GET(self) -> None:
parsed_path = urlparse(self.path)
query_params = parse_qs(parsed_path.query)
code = query_params.get("code")
if code:
if isinstance(self.server, OAuth.OAuthHTTPServer):
self.server.authenticator.set_token(
code[0], OAuth.RequestType.LOGIN
)
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(
b"Authorization successful. You can close this window."
)
Thread(target=self.server.shutdown).start()
else:
self.send_response(400)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(b"Authorization code not found.")
Thread(target=self.server.shutdown).start()
class RateLimiter:
rate_limits = {
RateLimitMode.NORMAL: RateLimitItemPerSecond(
RATE_LIMIT_CALLS_NORMAL, RATE_LIMIT_INTERVAL_SECS
),
RateLimitMode.REDUCED: RateLimitItemPerSecond(
RATE_LIMIT_CALLS_REDUCED, RATE_LIMIT_INTERVAL_SECS
),
}
def __init__(self):
self.storage = storage.MemoryStorage()
self.moving_window = strategies.MovingWindowRateLimiter(self.storage)
self.mode = RateLimitMode.NORMAL
self.rate_limit = RateLimiter.rate_limits[self.mode]
def check(self):
return self.moving_window.test(self.rate_limit, RATE_LIMIT_API)
def hit(self):
self.moving_window.hit(self.rate_limit, RATE_LIMIT_API)
def set_mode(self, mode: RateLimitMode):
self.mode = mode
self.rate_limit = RateLimiter.rate_limits[self.mode]

194
zotify/__main__.py
View file

@ -1,152 +1,68 @@
#! /usr/bin/env python3
from argparse import ArgumentParser
from pathlib import Path
"""
Zotify
It's like youtube-dl, but for that other music platform.
"""
from zotify.app import App
from zotify.config import CONFIG_PATHS, CONFIG_VALUES
from zotify.utils import OptionalOrFalse
VERSION = "0.9.11"
import argparse
from zotify.app import client
from zotify.config import CONFIG_VALUES
def main():
parser = ArgumentParser(
prog="zotify",
description="A fast and customizable music and podcast downloader",
)
group = parser.add_mutually_exclusive_group(required=True)
parser = argparse.ArgumentParser(prog='zotify',
description='A music and podcast downloader needing only python and ffmpeg.')
parser.add_argument('-ns', '--no-splash',
action='store_true',
help='Suppress the splash screen when loading.')
parser.add_argument('--config-location',
type=str,
help='Specify the zconfig.json location')
parser.add_argument('--username',
type=str,
help='Account username')
parser.add_argument('--password',
type=str,
help='Account password')
group = parser.add_mutually_exclusive_group(required=False)
group.add_argument('urls',
type=str,
# action='extend',
default='',
nargs='*',
help='Downloads the track, album, playlist, podcast episode, or all albums by an artist from a url. Can take multiple urls.')
group.add_argument('-l', '--liked',
dest='liked_songs',
action='store_true',
help='Downloads all the liked songs from your account.')
group.add_argument('-f', '--followed',
dest='followed_artists',
action='store_true',
help='Downloads all the songs from all your followed artists.')
group.add_argument('-p', '--playlist',
action='store_true',
help='Downloads a saved playlist from your account.')
group.add_argument('-s', '--search',
type=str,
nargs='?',
const=' ',
help='Loads search prompt to find then download a specific track, album or playlist')
group.add_argument('-d', '--download',
type=str,
help='Downloads tracks, playlists and albums from the URLs written in the file passed.')
group.add_argument(
"-v",
"--version",
action="store_true",
help="Print version and exit",
)
parser.add_argument(
"--debug",
action="store_true",
help="Display full tracebacks",
)
parser.add_argument(
"--config",
type=Path,
default=CONFIG_PATHS["conf"],
help="Specify the config.json location",
)
parser.add_argument(
"-l",
"--library",
type=Path,
help="Specify a path to the root of a music/playlist/podcast library",
)
parser.add_argument(
"-o", "--output", type=str, help="Specify the output file structure/format"
)
parser.add_argument(
"-c",
"--category",
type=str,
choices=["album", "artist", "playlist", "track", "show", "episode"],
default=["album", "artist", "playlist", "track", "show", "episode"],
nargs="+",
help="Searches for only this type",
)
parser.add_argument("--username", type=str, default="", help="Account username")
parser.add_argument("--token", type=str, default="", help="Account token")
parser.add_argument(
"-m",
"--match",
action="store_true",
help="Match downloaded track filenames to corresponding tracks in collection",
)
group.add_argument(
"urls",
type=str,
default="",
nargs="*",
help="Downloads the track, album, playlist, podcast, episode or artist from a URL or URI. Accepts multiple options.",
)
group.add_argument(
"-d",
"--download",
type=str,
nargs="*",
help="Downloads tracks, playlists and albums from the URLs written in the file passed.",
)
group.add_argument(
"-f",
"--followed",
action="store_true",
help="Download all songs from your followed artists.",
)
group.add_argument(
"-lt",
"--liked-tracks",
action="store_true",
help="Download all of your liked songs.",
)
group.add_argument(
"-le",
"--liked-episodes",
action="store_true",
help="Download all of your liked episodes.",
)
group.add_argument(
"-p",
"--playlist",
action="store_true",
help="Download a saved playlists from your account.",
)
group.add_argument(
"-s",
"--search",
type=str,
nargs="+",
help="Search for a specific track, album, playlist, artist or podcast",
)
for configkey in CONFIG_VALUES:
parser.add_argument(CONFIG_VALUES[configkey]['arg'],
type=str,
default=None,
help='Specify the value of the ['+configkey+'] config value')
for k, v in CONFIG_VALUES.items():
if v["type"] == bool:
parser.add_argument(
*v["args"],
action=OptionalOrFalse,
help=v["help"],
)
else:
try:
parser.add_argument(
*v["args"],
type=v["type"],
choices=v["choices"],
default=None,
help=v["help"],
)
except KeyError:
parser.add_argument(
*v["args"],
type=v["type"],
default=None,
help=v["help"],
)
parser.set_defaults(func=client)
parser.set_defaults(func=App)
args = parser.parse_args()
if args.version:
print(VERSION)
elif args.debug:
args.func(args)
else:
try:
args.func(args)
except Exception:
from traceback import format_exc
print(format_exc().splitlines()[-1])
exit(1)
except KeyboardInterrupt:
exit(130)
args.func(args)
if __name__ == "__main__":
if __name__ == '__main__':
main()

58
zotify/album.py Normal file
View file

@ -0,0 +1,58 @@
from zotify.const import ITEMS, ARTISTS, NAME, ID
from zotify.termoutput import Printer
from zotify.track import download_track
from zotify.utils import fix_filename
from zotify.zotify import Zotify
ALBUM_URL = 'https://api.spotify.com/v1/albums'
ARTIST_URL = 'https://api.spotify.com/v1/artists'
def get_album_tracks(album_id):
""" Returns album tracklist """
songs = []
offset = 0
limit = 50
while True:
resp = Zotify.invoke_url_with_params(f'{ALBUM_URL}/{album_id}/tracks', limit=limit, offset=offset)
offset += limit
songs.extend(resp[ITEMS])
if len(resp[ITEMS]) < limit:
break
return songs
def get_album_name(album_id):
""" Returns album name """
(raw, resp) = Zotify.invoke_url(f'{ALBUM_URL}/{album_id}')
return resp[ARTISTS][0][NAME], fix_filename(resp[NAME])
def get_artist_albums(artist_id):
""" Returns artist's albums """
(raw, resp) = Zotify.invoke_url(f'{ARTIST_URL}/{artist_id}/albums?include_groups=album%2Csingle')
# Return a list each album's id
album_ids = [resp[ITEMS][i][ID] for i in range(len(resp[ITEMS]))]
# Recursive requests to get all albums including singles an EPs
while resp['next'] is not None:
(raw, resp) = Zotify.invoke_url(resp['next'])
album_ids.extend([resp[ITEMS][i][ID] for i in range(len(resp[ITEMS]))])
return album_ids
def download_album(album):
""" Downloads songs from an album """
artist, album_name = get_album_name(album)
tracks = get_album_tracks(album)
for n, track in Printer.progress(enumerate(tracks, start=1), unit_scale=True, unit='Song', total=len(tracks)):
download_track('album', track[ID], extra_keys={'album_num': str(n).zfill(2), 'artist': artist, 'album': album_name, 'album_id': album}, disable_progressbar=True)
def download_artist_albums(artist):
""" Downloads albums of an artist """
albums = get_artist_albums(artist)
for album_id in albums:
download_album(album_id)

766
zotify/app.py
View file

@ -1,504 +1,310 @@
from argparse import Namespace
from librespot.audio.decoders import AudioQuality
from tabulate import tabulate
from pathlib import Path
from typing import Any
from time import sleep
from zotify import (
OAuth,
Session,
RATE_LIMIT_INTERVAL_SECS,
RATE_LIMIT_MAX_CONSECUTIVE_HITS,
RATE_LIMIT_RESTORE_CONDITION,
)
from zotify.collections import Album, Artist, Collection, Episode, Playlist, Show, Track
from zotify.config import Config
from zotify.file import TranscodingError
from zotify.album import download_album, download_artist_albums
from zotify.const import TRACK, NAME, ID, ARTIST, ARTISTS, ITEMS, TRACKS, EXPLICIT, ALBUM, ALBUMS, \
OWNER, PLAYLIST, PLAYLISTS, DISPLAY_NAME, TYPE
from zotify.loader import Loader
from zotify.logger import LogChannel, Logger
from zotify.utils import AudioFormat, PlayableType, RateLimitMode
from zotify.playlist import get_playlist_songs, get_playlist_info, download_from_user_playlist, download_playlist
from zotify.podcast import download_episode, get_show_episodes
from zotify.termoutput import Printer, PrintChannel
from zotify.track import download_track, get_saved_tracks, get_followed_artists
from zotify.utils import splash, split_input, regex_input_for_urls
from zotify.zotify import Zotify
SEARCH_URL = 'https://api.spotify.com/v1/search'
class ParseError(ValueError): ...
def client(args) -> None:
""" Connects to download server to perform query's and get songs to download """
Zotify(args)
Printer.print(PrintChannel.SPLASH, splash())
quality_options = {
'auto': AudioQuality.VERY_HIGH if Zotify.check_premium() else AudioQuality.HIGH,
'normal': AudioQuality.NORMAL,
'high': AudioQuality.HIGH,
'very_high': AudioQuality.VERY_HIGH
}
Zotify.DOWNLOAD_QUALITY = quality_options[Zotify.CONFIG.get_download_quality()]
if args.download:
urls = []
filename = args.download
if Path(filename).exists():
with open(filename, 'r', encoding='utf-8') as file:
urls.extend([line.strip() for line in file.readlines()])
download_from_urls(urls)
else:
Printer.print(PrintChannel.ERRORS, f'File {filename} not found.\n')
return
if args.urls:
if len(args.urls) > 0:
download_from_urls(args.urls)
return
if args.playlist:
download_from_user_playlist()
return
if args.liked_songs:
for song in get_saved_tracks():
if not song[TRACK][NAME] or not song[TRACK][ID]:
Printer.print(PrintChannel.SKIPS, '### SKIPPING: SONG DOES NOT EXIST ANYMORE ###' + "\n")
else:
download_track('liked', song[TRACK][ID])
return
if args.followed_artists:
for artist in get_followed_artists():
download_artist_albums(artist)
return
if args.search:
if args.search == ' ':
search_text = ''
while len(search_text) == 0:
search_text = input('Enter search: ')
search(search_text)
else:
if not download_from_urls([args.search]):
search(args.search)
return
else:
search_text = ''
while len(search_text) == 0:
search_text = input('Enter search: ')
search(search_text)
def download_from_urls(urls: list[str]) -> bool:
""" Downloads from a list of urls """
download = False
for spotify_url in urls:
track_id, album_id, playlist_id, episode_id, show_id, artist_id = regex_input_for_urls(spotify_url)
if track_id is not None:
download = True
download_track('single', track_id)
elif artist_id is not None:
download = True
download_artist_albums(artist_id)
elif album_id is not None:
download = True
download_album(album_id)
elif playlist_id is not None:
download = True
playlist_songs = get_playlist_songs(playlist_id)
name, _ = get_playlist_info(playlist_id)
enum = 1
char_num = len(str(len(playlist_songs)))
for song in playlist_songs:
if not song[TRACK][NAME] or not song[TRACK][ID]:
Printer.print(PrintChannel.SKIPS, '### SKIPPING: SONG DOES NOT EXIST ANYMORE ###' + "\n")
else:
if song[TRACK][TYPE] == "episode": # Playlist item is a podcast episode
download_episode(song[TRACK][ID])
else:
download_track('playlist', song[TRACK][ID], extra_keys=
{
'playlist_song_name': song[TRACK][NAME],
'playlist': name,
'playlist_num': str(enum).zfill(char_num),
'playlist_id': playlist_id,
'playlist_track_id': song[TRACK][ID]
})
enum += 1
elif episode_id is not None:
download = True
download_episode(episode_id)
elif show_id is not None:
download = True
for episode in get_show_episodes(show_id):
download_episode(episode)
return download
class Selection:
def __init__(self, session: Session):
self.__session = session
self.__items: list[dict[str, Any]] = []
self.__print_labels = {
"album": ("name", "artists"),
"playlist": ("name", "owner"),
"track": ("title", "artists", "album"),
"show": ("title", "creator"),
}
def search(search_term):
""" Searches download server's API for relevant data """
params = {'limit': '10',
'offset': '0',
'q': search_term,
'type': 'track,album,artist,playlist'}
def search(
self,
search_text: str,
category: list[str] = [
"track",
"album",
"artist",
"playlist",
"show",
"episode",
],
) -> list[str]:
offset = 0
categories = ",".join(category)
ids = []
while True:
with Loader("Searching..."):
country = self.__session.api().invoke_url("me")["country"]
resp = self.__session.api().invoke_url(
"search",
{
"q": search_text,
"type": categories,
"include_external": "audio",
"market": country,
},
limit=10,
offset=offset,
)
# Parse args
splits = search_term.split()
for split in splits:
index = splits.index(split)
print(f'Search results for "{search_text}"')
count = 0
next_page = {}
self.__items = []
for cat in categories.split(","):
label = cat + "s"
items = resp[label]["items"]
next_page[label] = resp[label]["next"]
if len(items) > 0:
print(f"\n{label.capitalize()}:")
try:
self.__print(count, items, *self.__print_labels[cat])
except KeyError:
self.__print(count, items, "name")
count += len(items)
self.__items.extend(items)
if split[0] == '-' and len(split) > 1:
if len(splits)-1 == index:
raise IndexError('No parameters passed after option: {}\n'.
format(split))
for id in self.__get_selection(allow_empty=True):
ids.append(id)
if split == '-l' or split == '-limit':
try:
int(splits[index+1])
except ValueError:
raise ValueError('Parameter passed after {} option must be an integer.\n'.
format(split))
if int(splits[index+1]) > 50:
raise ValueError('Invalid limit passed. Max is 50.\n')
params['limit'] = splits[index+1]
next_flag = False
for page in next_page.values():
if page is not None and next_flag is False:
next_flag = True
params = page.split("?", 1)[1]
page_offset = int(params.split("&")[0].split("=")[1])
offset = page_offset
if split == '-t' or split == '-type':
allowed_types = ['track', 'playlist', 'album', 'artist']
passed_types = []
for i in range(index+1, len(splits)):
if splits[i][0] == '-':
break
if not next_flag:
break
if splits[i] not in allowed_types:
raise ValueError('Parameters passed after {} option must be from this list:\n{}'.
format(split, '\n'.join(allowed_types)))
get_next = self.__get_next_prompt()
if get_next.lower() == "n":
break
passed_types.append(splits[i])
params['type'] = ','.join(passed_types)
return ids
if len(params['type']) == 0:
params['type'] = 'track,album,artist,playlist'
def get(self, category: str, name: str = "", content: str = "") -> list[str]:
with Loader("Fetching items..."):
r = self.__session.api().invoke_url(f"me/{category}", limit=50)
# Clean search term
search_term_list = []
for split in splits:
if split[0] == "-":
break
search_term_list.append(split)
if not search_term_list:
raise ValueError("Invalid query.")
params["q"] = ' '.join(search_term_list)
ids = []
while True:
if content != "":
r = r[content]
resp = r["items"]
resp = Zotify.invoke_url_with_params(SEARCH_URL, **params)
self.__items = []
for i in range(len(resp)):
try:
item = resp[i][name]
except KeyError:
item = resp[i]
self.__items.append(item)
print(
"{:<2} {:<38}".format(
i + 1, self.__fix_string_length(item["name"], 38)
)
)
counter = 1
dics = []
for id in self.__get_selection():
ids.append(id)
if r["next"] is None:
break
get_next = self.__get_next_prompt()
if get_next.lower() == "n":
break
with Loader("Fetching items..."):
r = self.__session.api().invoke_url(r["next"], raw_url=True)
return ids
@staticmethod
def from_file(file_path: Path) -> list[str]:
with open(file_path, "r", encoding="utf-8") as f:
return [line.strip() for line in f.readlines()]
def __get_selection(self, allow_empty: bool = False) -> list[str]:
print("\nResults to save (eg: 1,2,5 1-3)")
selection = ""
while len(selection) == 0:
selection = input("==> ")
if len(selection) == 0 and allow_empty:
return []
ids = []
selections = selection.split(",")
for i in selections:
if "-" in i:
split = i.split("-")
for x in range(int(split[0]), int(split[1]) + 1):
ids.append(self.__items[x - 1]["uri"])
else:
ids.append(self.__items[int(i) - 1]["uri"])
return ids
def __print(self, count: int, items: list[dict[str, Any]], *args: str) -> None:
arg_range = range(len(args))
category_str = "# " + " ".join("{:<38}" for _ in arg_range)
print(category_str.format(*[s.upper() for s in list(args)]))
for item in items:
count += 1
fmt_str = "{:<2} ".format(count) + " ".join("{:<38}" for _ in arg_range)
fmt_vals: list[str] = []
for arg in args:
match arg:
case "artists":
fmt_vals.append(
", ".join([artist["name"] for artist in item["artists"]])
)
case "owner":
fmt_vals.append(item["owner"]["display_name"])
case "album":
fmt_vals.append(item["album"]["name"])
case "creator":
fmt_vals.append(item["publisher"])
case "title":
fmt_vals.append(item["name"])
case _:
fmt_vals.append(item[arg])
print(
fmt_str.format(
*(self.__fix_string_length(fmt_vals[x], 38) for x in arg_range),
)
)
@staticmethod
def __fix_string_length(text: str, max_length: int) -> str:
if len(text) > max_length:
return text[: max_length - 3] + "..."
return text
def __get_next_prompt(self) -> str:
print("\nGet next page? Y/n")
get_next = None
while get_next not in ["Y", "y", "N", "n"]:
get_next = input("==> ")
if len(get_next) == 0:
get_next = "y"
return get_next
class App:
def __init__(self, args: Namespace):
self.__config = Config(args)
self.__existing = {}
self.__duplicates = {}
Logger(self.__config)
# Create session
if args.username != "" and args.token != "":
oauth = OAuth(args.username)
oauth.set_token(args.token, OAuth.RequestType.REFRESH)
self.__session = Session.from_oauth(
oauth, self.__config.credentials_path, self.__config.language
)
elif self.__config.credentials_path.is_file():
self.__session = Session.from_file(
self.__config.credentials_path,
self.__config.language,
)
else:
username = args.username
while username == "":
username = input("Username: ")
oauth = OAuth(username)
auth_url = oauth.auth_interactive()
print(f"\nClick on the following link to login:\n{auth_url}")
self.__session = Session.from_oauth(
oauth, self.__config.credentials_path, self.__config.language
)
# Get items to download
ids = self.get_selection(args)
with Loader("Parsing input..."):
try:
collections = self.parse(ids)
except ParseError as e:
Logger.log(LogChannel.ERRORS, str(e))
exit(1)
if len(collections) > 0:
with Loader("Scanning collections..."):
self.scan(collections, args.match)
self.download_all(collections)
else:
Logger.log(LogChannel.WARNINGS, "there is nothing to do")
exit(0)
def get_selection(self, args: Namespace) -> list[str]:
selection = Selection(self.__session)
try:
if args.search:
return selection.search(" ".join(args.search), args.category)
elif args.playlist:
return selection.get("playlists")
elif args.followed:
return selection.get("following?type=artist", content="artists")
elif args.liked_tracks:
return selection.get("tracks", "track")
elif args.liked_episodes:
return selection.get("episodes")
elif args.download:
ids = []
for x in args.download:
ids.extend(selection.from_file(x.strip()))
return ids
elif args.urls:
return args.urls
except KeyboardInterrupt:
Logger.log(LogChannel.WARNINGS, "\nthere is nothing to do")
exit(130)
except (FileNotFoundError, ValueError):
pass
Logger.log(LogChannel.WARNINGS, "there is nothing to do")
exit(0)
def parse(self, links: list[str]) -> list[Collection]:
collections: list[Collection] = []
for link in links:
link = link.rsplit("?", 1)[0]
try:
split = link.split(link[-23])
_id = split[-1]
id_type = split[-2]
except IndexError:
raise ParseError(f'Could not parse "{link}"')
collection_types = {
"album": Album,
"artist": Artist,
"show": Show,
"track": Track,
"episode": Episode,
"playlist": Playlist,
}
try:
collections.append(
collection_types[id_type](_id, self.__session.api(), self.__config)
)
except ValueError:
raise ParseError(f'Unsupported content type "{id_type}"')
return collections
def scan(self, collections: list[Collection], match: bool):
if self.__config.replace_existing:
return
if match:
for collection in collections:
collection.get_match()
if self.__config.skip_previous:
for collection in collections:
try:
existing = collection.get_existing(
self.__config.audio_format.value.ext
)
self.__existing.update(existing)
except IndexError as err:
Logger.log(
LogChannel.WARNINGS, f"{err} Cannot scan for existing tracks"
)
if self.__config.skip_duplicates:
for collection in collections:
try:
duplicates = collection.get_duplicates(
self.__config.audio_format.value.ext,
self.__config.album_library,
self.__config.playlist_library,
self.__config.podcast_library,
)
self.__duplicates.update(duplicates)
except IndexError as err:
Logger.log(
LogChannel.WARNINGS, f"{err} Cannot scan for duplicate tracks"
)
def download_all(self, collections: list[Collection]) -> None:
self.rate_limit_hits = 0
self.last_rate_limit_hit = 0
count = 0
total = sum(len(c.playables) for c in collections)
for collection in collections:
for playable in collection.playables:
count += 1
# Skip duplicates and previously downloaded
if playable.duplicate:
Logger.log(
LogChannel.SKIPS,
f'Skipping "{self.__duplicates[playable.id]}": Duplicated from another collection',
)
continue
if playable.existing:
Logger.log(
LogChannel.SKIPS,
f'Skipping "{self.__existing[playable.id]}": Previously downloaded',
)
continue
# Get track data
if playable.type == PlayableType.TRACK:
try:
self.restore_rate_limit(count)
with Loader("Fetching track..."):
track = self.__session.get_track(
playable.id, self.__config.download_quality
)
except RuntimeError as err:
self.handle_runtime_error(err, playable.type, count)
continue
elif playable.type == PlayableType.EPISODE:
try:
self.restore_rate_limit(count)
with Loader("Fetching episode..."):
track = self.__session.get_episode(playable.id)
except RuntimeError as err:
self.handle_runtime_error(err, playable.type, count)
continue
total_tracks = 0
if TRACK in params['type'].split(','):
tracks = resp[TRACKS][ITEMS]
if len(tracks) > 0:
print('### TRACKS ###')
track_data = []
for track in tracks:
if track[EXPLICIT]:
explicit = '[E]'
else:
Logger.log(
LogChannel.SKIPS,
f'Download Error: Unknown playable content "{playable.type}"',
)
continue
explicit = ''
# Create download location and generate file name
track.metadata.extend(playable.metadata)
try:
output = track.create_output(
self.__config.audio_format.value.ext,
playable.library,
playable.output_template,
self.__config.replace_existing,
)
except FileExistsError:
Logger.log(
LogChannel.SKIPS,
f'Skipping "{track.name}": Already exists at specified output',
)
continue
track_data.append([counter, f'{track[NAME]} {explicit}',
','.join([artist[NAME] for artist in track[ARTISTS]])])
dics.append({
ID: track[ID],
NAME: track[NAME],
'type': TRACK,
})
# Download track
with Logger.progress(
desc=f"({count}/{total}) {track.name}",
total=track.input_stream.size,
) as p_bar:
file = track.write_audio_stream(
output, p_bar, self.__config.download_real_time
)
counter += 1
total_tracks = counter - 1
print(tabulate(track_data, headers=[
'S.NO', 'Name', 'Artists'], tablefmt='pretty'))
print('\n')
del tracks
del track_data
# Download lyrics
if playable.type == PlayableType.TRACK and self.__config.lyrics_file:
if not self.__session.is_premium():
Logger.log(
LogChannel.SKIPS,
f'Failed to save lyrics for "{track.name}": Lyrics are only available to premium users',
)
total_albums = 0
if ALBUM in params['type'].split(','):
albums = resp[ALBUMS][ITEMS]
if len(albums) > 0:
print('### ALBUMS ###')
album_data = []
for album in albums:
album_data.append([counter, album[NAME],
','.join([artist[NAME] for artist in album[ARTISTS]])])
dics.append({
ID: album[ID],
NAME: album[NAME],
'type': ALBUM,
})
counter += 1
total_albums = counter - total_tracks - 1
print(tabulate(album_data, headers=[
'S.NO', 'Album', 'Artists'], tablefmt='pretty'))
print('\n')
del albums
del album_data
total_artists = 0
if ARTIST in params['type'].split(','):
artists = resp[ARTISTS][ITEMS]
if len(artists) > 0:
print('### ARTISTS ###')
artist_data = []
for artist in artists:
artist_data.append([counter, artist[NAME]])
dics.append({
ID: artist[ID],
NAME: artist[NAME],
'type': ARTIST,
})
counter += 1
total_artists = counter - total_tracks - total_albums - 1
print(tabulate(artist_data, headers=[
'S.NO', 'Name'], tablefmt='pretty'))
print('\n')
del artists
del artist_data
total_playlists = 0
if PLAYLIST in params['type'].split(','):
playlists = resp[PLAYLISTS][ITEMS]
if len(playlists) > 0:
print('### PLAYLISTS ###')
playlist_data = []
for playlist in playlists:
playlist_data.append(
[counter, playlist[NAME], playlist[OWNER][DISPLAY_NAME]])
dics.append({
ID: playlist[ID],
NAME: playlist[NAME],
'type': PLAYLIST,
})
counter += 1
total_playlists = counter - total_artists - total_tracks - total_albums - 1
print(tabulate(playlist_data, headers=[
'S.NO', 'Name', 'Owner'], tablefmt='pretty'))
print('\n')
del playlists
del playlist_data
if total_tracks + total_albums + total_artists + total_playlists == 0:
print('NO RESULTS FOUND - EXITING...')
else:
selection = ''
print('> SELECT A DOWNLOAD OPTION BY ID')
print('> SELECT A RANGE BY ADDING A DASH BETWEEN BOTH ID\'s')
print('> OR PARTICULAR OPTIONS BY ADDING A COMMA BETWEEN ID\'s\n')
while len(selection) == 0:
selection = str(input('ID(s): '))
inputs = split_input(selection)
for pos in inputs:
position = int(pos)
for dic in dics:
print_pos = dics.index(dic) + 1
if print_pos == position:
if dic['type'] == TRACK:
download_track('single', dic[ID])
elif dic['type'] == ALBUM:
download_album(dic[ID])
elif dic['type'] == ARTIST:
download_artist_albums(dic[ID])
else:
with Loader("Fetching lyrics..."):
try:
track.get_lyrics().save(output)
except FileNotFoundError as e:
Logger.log(LogChannel.SKIPS, str(e))
Logger.log(
LogChannel.DOWNLOADS, f"\nDownloaded {track.name} ({count}/{total})"
)
# Transcode audio
if (
self.__config.audio_format != AudioFormat.VORBIS
or self.__config.ffmpeg_args != ""
):
try:
with Loader("Converting audio..."):
file.transcode(
self.__config.audio_format,
self.__config.download_quality,
self.__config.transcode_bitrate,
True,
self.__config.ffmpeg_path,
self.__config.ffmpeg_args.split(),
)
except TranscodingError as e:
Logger.log(LogChannel.ERRORS, str(e))
# Write metadata
if self.__config.save_metadata:
with Loader("Writing metadata..."):
file.write_metadata(track.metadata)
file.write_cover_art(
track.get_cover_art(self.__config.artwork_size)
)
# Remove temp filename
file.clean_filename()
# Reset rate limit counter for every successful download
self.rate_limit_hits = 0
def restore_rate_limit(self, count: int) -> None:
if (
self.__session.rate_limiter.mode == RateLimitMode.REDUCED
and (count - self.last_rate_limit_hit) > RATE_LIMIT_RESTORE_CONDITION
):
with Loader("Restoring rate limit to normal..."):
self.__session.rate_limiter.set_mode(RateLimitMode.NORMAL)
sleep(RATE_LIMIT_INTERVAL_SECS)
def handle_runtime_error(
self, err: str, playable_type: PlayableType, count: int
) -> None:
Logger.log(LogChannel.SKIPS, f"Skipping {playable_type.value} #{count}: {err}")
if "audio key" in str(err).lower():
self.handle_rate_limit_hit(count)
def handle_rate_limit_hit(self, count: int) -> None:
self.rate_limit_hits += 1
self.last_rate_limit_hit = count
# Exit program if rate limit hit cutoff is reached
if self.rate_limit_hits > RATE_LIMIT_MAX_CONSECUTIVE_HITS:
Logger.log(LogChannel.ERRORS, "Server too busy or down. Try again later")
exit(1)
# Reduce internal rate limiter
if self.__session.rate_limiter.mode == RateLimitMode.NORMAL:
self.__session.rate_limiter.set_mode(RateLimitMode.REDUCED)
# Sleep for one interval
with Loader(
f"Server rate limit hit! Sleeping for {RATE_LIMIT_INTERVAL_SECS}s..."
):
sleep(RATE_LIMIT_INTERVAL_SECS)
download_playlist(dic)

340
zotify/collections.py
View file

@ -1,340 +0,0 @@
from pathlib import Path
from glob import iglob
from librespot.metadata import (
AlbumId,
ArtistId,
PlaylistId,
ShowId,
)
from zotify import ApiClient, API_MAX_REQUEST_LIMIT
from zotify.config import Config
from zotify.file import LocalFile
from zotify.utils import (
MetadataEntry,
PlayableData,
PlayableType,
bytes_to_base62,
fix_filename,
)
class Collection:
def __init__(self, api: ApiClient):
self.playables: list[PlayableData] = []
self.path: Path = None
self.api = api
self.offset = 0
def set_path(self):
if len(self.playables) == 0:
raise IndexError("Collection is empty!")
meta_tags = ["album_artist", "album", "podcast", "playlist"]
library = Path(self.playables[0].library)
output = self.playables[0].output_template
metadata = self.playables[0].metadata
for meta in metadata:
if meta.name in meta_tags:
output = output.replace(
"{" + meta.name + "}", fix_filename(meta.string)
)
if type(self) is Track or type(self) is Episode:
self.path = library
else:
self.path = library.joinpath(output).expanduser().parent
def get_existing(self, ext: str) -> dict[str, str]:
existing: dict[str, str] = {}
if self.path is None:
self.set_path()
if self.path.exists():
if type(self) is Track or type(self) is Episode:
file_path = "**/*.{}".format(ext)
else:
file_path = "*.{}".format(ext)
scan_path = str(self.path.joinpath(file_path))
# Check contents of path
for file in iglob(scan_path, recursive=True):
f_path = Path(file)
f = LocalFile(f_path)
try:
existing[f.get_metadata("spotid")] = f_path.stem
except IndexError:
pass
for playable in self.playables:
if playable.id in existing.keys():
playable.existing = True
return existing
def get_duplicates(
self, ext: str, album_lib: Path, playlist_lib: Path, podcast_lib: Path
) -> dict[str, str]:
existing: dict[str, str] = {}
duplicates: dict[str, str] = {}
scan_paths = []
if self.path is None:
self.set_path()
if self.path.exists():
file_path = "*.{}".format(ext)
collection_path = str(self.path.joinpath(file_path))
file_path = "**/*.{}".format(ext)
# Scan album library path
scan_paths.append(str(album_lib.joinpath(file_path)))
# Scan playlist library path
scan_paths.append(str(playlist_lib.joinpath(file_path)))
# Scan podcast library path
scan_paths.append(str(podcast_lib.joinpath(file_path)))
for scan_path in scan_paths:
for file in iglob(scan_path, recursive=True):
f_path = Path(file)
if self.path.exists() and f_path.match(collection_path):
continue
f = LocalFile(f_path)
try:
existing[f.get_metadata("spotid")] = f_path.stem
except IndexError:
pass
for playable in self.playables:
if playable.id in existing.keys():
playable.duplicate = True
duplicates[playable.id] = existing[playable.id]
existing = {}
return duplicates
def get_metadata(self):
params = {}
ids = ""
offset_start = self.offset
for playable in self.playables[self.offset :]:
if (
self.offset == offset_start
or (self.offset % API_MAX_REQUEST_LIMIT) != 0
):
ids = f"{ids},{playable.id}"
self.offset += 1
else:
break
metadata = []
params = {"ids": ids.strip(",")}
if isinstance(self, (Album, Artist, Playlist, Track)):
r = self.api.invoke_url(
"tracks", params, limit=API_MAX_REQUEST_LIMIT, offset=offset_start
)
for track in r["tracks"]:
# Get title, artist, and id
track_metadata = [
MetadataEntry("spotid", track["id"]),
MetadataEntry("title", track["name"]),
MetadataEntry("artists", [a["name"] for a in track["artists"]]),
]
metadata.append(track_metadata)
else:
r = self.api.invoke_url(
"episodes", params, limit=API_MAX_REQUEST_LIMIT, offset=offset_start
)
for episode in r["episodes"]:
# Get title and id
episode_metadata = [
MetadataEntry("spotid", episode["id"]),
MetadataEntry("title", episode["name"]),
]
metadata.append(episode_metadata)
return metadata
def get_match(self):
count = 0
# Output format of existing tracks must match
# with the current download command
if self.path is None:
self.set_path()
if self.path.exists():
for playable in self.playables:
if count == self.offset:
# Get new batch of metadata
metadata = self.get_metadata()
# Create file path, include all extensions
filename = Path(self.playables[0].output_template).name
filename = filename.replace("{episode_number}", "*")
filename = filename.replace("{track_number}", "*")
for meta in metadata[count % API_MAX_REQUEST_LIMIT]:
filename = filename.replace(
"{" + meta.name + "}", fix_filename(meta.string)
)
scan_path = f"{self.path.joinpath(filename)}.*"
for file in iglob(scan_path):
f = LocalFile(Path(file))
f.write_metadata(metadata[count % API_MAX_REQUEST_LIMIT])
count += 1
class Album(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
album = api.get_metadata_4_album(AlbumId.from_base62(b62_id))
for disc in album.disc:
for track in disc.track:
metadata = [
MetadataEntry("spotid", bytes_to_base62(track.gid)),
MetadataEntry("album_artist", album.artist[0].name),
MetadataEntry("album", album.name),
]
self.playables.append(
PlayableData(
PlayableType.TRACK,
bytes_to_base62(track.gid),
config.album_library,
config.output_album,
metadata,
)
)
class Artist(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
artist = api.get_metadata_4_artist(ArtistId.from_base62(b62_id))
for album_group in (
artist.album_group
or artist.single_group
or artist.compilation_group
or artist.appears_on_group
):
album = api.get_metadata_4_album(
AlbumId.from_base62(bytes_to_base62(album_group.album[0].gid))
)
for disc in album.disc:
for track in disc.track:
metadata = [
MetadataEntry("spotid", bytes_to_base62(track.gid)),
MetadataEntry("album_artist", album.artist[0].name),
MetadataEntry("album", album.name),
]
self.playables.append(
PlayableData(
PlayableType.TRACK,
bytes_to_base62(track.gid),
config.album_library,
config.output_album,
metadata,
)
)
class Show(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
show = api.get_metadata_4_show(ShowId.from_base62(b62_id))
for episode in show.episode:
metadata = [
MetadataEntry("spotid", bytes_to_base62(episode.gid)),
MetadataEntry("podcast", show.name),
]
self.playables.append(
PlayableData(
PlayableType.EPISODE,
bytes_to_base62(episode.gid),
config.podcast_library,
config.output_podcast,
metadata,
)
)
class Playlist(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
playlist = api.get_playlist(PlaylistId(b62_id))
for i in range(len(playlist.contents.items)):
item = playlist.contents.items[i]
split = item.uri.split(":")
playable_type = split[1]
playable_id = split[2]
metadata = [
MetadataEntry("spotid", playable_id),
MetadataEntry("playlist", playlist.attributes.name),
MetadataEntry("playlist_length", playlist.length),
MetadataEntry("playlist_owner", playlist.owner_username),
MetadataEntry(
"playlist_number",
i + 1,
str(i + 1).zfill(len(str(playlist.length + 1))),
),
]
if playable_type == "track":
self.playables.append(
PlayableData(
PlayableType.TRACK,
playable_id,
config.playlist_library,
config.output_playlist_track,
metadata,
)
)
elif playable_type == "episode":
self.playables.append(
PlayableData(
PlayableType.EPISODE,
playable_id,
config.playlist_library,
config.output_playlist_episode,
metadata,
)
)
elif playable_type == "local":
# Ignore local files
pass
else:
raise ValueError("Unknown playable content", playable_type)
class Track(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
metadata = [MetadataEntry("spotid", b62_id)]
self.playables.append(
PlayableData(
PlayableType.TRACK,
b62_id,
config.album_library,
config.output_album,
metadata,
)
)
class Episode(Collection):
def __init__(self, b62_id: str, api: ApiClient, config: Config = Config()):
super().__init__(api)
metadata = [MetadataEntry("spotid", b62_id)]
self.playables.append(
PlayableData(
PlayableType.EPISODE,
b62_id,
config.podcast_library,
config.output_podcast,
metadata,
)
)

635
zotify/config.py
View file

@ -1,361 +1,310 @@
from argparse import Namespace
from json import dump, load
from os import environ
from pathlib import Path
from sys import platform as PLATFORM
import json
import sys
from pathlib import Path, PurePath
from typing import Any
from zotify.utils import AudioFormat, ImageSize, Quality
ALBUM_LIBRARY = "album_library"
ALL_ARTISTS = "all_artists"
ARTWORK_SIZE = "artwork_size"
AUDIO_FORMAT = "audio_format"
CREATE_PLAYLIST_FILE = "create_playlist_file"
CREDENTIALS_PATH = "credentials_path"
DOWNLOAD_QUALITY = "download_quality"
DOWNLOAD_REAL_TIME = "download_real_time"
FFMPEG_ARGS = "ffmpeg_args"
FFMPEG_PATH = "ffmpeg_path"
LANGUAGE = "language"
LYRICS_FILE = "lyrics_file"
LYRICS_ONLY = "lyrics_only"
OUTPUT = "output"
OUTPUT_ALBUM = "output_album"
OUTPUT_PLAYLIST_TRACK = "output_playlist_track"
OUTPUT_PLAYLIST_EPISODE = "output_playlist_episode"
OUTPUT_PODCAST = "output_podcast"
OUTPUT_SINGLE = "output_single"
PATH_ARCHIVE = "path_archive"
PLAYLIST_LIBRARY = "playlist_library"
PODCAST_LIBRARY = "podcast_library"
PRINT_DOWNLOADS = "print_downloads"
PRINT_ERRORS = "print_errors"
PRINT_PROGRESS = "print_progress"
PRINT_SKIPS = "print_skips"
PRINT_WARNINGS = "print_warnings"
REPLACE_EXISTING = "replace_existing"
SAVE_METADATA = "save_metadata"
SAVE_SUBTITLES = "save_subtitles"
SKIP_DUPLICATES = "skip_duplicates"
SKIP_PREVIOUS = "skip_previous"
TRANSCODE_BITRATE = "transcode_bitrate"
SYSTEM_PATHS = {
"win32": Path.home().joinpath("AppData/Roaming/Zotify"),
"darwin": Path.home().joinpath("Library/Application Support/Zotify"),
"linux": Path(environ.get("XDG_CONFIG_HOME") or "~/.config")
.expanduser()
.joinpath("zotify"),
}
LIBRARY_PATHS = {
"album": Path.home().joinpath("Music/Zotify Albums"),
"podcast": Path.home().joinpath("Music/Zotify Podcasts"),
"playlist": Path.home().joinpath("Music/Zotify Playlists"),
}
CONFIG_PATHS = {
"conf": SYSTEM_PATHS[PLATFORM].joinpath("config.json"),
"creds": SYSTEM_PATHS[PLATFORM].joinpath("credentials.json"),
"archive": SYSTEM_PATHS[PLATFORM].joinpath("track_archive"),
}
OUTPUT_PATHS = {
"album": "{album_artist}/{album}/{track_number}. {artists} - {title}",
"podcast": "{podcast}/{episode_number} - {title}",
"playlist_track": "{playlist}/{artists} - {title}",
"playlist_episode": "{playlist}/{episode_number} - {title}",
}
ROOT_PATH = 'ROOT_PATH'
ROOT_PODCAST_PATH = 'ROOT_PODCAST_PATH'
SKIP_EXISTING = 'SKIP_EXISTING'
SKIP_PREVIOUSLY_DOWNLOADED = 'SKIP_PREVIOUSLY_DOWNLOADED'
DOWNLOAD_FORMAT = 'DOWNLOAD_FORMAT'
BULK_WAIT_TIME = 'BULK_WAIT_TIME'
OVERRIDE_AUTO_WAIT = 'OVERRIDE_AUTO_WAIT'
CHUNK_SIZE = 'CHUNK_SIZE'
SPLIT_ALBUM_DISCS = 'SPLIT_ALBUM_DISCS'
DOWNLOAD_REAL_TIME = 'DOWNLOAD_REAL_TIME'
LANGUAGE = 'LANGUAGE'
DOWNLOAD_QUALITY = 'DOWNLOAD_QUALITY'
TRANSCODE_BITRATE = 'TRANSCODE_BITRATE'
SONG_ARCHIVE = 'SONG_ARCHIVE'
SAVE_CREDENTIALS = 'SAVE_CREDENTIALS'
CREDENTIALS_LOCATION = 'CREDENTIALS_LOCATION'
OUTPUT = 'OUTPUT'
PRINT_SPLASH = 'PRINT_SPLASH'
PRINT_SKIPS = 'PRINT_SKIPS'
PRINT_DOWNLOAD_PROGRESS = 'PRINT_DOWNLOAD_PROGRESS'
PRINT_ERRORS = 'PRINT_ERRORS'
PRINT_DOWNLOADS = 'PRINT_DOWNLOADS'
PRINT_API_ERRORS = 'PRINT_API_ERRORS'
TEMP_DOWNLOAD_DIR = 'TEMP_DOWNLOAD_DIR'
MD_SAVE_GENRES = 'MD_SAVE_GENRES'
MD_ALLGENRES = 'MD_ALLGENRES'
MD_GENREDELIMITER = 'MD_GENREDELIMITER'
PRINT_PROGRESS_INFO = 'PRINT_PROGRESS_INFO'
PRINT_WARNINGS = 'PRINT_WARNINGS'
RETRY_ATTEMPTS = 'RETRY_ATTEMPTS'
CONFIG_VERSION = 'CONFIG_VERSION'
DOWNLOAD_LYRICS = 'DOWNLOAD_LYRICS'
CONFIG_VALUES = {
CREDENTIALS_PATH: {
"default": CONFIG_PATHS["creds"],
"type": Path,
"args": ["--credentials"],
"help": "Path to credentials file",
},
PATH_ARCHIVE: {
"default": CONFIG_PATHS["archive"],
"type": Path,
"args": ["--archive"],
"help": "Path to track archive file",
},
ALBUM_LIBRARY: {
"default": LIBRARY_PATHS["album"],
"type": Path,
"args": ["--album-library"],
"help": "Path to root of album library",
},
PODCAST_LIBRARY: {
"default": LIBRARY_PATHS["podcast"],
"type": Path,
"args": ["--podcast-library"],
"help": "Path to root of podcast library",
},
PLAYLIST_LIBRARY: {
"default": LIBRARY_PATHS["playlist"],
"type": Path,
"args": ["--playlist-library"],
"help": "Path to root of playlist library",
},
OUTPUT_ALBUM: {
"default": OUTPUT_PATHS["album"],
"type": str,
"args": ["--output-album", "-oa"],
"help": "File layout for saved albums",
},
OUTPUT_PLAYLIST_TRACK: {
"default": OUTPUT_PATHS["playlist_track"],
"type": str,
"args": ["--output-playlist-track", "-opt"],
"help": "File layout for tracks in a playlist",
},
OUTPUT_PLAYLIST_EPISODE: {
"default": OUTPUT_PATHS["playlist_episode"],
"type": str,
"args": ["--output-playlist-episode", "-ope"],
"help": "File layout for episodes in a playlist",
},
OUTPUT_PODCAST: {
"default": OUTPUT_PATHS["podcast"],
"type": str,
"args": ["--output-podcast", "-op"],
"help": "File layout for saved podcasts",
},
DOWNLOAD_QUALITY: {
"default": "auto",
"type": Quality.from_string,
"choices": list(Quality),
"args": ["--download-quality"],
"help": "Audio download quality (auto for highest available)",
},
DOWNLOAD_REAL_TIME: {
"default": False,
"type": bool,
"args": ["--download-real-time"],
"help": "Download at the same rate as the track being played",
},
ARTWORK_SIZE: {
"default": "large",
"type": ImageSize.from_string,
"choices": list(ImageSize),
"args": ["--artwork-size"],
"help": "Image size of track's cover art",
},
AUDIO_FORMAT: {
"default": "vorbis",
"type": AudioFormat.from_string,
"choices": list(AudioFormat),
"args": ["--audio-format"],
"help": "Audio format of final track output",
},
TRANSCODE_BITRATE: {
"default": -1,
"type": int,
"args": ["--bitrate"],
"help": "Transcoding bitrate (-1 to use download rate)",
},
FFMPEG_PATH: {
"default": "",
"type": str,
"args": ["--ffmpeg-path"],
"help": "Path to ffmpeg binary",
},
FFMPEG_ARGS: {
"default": "",
"type": str,
"args": ["--ffmpeg-args"],
"help": "Additional ffmpeg arguments when transcoding",
},
SAVE_SUBTITLES: {
"default": False,
"type": bool,
"args": ["--save-subtitles"],
"help": "Save subtitles from podcasts to a .srt file",
},
LANGUAGE: {
"default": "en",
"type": str,
"args": ["--language"],
"help": "Language for metadata",
},
LYRICS_FILE: {
"default": False,
"type": bool,
"args": ["--lyrics-file"],
"help": "Save lyrics to a file",
},
LYRICS_ONLY: {
"default": False,
"type": bool,
"args": ["--lyrics-only"],
"help": "Only download lyrics and not actual audio",
},
CREATE_PLAYLIST_FILE: {
"default": True,
"type": bool,
"args": ["--playlist-file"],
"help": "Save playlist information to an m3u8 file",
},
SAVE_METADATA: {
"default": True,
"type": bool,
"args": ["--save-metadata"],
"help": "Save metadata, required for other metadata options",
},
ALL_ARTISTS: {
"default": True,
"type": bool,
"args": ["--all-artists"],
"help": "Add all track artists to artist tag in metadata",
},
REPLACE_EXISTING: {
"default": False,
"type": bool,
"args": ["--replace-existing"],
"help": "Overwrite existing files with the same name",
},
SKIP_PREVIOUS: {
"default": True,
"type": bool,
"args": ["--skip-previous"],
"help": "Skip previously downloaded songs",
},
SKIP_DUPLICATES: {
"default": True,
"type": bool,
"args": ["--skip-duplicates"],
"help": "Skip downloading existing track to different album",
},
PRINT_DOWNLOADS: {
"default": False,
"type": bool,
"args": ["--print-downloads"],
"help": "Print messages when a song is finished downloading",
},
PRINT_PROGRESS: {
"default": True,
"type": bool,
"args": ["--print-progress"],
"help": "Show progress bars",
},
PRINT_SKIPS: {
"default": False,
"type": bool,
"args": ["--print-skips"],
"help": "Show messages if a song is being skipped",
},
PRINT_WARNINGS: {
"default": True,
"type": bool,
"args": ["--print-warnings"],
"help": "Show warnings",
},
PRINT_ERRORS: {
"default": True,
"type": bool,
"args": ["--print-errors"],
"help": "Show errors",
},
SAVE_CREDENTIALS: { 'default': 'True', 'type': bool, 'arg': '--save-credentials' },
CREDENTIALS_LOCATION: { 'default': '', 'type': str, 'arg': '--credentials-location' },
OUTPUT: { 'default': '', 'type': str, 'arg': '--output' },
SONG_ARCHIVE: { 'default': '', 'type': str, 'arg': '--song-archive' },
ROOT_PATH: { 'default': '', 'type': str, 'arg': '--root-path' },
ROOT_PODCAST_PATH: { 'default': '', 'type': str, 'arg': '--root-podcast-path' },
SPLIT_ALBUM_DISCS: { 'default': 'False', 'type': bool, 'arg': '--split-album-discs' },
DOWNLOAD_LYRICS: { 'default': 'True', 'type': bool, 'arg': '--download-lyrics' },
MD_SAVE_GENRES: { 'default': 'False', 'type': bool, 'arg': '--md-save-genres' },
MD_ALLGENRES: { 'default': 'False', 'type': bool, 'arg': '--md-allgenres' },
MD_GENREDELIMITER: { 'default': ',', 'type': str, 'arg': '--md-genredelimiter' },
DOWNLOAD_FORMAT: { 'default': 'ogg', 'type': str, 'arg': '--download-format' },
DOWNLOAD_QUALITY: { 'default': 'auto', 'type': str, 'arg': '--download-quality' },
TRANSCODE_BITRATE: { 'default': 'auto', 'type': str, 'arg': '--transcode-bitrate' },
SKIP_EXISTING: { 'default': 'True', 'type': bool, 'arg': '--skip-existing' },
SKIP_PREVIOUSLY_DOWNLOADED: { 'default': 'False', 'type': bool, 'arg': '--skip-previously-downloaded' },
RETRY_ATTEMPTS: { 'default': '1', 'type': int, 'arg': '--retry-attempts' },
BULK_WAIT_TIME: { 'default': '1', 'type': int, 'arg': '--bulk-wait-time' },
OVERRIDE_AUTO_WAIT: { 'default': 'False', 'type': bool, 'arg': '--override-auto-wait' },
CHUNK_SIZE: { 'default': '20000', 'type': int, 'arg': '--chunk-size' },
DOWNLOAD_REAL_TIME: { 'default': 'False', 'type': bool, 'arg': '--download-real-time' },
LANGUAGE: { 'default': 'en', 'type': str, 'arg': '--language' },
PRINT_SPLASH: { 'default': 'False', 'type': bool, 'arg': '--print-splash' },
PRINT_SKIPS: { 'default': 'True', 'type': bool, 'arg': '--print-skips' },
PRINT_DOWNLOAD_PROGRESS: { 'default': 'True', 'type': bool, 'arg': '--print-download-progress' },
PRINT_ERRORS: { 'default': 'True', 'type': bool, 'arg': '--print-errors' },
PRINT_DOWNLOADS: { 'default': 'False', 'type': bool, 'arg': '--print-downloads' },
PRINT_API_ERRORS: { 'default': 'True', 'type': bool, 'arg': '--print-api-errors' },
PRINT_PROGRESS_INFO: { 'default': 'True', 'type': bool, 'arg': '--print-progress-info' },
PRINT_WARNINGS: { 'default': 'True', 'type': bool, 'arg': '--print-warnings' },
TEMP_DOWNLOAD_DIR: { 'default': '', 'type': str, 'arg': '--temp-download-dir' }
}
OUTPUT_DEFAULT_PLAYLIST = '{playlist}/{artist} - {song_name}.{ext}'
OUTPUT_DEFAULT_PLAYLIST_EXT = '{playlist}/{playlist_num} - {artist} - {song_name}.{ext}'
OUTPUT_DEFAULT_LIKED_SONGS = 'Liked Songs/{artist} - {song_name}.{ext}'
OUTPUT_DEFAULT_SINGLE = '{artist}/{album}/{artist} - {song_name}.{ext}'
OUTPUT_DEFAULT_ALBUM = '{artist}/{album}/{album_num} - {artist} - {song_name}.{ext}'
class Config:
__config_file: Path | None
album_library: Path
artwork_size: ImageSize
audio_format: AudioFormat
credentials_path: Path
download_quality: Quality
download_real_time: bool
ffmpeg_args: str
ffmpeg_path: str
language: str
lyrics_file: bool
output_album: str
output_podcast: str
output_playlist_track: str
output_playlist_episode: str
playlist_library: Path
podcast_library: Path
print_progress: bool
replace_existing: bool
save_metadata: bool
transcode_bitrate: int
Values = {}
def __init__(self, args: Namespace | None = None):
jsonvalues = {}
if args is not None and args.config:
self.__config_file = Path(args.config)
# Valid config file found
if self.__config_file.exists():
with open(self.__config_file, "r", encoding="utf-8") as conf:
jsonvalues = load(conf)
# Remove config file and make a new one
else:
self.__config_file.parent.mkdir(parents=True, exist_ok=True)
jsonvalues = {}
for key in CONFIG_VALUES:
if CONFIG_VALUES[key]["type"] in [str, int, bool]:
jsonvalues[key] = CONFIG_VALUES[key]["default"]
else:
jsonvalues[key] = str(CONFIG_VALUES[key]["default"])
with open(self.__config_file, "w+", encoding="utf-8") as conf:
dump(jsonvalues, conf, indent=4)
@classmethod
def load(cls, args) -> None:
system_paths = {
'win32': Path.home() / 'AppData/Roaming/Zotify',
'linux': Path.home() / '.config/zotify',
'darwin': Path.home() / 'Library/Application Support/Zotify'
}
if sys.platform not in system_paths:
config_fp = Path.cwd() / '.zotify/config.json'
else:
self.__config_file = None
config_fp = system_paths[sys.platform] / 'config.json'
if args.config_location:
config_fp = args.config_location
true_config_file_path = Path(config_fp).expanduser()
# Load config from zconfig.json
Path(PurePath(true_config_file_path).parent).mkdir(parents=True, exist_ok=True)
if not Path(true_config_file_path).exists():
with open(true_config_file_path, 'w', encoding='utf-8') as config_file:
json.dump(cls.get_default_json(), config_file, indent=4)
with open(true_config_file_path, encoding='utf-8') as config_file:
jsonvalues = json.load(config_file)
cls.Values = {}
for key in CONFIG_VALUES:
if key in jsonvalues:
cls.Values[key] = cls.parse_arg_value(key, jsonvalues[key])
# Add default values for missing keys
for key in CONFIG_VALUES:
# Override config with commandline arguments
if args is not None and key in vars(args) and vars(args)[key] is not None:
setattr(self, key, self.__parse_arg_value(key, vars(args)[key]))
# If no command option specified use config
elif key in jsonvalues:
setattr(self, key, self.__parse_arg_value(key, jsonvalues[key]))
# Use default values for missing keys
else:
setattr(
self,
key,
self.__parse_arg_value(key, CONFIG_VALUES[key]["default"]),
)
if key not in cls.Values:
cls.Values[key] = cls.parse_arg_value(key, CONFIG_VALUES[key]['default'])
# "library" arg overrides all *_library options
if args is not None and args.library:
self.album_library = Path(args.library).expanduser().resolve()
self.playlist_library = Path(args.library).expanduser().resolve()
self.podcast_library = Path(args.library).expanduser().resolve()
# Override config from commandline arguments
# "output" arg overrides all output_* options
if args is not None and args.output:
self.output_album = args.output
self.output_podcast = args.output
self.output_playlist_track = args.output
self.output_playlist_episode = args.output
for key in CONFIG_VALUES:
if key.lower() in vars(args) and vars(args)[key.lower()] is not None:
cls.Values[key] = cls.parse_arg_value(key, vars(args)[key.lower()])
@staticmethod
def __parse_arg_value(key: str, value: Any) -> Any:
config_type = CONFIG_VALUES[key]["type"]
if type(value) is config_type:
if args.no_splash:
cls.Values[PRINT_SPLASH] = False
@classmethod
def get_default_json(cls) -> Any:
r = {}
for key in CONFIG_VALUES:
r[key] = CONFIG_VALUES[key]['default']
return r
@classmethod
def parse_arg_value(cls, key: str, value: Any) -> Any:
if type(value) == CONFIG_VALUES[key]['type']:
return value
elif config_type == Path:
return Path(value).expanduser().resolve()
elif config_type == AudioFormat.from_string:
return AudioFormat.from_string(value)
elif config_type == ImageSize.from_string:
return ImageSize.from_string(value)
elif config_type == Quality.from_string:
return Quality.from_string(value)
else:
raise TypeError("Invalid Type: " + value)
if CONFIG_VALUES[key]['type'] == str:
return str(value)
if CONFIG_VALUES[key]['type'] == int:
return int(value)
if CONFIG_VALUES[key]['type'] == bool:
if str(value).lower() in ['yes', 'true', '1']:
return True
if str(value).lower() in ['no', 'false', '0']:
return False
raise ValueError("Not a boolean: " + value)
raise ValueError("Unknown Type: " + value)
def get(self, key: str) -> Any:
"""
Gets a value from config
Args:
key: config attribute to return value of
Returns:
Value of key
"""
return getattr(self, key)
@classmethod
def get(cls, key: str) -> Any:
return cls.Values.get(key)
@classmethod
def get_root_path(cls) -> str:
if cls.get(ROOT_PATH) == '':
root_path = PurePath(Path.home() / 'Music/Zotify Music/')
else:
root_path = PurePath(Path(cls.get(ROOT_PATH)).expanduser())
Path(root_path).mkdir(parents=True, exist_ok=True)
return root_path
@classmethod
def get_root_podcast_path(cls) -> str:
if cls.get(ROOT_PODCAST_PATH) == '':
root_podcast_path = PurePath(Path.home() / 'Music/Zotify Podcasts/')
else:
root_podcast_path = PurePath(Path(cls.get(ROOT_PODCAST_PATH)).expanduser())
Path(root_podcast_path).mkdir(parents=True, exist_ok=True)
return root_podcast_path
@classmethod
def get_skip_existing(cls) -> bool:
return cls.get(SKIP_EXISTING)
@classmethod
def get_skip_previously_downloaded(cls) -> bool:
return cls.get(SKIP_PREVIOUSLY_DOWNLOADED)
@classmethod
def get_split_album_discs(cls) -> bool:
return cls.get(SPLIT_ALBUM_DISCS)
@classmethod
def get_chunk_size(cls) -> int:
return cls.get(CHUNK_SIZE)
@classmethod
def get_override_auto_wait(cls) -> bool:
return cls.get(OVERRIDE_AUTO_WAIT)
@classmethod
def get_download_format(cls) -> str:
return cls.get(DOWNLOAD_FORMAT)
@classmethod
def get_download_lyrics(cls) -> bool:
return cls.get(DOWNLOAD_LYRICS)
@classmethod
def get_bulk_wait_time(cls) -> int:
return cls.get(BULK_WAIT_TIME)
@classmethod
def get_language(cls) -> str:
return cls.get(LANGUAGE)
@classmethod
def get_download_real_time(cls) -> bool:
return cls.get(DOWNLOAD_REAL_TIME)
@classmethod
def get_download_quality(cls) -> str:
return cls.get(DOWNLOAD_QUALITY)
@classmethod
def get_transcode_bitrate(cls) -> str:
return cls.get(TRANSCODE_BITRATE)
@classmethod
def get_song_archive(cls) -> str:
if cls.get(SONG_ARCHIVE) == '':
system_paths = {
'win32': Path.home() / 'AppData/Roaming/Zotify',
'linux': Path.home() / '.local/share/zotify',
'darwin': Path.home() / 'Library/Application Support/Zotify'
}
if sys.platform not in system_paths:
song_archive = PurePath(Path.cwd() / '.zotify/.song_archive')
else:
song_archive = PurePath(system_paths[sys.platform] / '.song_archive')
else:
song_archive = PurePath(Path(cls.get(SONG_ARCHIVE)).expanduser())
Path(song_archive.parent).mkdir(parents=True, exist_ok=True)
return song_archive
@classmethod
def get_save_credentials(cls) -> bool:
return cls.get(SAVE_CREDENTIALS)
@classmethod
def get_credentials_location(cls) -> str:
if cls.get(CREDENTIALS_LOCATION) == '':
system_paths = {
'win32': Path.home() / 'AppData/Roaming/Zotify',
'linux': Path.home() / '.local/share/zotify',
'darwin': Path.home() / 'Library/Application Support/Zotify'
}
if sys.platform not in system_paths:
credentials_location = PurePath(Path.cwd() / '.zotify/credentials.json')
else:
credentials_location = PurePath(system_paths[sys.platform] / 'credentials.json')
else:
credentials_location = PurePath(Path.cwd()).joinpath(cls.get(CREDENTIALS_LOCATION))
Path(credentials_location.parent).mkdir(parents=True, exist_ok=True)
return credentials_location
@classmethod
def get_temp_download_dir(cls) -> str:
if cls.get(TEMP_DOWNLOAD_DIR) == '':
return ''
return PurePath(cls.get_root_path()).joinpath(cls.get(TEMP_DOWNLOAD_DIR))
@classmethod
def get_save_genres(cls) -> bool:
return cls.get(MD_SAVE_GENRES)
@classmethod
def get_all_genres(cls) -> bool:
return cls.get(MD_ALLGENRES)
@classmethod
def get_all_genres_delimiter(cls) -> bool:
return cls.get(MD_GENREDELIMITER)
@classmethod
def get_output(cls, mode: str) -> str:
v = cls.get(OUTPUT)
if v:
return v
if mode == 'playlist':
if cls.get_split_album_discs():
split = PurePath(OUTPUT_DEFAULT_PLAYLIST).parent
return PurePath(split).joinpath('Disc {disc_number}').joinpath(split)
return OUTPUT_DEFAULT_PLAYLIST
if mode == 'extplaylist':
if cls.get_split_album_discs():
split = PurePath(OUTPUT_DEFAULT_PLAYLIST_EXT).parent
return PurePath(split).joinpath('Disc {disc_number}').joinpath(split)
return OUTPUT_DEFAULT_PLAYLIST_EXT
if mode == 'liked':
if cls.get_split_album_discs():
split = PurePath(OUTPUT_DEFAULT_LIKED_SONGS).parent
return PurePath(split).joinpath('Disc {disc_number}').joinpath(split)
return OUTPUT_DEFAULT_LIKED_SONGS
if mode == 'single':
if cls.get_split_album_discs():
split = PurePath(OUTPUT_DEFAULT_SINGLE).parent
return PurePath(split).joinpath('Disc {disc_number}').joinpath(split)
return OUTPUT_DEFAULT_SINGLE
if mode == 'album':
if cls.get_split_album_discs():
split = PurePath(OUTPUT_DEFAULT_ALBUM).parent
return PurePath(split).joinpath('Disc {disc_number}').joinpath(split)
return OUTPUT_DEFAULT_ALBUM
raise ValueError()
@classmethod
def get_retry_attempts(cls) -> int:
return cls.get(RETRY_ATTEMPTS)

115
zotify/const.py Normal file
View file

@ -0,0 +1,115 @@
FOLLOWED_ARTISTS_URL = 'https://api.spotify.com/v1/me/following?type=artist'
SAVED_TRACKS_URL = 'https://api.spotify.com/v1/me/tracks'
TRACKS_URL = 'https://api.spotify.com/v1/tracks'
TRACK_STATS_URL = 'https://api.spotify.com/v1/audio-features/'
TRACKNUMBER = 'tracknumber'
DISCNUMBER = 'discnumber'
YEAR = 'year'
ALBUM = 'album'
TRACKTITLE = 'tracktitle'
ARTIST = 'artist'
ARTISTS = 'artists'
ALBUMARTIST = 'albumartist'
GENRES = 'genres'
GENRE = 'genre'
ARTWORK = 'artwork'
TRACKS = 'tracks'
TRACK = 'track'
ITEMS = 'items'
NAME = 'name'
HREF = 'href'
ID = 'id'
URL = 'url'
RELEASE_DATE = 'release_date'
IMAGES = 'images'
LIMIT = 'limit'
OFFSET = 'offset'
AUTHORIZATION = 'Authorization'
IS_PLAYABLE = 'is_playable'
DURATION_MS = 'duration_ms'
TRACK_NUMBER = 'track_number'
DISC_NUMBER = 'disc_number'
SHOW = 'show'
ERROR = 'error'
EXPLICIT = 'explicit'
PLAYLIST = 'playlist'
PLAYLISTS = 'playlists'
OWNER = 'owner'
DISPLAY_NAME = 'display_name'
ALBUMS = 'albums'
TYPE = 'type'
PREMIUM = 'premium'
WIDTH = 'width'
USER_READ_EMAIL = 'user-read-email'
USER_FOLLOW_READ = 'user-follow-read'
PLAYLIST_READ_PRIVATE = 'playlist-read-private'
USER_LIBRARY_READ = 'user-library-read'
WINDOWS_SYSTEM = 'Windows'
LINUX_SYSTEM = 'Linux'
CODEC_MAP = {
'aac': 'aac',
'fdk_aac': 'libfdk_aac',
'm4a': 'aac',
'mp3': 'libmp3lame',
'ogg': 'copy',
'opus': 'libopus',
'vorbis': 'copy',
}
EXT_MAP = {
'aac': 'm4a',
'fdk_aac': 'm4a',
'm4a': 'm4a',
'mp3': 'mp3',
'ogg': 'ogg',
'opus': 'ogg',
'vorbis': 'ogg',
}

142
zotify/file.py
View file

@ -1,142 +0,0 @@
from errno import ENOENT
from pathlib import Path
from subprocess import PIPE, Popen
from music_tag import load_file
from mutagen.oggvorbis import OggVorbisHeaderError
from zotify.utils import AudioFormat, MetadataEntry, Quality
class TranscodingError(RuntimeError): ...
class LocalFile:
def __init__(
self,
path: Path,
audio_format: AudioFormat | None = None,
bitrate: int = -1,
):
self.__path = path
self.__audio_format = audio_format
self.__bitrate = bitrate
def transcode(
self,
audio_format: AudioFormat | None = None,
download_quality: Quality | None = None,
bitrate: int = -1,
replace: bool = False,
ffmpeg: str = "",
opt_args: list[str] = [],
) -> None:
"""
Use ffmpeg to transcode a saved audio file
Args:
audio_format: Audio format to transcode file to
bitrate: Bitrate to transcode file to in kbps
replace: Replace existing file
ffmpeg: Location of FFmpeg binary
opt_args: Additional arguments to pass to ffmpeg
"""
if not audio_format:
audio_format = self.__audio_format
if audio_format:
ext = audio_format.value.ext
else:
ext = self.__path.suffix[1:]
cmd = [
ffmpeg if ffmpeg != "" else "ffmpeg",
"-y",
"-hide_banner",
"-loglevel",
"error",
"-i",
str(self.__path),
]
path = self.__path.parent.joinpath(
self.__path.name.rsplit(".", 1)[0] + "." + ext
)
if self.__path == path:
raise TranscodingError(
f"Cannot overwrite source, target file {path} already exists."
)
if bitrate > 0:
cmd.extend(["-b:a", str(bitrate) + "k"])
else:
cmd.extend(["-b:a", str(Quality.get_bitrate(download_quality)) + "k"])
cmd.extend(["-c:a", audio_format.value.name]) if audio_format else None
cmd.extend(opt_args)
cmd.append(str(path))
try:
process = Popen(cmd, stdin=PIPE)
process.wait()
except OSError as e:
if e.errno == ENOENT:
raise TranscodingError("FFmpeg was not found")
else:
raise
if process.returncode != 0:
raise TranscodingError(
f'`{" ".join(cmd)}` failed with error code {process.returncode}'
)
if replace:
self.__path.unlink()
self.__path = path
self.__audio_format = audio_format
self.__bitrate = bitrate
def write_metadata(self, metadata: list[MetadataEntry]) -> None:
"""
Write metadata to file
Args:
metadata: key-value metadata dictionary
"""
f = load_file(self.__path)
f.save()
for m in metadata:
try:
f[m.name] = m.value
except KeyError:
pass # TODO
try:
f.save()
except OggVorbisHeaderError:
pass # Thrown when using untranscoded file, nothing breaks.
def write_cover_art(self, image: bytes) -> None:
"""
Write cover artwork to file
Args:
image: raw image data
"""
f = load_file(self.__path)
f["artwork"] = image
try:
f.save()
except OggVorbisHeaderError:
pass # Thrown when using untranscoded file, nothing breaks.
def get_metadata(self, tag: str) -> str:
"""
Gets metadata from file
Args:
tag: metadata tag to be retrieved
"""
f = load_file(self.__path)
return f[tag].value
def clean_filename(self) -> None:
"""
Removes tmp suffix on filename
Args:
None
"""
path = self.__path
clean = path.name.replace("_tmp", "")
path.rename(path.parent.joinpath(clean))

46
zotify/loader.py
View file

@ -1,19 +1,17 @@
# load symbol from:
# https://stackoverflow.com/questions/22029562/python-how-to-make-simple-animated-loading-while-process-is-running
from __future__ import annotations
# imports
from itertools import cycle
from shutil import get_terminal_size
from sys import platform as PLATFORM
from threading import Thread
from time import sleep
from zotify.logger import Logger
from zotify.termoutput import Printer
class Loader:
"""
Busy symbol.
"""Busy symbol.
Can be called inside a context:
@ -21,10 +19,10 @@ class Loader:
# do something
pass
"""
def __init__(self, desc: str = "Loading...", end: str = "", timeout: float = 0.1):
def __init__(self, chan, desc="Loading...", end='', timeout=0.1, mode='prog'):
"""
A loader-like context manager
Args:
desc (str, optional): The loader's description. Defaults to "Loading...".
end (str, optional): Final print. Defaults to "".
@ -33,38 +31,42 @@ class Loader:
self.desc = desc
self.end = end
self.timeout = timeout
self.channel = chan
self.__thread = Thread(target=self.__animate, daemon=True)
# Cool loader looks awful in cmd
if PLATFORM == "win32":
self.steps = ["/", "-", "\\", "|"]
else:
self.steps = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]
self._thread = Thread(target=self._animate, daemon=True)
if mode == 'std1':
self.steps = ["⢿", "⣻", "⣽", "⣾", "⣷", "⣯", "⣟", "⡿"]
elif mode == 'std2':
self.steps = ["◜","◝","◞","◟"]
elif mode == 'std3':
self.steps = ["😐 ","😐 ","😮 ","😮 ","😦 ","😦 ","😧 ","😧 ","🤯 ","💥 ","✨ ","\u3000 ","\u3000 ","\u3000 "]
elif mode == 'prog':
self.steps = ["[∙∙∙]","[●∙∙]","[∙●∙]","[∙∙●]","[∙∙∙]"]
self.done = False
def start(self) -> Loader:
self.__thread.start()
def start(self):
self._thread.start()
return self
def __animate(self) -> None:
def _animate(self):
for c in cycle(self.steps):
if self.done:
break
Logger.print_loader(f"\r {c} {self.desc} ")
Printer.print_loader(self.channel, f"\r\t{c} {self.desc} ")
sleep(self.timeout)
def __enter__(self) -> None:
def __enter__(self):
self.start()
def stop(self) -> None:
def stop(self):
self.done = True
cols = get_terminal_size((80, 20)).columns
Logger.print_loader("\r" + " " * cols)
Printer.print_loader(self.channel, "\r" + " " * cols)
if self.end != "":
Logger.print_loader(f"\r{self.end}")
Printer.print_loader(self.channel, f"\r{self.end}")
def __exit__(self, exc_type, exc_value, tb) -> None:
def __exit__(self, exc_type, exc_value, tb):
# handle exceptions with those variables ^
self.stop()

82
zotify/logger.py
View file

@ -1,82 +0,0 @@
from enum import Enum
from sys import stderr
from tqdm import tqdm
from zotify.config import (
PRINT_DOWNLOADS,
PRINT_ERRORS,
PRINT_PROGRESS,
PRINT_SKIPS,
PRINT_WARNINGS,
Config,
)
class LogChannel(Enum):
SKIPS = PRINT_SKIPS
PROGRESS = PRINT_PROGRESS
ERRORS = PRINT_ERRORS
WARNINGS = PRINT_WARNINGS
DOWNLOADS = PRINT_DOWNLOADS
class Logger:
__config: Config = Config()
@classmethod
def __init__(cls, config: Config):
cls.__config = config
@classmethod
def log(cls, channel: LogChannel, msg: str) -> None:
"""
Prints a message to console if the print channel is enabled
Args:
channel: LogChannel to print to
msg: Message to log
"""
if cls.__config.get(channel.value):
if channel == LogChannel.ERRORS:
print(msg, file=stderr)
else:
print(msg)
@classmethod
def progress(
cls,
iterable=None,
desc=None,
total=None,
leave=False,
position=0,
unit="B",
unit_scale=True,
unit_divisor=1024,
) -> tqdm:
"""
Prints progress bar
Returns:
tqdm decorated iterable
"""
return tqdm(
iterable=iterable,
desc=desc,
total=total,
disable=not cls.__config.print_progress,
leave=leave,
position=position,
unit=unit,
unit_scale=unit_scale,
unit_divisor=unit_divisor,
)
@classmethod
def print_loader(cls, msg: str) -> None:
"""
Prints animated loading symbol
Args:
msg: Message to display
"""
if cls.__config.print_progress:
print(msg, flush=True, end="")

272
zotify/playable.py
View file

@ -1,272 +0,0 @@
from math import floor
from pathlib import Path
from time import time, sleep
from librespot.core import PlayableContentFeeder
from librespot.metadata import AlbumId
from librespot.proto import Metadata_pb2 as Metadata
from librespot.structure import GeneralAudioStream
from librespot.util import bytes_to_hex
from requests import get
from tqdm import tqdm
from zotify.file import LocalFile
from zotify.utils import (
AudioFormat,
ImageSize,
MetadataEntry,
bytes_to_base62,
fix_filename,
)
IMG_URL = "https://i.scdn.co/image/"
LYRICS_URL = "https://spclient.wg.spotify.com/color-lyrics/v2/track/"
class Lyrics:
def __init__(self, lyrics: dict, **kwargs):
self.__lines = []
self.__sync_type = lyrics["syncType"]
for line in lyrics["lines"]:
self.__lines.append(line["words"] + "\n")
if self.__sync_type == "line_synced":
self.__lines_synced = []
for line in lyrics["lines"]:
timestamp = int(line["start_time_ms"])
ts_minutes = str(floor(timestamp / 60000)).zfill(2)
ts_seconds = str(floor((timestamp % 60000) / 1000)).zfill(2)
ts_millis = str(floor(timestamp % 1000))[:2].zfill(2)
self.__lines_synced.append(
f"[{ts_minutes}:{ts_seconds}.{ts_millis}]{line.words}\n"
)
def save(self, path: Path | str, prefer_synced: bool = True) -> None:
"""
Saves lyrics to file
Args:
location: path to target lyrics file
prefer_synced: Use line synced lyrics if available
"""
if not isinstance(path, Path):
path = Path(path).expanduser()
if self.__sync_type == "line_synced" and prefer_synced:
with open(f"{path}.lrc", "w+", encoding="utf-8") as f:
f.writelines(self.__lines_synced)
else:
with open(f"{path}.txt", "w+", encoding="utf-8") as f:
f.writelines(self.__lines[:-1])
class Playable:
cover_images: list[Metadata.Image]
input_stream: GeneralAudioStream
metadata: list[MetadataEntry]
name: str
def create_output(
self,
ext: str,
library: Path | str = Path("./"),
output: str = "{title}",
replace: bool = False,
) -> Path:
"""
Creates save directory for the output file
Args:
library: Path to root content library
output: Template for the output filepath
replace: Replace existing files with same output
Returns:
File path for the track
"""
if not isinstance(library, Path):
library = Path(library)
for meta in self.metadata:
if meta.string is not None and len(meta.string) < 100:
output = output.replace(
"{" + meta.name + "}", fix_filename(meta.string)
)
else:
if "," in meta.string:
shortened = ",".join(meta.string.split(",", 3)[:3])
else:
shortened = f"{meta.string[:50]}..."
output = output.replace("{" + meta.name + "}", fix_filename(shortened))
if meta.name == "spotid":
spotid = meta.string
file_path = library.joinpath(output).expanduser()
check_path = Path(f"{file_path}.{ext}")
if check_path.exists():
f = LocalFile(check_path)
f_spotid = None
try:
f_spotid = f.get_metadata("spotid")
except IndexError:
pass
if f_spotid != spotid:
file_path = Path(f"{file_path} (SpotId:{spotid[-5:]})")
else:
if not replace:
raise FileExistsError("File already downloaded")
else:
file_path.parent.mkdir(parents=True, exist_ok=True)
return file_path
def write_audio_stream(
self,
output: Path | str,
p_bar: tqdm = tqdm(disable=True),
real_time: bool = False,
) -> LocalFile:
"""
Writes audio stream to file
Args:
output: File path of saved audio stream
p_bar: tqdm progress bar
Returns:
LocalFile object
"""
if not isinstance(output, Path):
output = Path(output).expanduser()
file = f"{output}_tmp.ogg"
time_start = time()
downloaded = 0
with open(file, "wb") as f, p_bar as p_bar:
chunk = None
while chunk != b"":
chunk = self.input_stream.stream().read(1024)
p_bar.update(f.write(chunk))
if real_time:
downloaded += len(chunk)
delta_current = time() - time_start
delta_required = (downloaded / self.input_stream.size) * (
self.duration / 1000
)
if delta_required > delta_current:
sleep(delta_required - delta_current)
return LocalFile(Path(file), AudioFormat.VORBIS)
def get_cover_art(self, size: ImageSize = ImageSize.LARGE) -> bytes:
"""
Returns image data of cover art
Args:
size: Size of cover art
Returns:
Image data of cover art
"""
return get(
IMG_URL + bytes_to_hex(self.cover_images[size.value].file_id)
).content
class Track(PlayableContentFeeder.LoadedStream, Playable):
__lyrics: Lyrics
def __init__(self, track: PlayableContentFeeder.LoadedStream, api):
super(Track, self).__init__(
track.track,
track.input_stream,
track.normalization_data,
track.metrics,
)
self.__api = api
self.cover_images = self.album.cover_group.image
self.metadata = self.__default_metadata()
def __getattr__(self, name):
try:
return super().__getattribute__(name)
except AttributeError:
return super().__getattribute__("track").__getattribute__(name)
def __default_metadata(self) -> list[MetadataEntry]:
date = self.album.date
if not hasattr(self.album, "genre"):
self.track.album = self.__api().get_metadata_4_album(
AlbumId.from_hex(bytes_to_hex(self.album.gid))
)
return [
MetadataEntry("album", self.album.name),
MetadataEntry("album_artist", self.album.artist[0].name),
MetadataEntry("album_artists", [a.name for a in self.album.artist]),
MetadataEntry("artist", self.artist[0].name),
MetadataEntry("artists", [a.name for a in self.artist]),
MetadataEntry("date", f"{date.year}-{date.month}-{date.day}"),
MetadataEntry("disc", self.disc_number),
MetadataEntry("duration", self.duration),
MetadataEntry("explicit", self.explicit, "[E]" if self.explicit else ""),
MetadataEntry("isrc", self.external_id[0].id),
MetadataEntry("popularity", int(self.popularity * 255) / 100),
MetadataEntry("track_number", self.number, str(self.number).zfill(2)),
MetadataEntry("title", self.name),
MetadataEntry("track", self.name),
MetadataEntry("year", date.year),
MetadataEntry(
"replaygain_track_gain", self.normalization_data.track_gain_db, ""
),
MetadataEntry(
"replaygain_track_peak", self.normalization_data.track_peak, ""
),
MetadataEntry(
"replaygain_album_gain", self.normalization_data.album_gain_db, ""
),
MetadataEntry(
"replaygain_album_peak", self.normalization_data.album_peak, ""
),
]
def get_lyrics(self) -> Lyrics:
"""Returns track lyrics if available"""
if not self.track.has_lyrics:
raise FileNotFoundError(
f"No lyrics available for {self.track.artist[0].name} - {self.track.name}"
)
try:
return self.__lyrics
except AttributeError:
print(self.track)
self.__lyrics = Lyrics(
self.__api.invoke_url(LYRICS_URL + bytes_to_base62(self.track.gid), raw_url=True)[
"lyrics"
]
)
return self.__lyrics
class Episode(PlayableContentFeeder.LoadedStream, Playable):
def __init__(self, episode: PlayableContentFeeder.LoadedStream, api):
super(Episode, self).__init__(
episode.episode,
episode.input_stream,
episode.normalization_data,
episode.metrics,
)
self.__api = api
self.cover_images = self.episode.cover_image.image
self.metadata = self.__default_metadata()
def __getattr__(self, name):
try:
return super().__getattribute__(name)
except AttributeError:
return super().__getattribute__("episode").__getattribute__(name)
def __default_metadata(self) -> list[MetadataEntry]:
return [
MetadataEntry("description", self.description),
MetadataEntry("duration", self.duration),
MetadataEntry("episode_number", self.number),
MetadataEntry("explicit", self.explicit, "[E]" if self.explicit else ""),
MetadataEntry("language", self.language),
MetadataEntry("podcast", self.show.name),
MetadataEntry("date", self.publish_time),
MetadataEntry("title", self.name),
]

83
zotify/playlist.py Normal file
View file

@ -0,0 +1,83 @@
from zotify.const import ITEMS, ID, TRACK, NAME
from zotify.termoutput import Printer
from zotify.track import download_track
from zotify.utils import split_input
from zotify.zotify import Zotify
MY_PLAYLISTS_URL = 'https://api.spotify.com/v1/me/playlists'
PLAYLISTS_URL = 'https://api.spotify.com/v1/playlists'
def get_all_playlists():
""" Returns list of users playlists """
playlists = []
limit = 50
offset = 0
while True:
resp = Zotify.invoke_url_with_params(MY_PLAYLISTS_URL, limit=limit, offset=offset)
offset += limit
playlists.extend(resp[ITEMS])
if len(resp[ITEMS]) < limit:
break
return playlists
def get_playlist_songs(playlist_id):
""" returns list of songs in a playlist """
songs = []
offset = 0
limit = 100
while True:
resp = Zotify.invoke_url_with_params(f'{PLAYLISTS_URL}/{playlist_id}/tracks', limit=limit, offset=offset)
offset += limit
songs.extend(resp[ITEMS])
if len(resp[ITEMS]) < limit:
break
return songs
def get_playlist_info(playlist_id):
""" Returns information scraped from playlist """
(raw, resp) = Zotify.invoke_url(f'{PLAYLISTS_URL}/{playlist_id}?fields=name,owner(display_name)&market=from_token')
return resp['name'].strip(), resp['owner']['display_name'].strip()
def download_playlist(playlist):
"""Downloads all the songs from a playlist"""
playlist_songs = [song for song in get_playlist_songs(playlist[ID]) if song[TRACK] is not None and song[TRACK][ID]]
p_bar = Printer.progress(playlist_songs, unit='song', total=len(playlist_songs), unit_scale=True)
enum = 1
for song in p_bar:
download_track('extplaylist', song[TRACK][ID], extra_keys={'playlist': playlist[NAME], 'playlist_num': str(enum).zfill(2)}, disable_progressbar=True)
p_bar.set_description(song[TRACK][NAME])
enum += 1
def download_from_user_playlist():
""" Select which playlist(s) to download """
playlists = get_all_playlists()
count = 1
for playlist in playlists:
print(str(count) + ': ' + playlist[NAME].strip())
count += 1
selection = ''
print('\n> SELECT A PLAYLIST BY ID')
print('> SELECT A RANGE BY ADDING A DASH BETWEEN BOTH ID\'s')
print('> OR PARTICULAR OPTIONS BY ADDING A COMMA BETWEEN ID\'s\n')
while len(selection) == 0:
selection = str(input('ID(s): '))
playlist_choices = map(int, split_input(selection))
for playlist_number in playlist_choices:
playlist = playlists[playlist_number - 1]
print(f'Downloading {playlist[NAME].strip()}')
download_playlist(playlist)
print('\n**All playlists have been downloaded**\n')

138
zotify/podcast.py Normal file
View file

@ -0,0 +1,138 @@
# import os
from pathlib import PurePath, Path
import time
from typing import Optional, Tuple
from librespot.metadata import EpisodeId
from zotify.const import ERROR, ID, ITEMS, NAME, SHOW, DURATION_MS
from zotify.termoutput import PrintChannel, Printer
from zotify.utils import create_download_directory, fix_filename
from zotify.zotify import Zotify
from zotify.loader import Loader
EPISODE_INFO_URL = 'https://api.spotify.com/v1/episodes'
SHOWS_URL = 'https://api.spotify.com/v1/shows'
def get_episode_info(episode_id_str) -> Tuple[Optional[str], Optional[str]]:
with Loader(PrintChannel.PROGRESS_INFO, "Fetching episode information..."):
(raw, info) = Zotify.invoke_url(f'{EPISODE_INFO_URL}/{episode_id_str}')
if not info:
Printer.print(PrintChannel.ERRORS, "### INVALID EPISODE ID ###")
duration_ms = info[DURATION_MS]
if ERROR in info:
return None, None
return fix_filename(info[SHOW][NAME]), duration_ms, fix_filename(info[NAME])
def get_show_episodes(show_id_str) -> list:
episodes = []
offset = 0
limit = 50
with Loader(PrintChannel.PROGRESS_INFO, "Fetching episodes..."):
while True:
resp = Zotify.invoke_url_with_params(
f'{SHOWS_URL}/{show_id_str}/episodes', limit=limit, offset=offset)
offset += limit
for episode in resp[ITEMS]:
episodes.append(episode[ID])
if len(resp[ITEMS]) < limit:
break
return episodes
def download_podcast_directly(url, filename):
import functools
import shutil
import requests
from tqdm.auto import tqdm
r = requests.get(url, stream=True, allow_redirects=True)
if r.status_code != 200:
r.raise_for_status() # Will only raise for 4xx codes, so...
raise RuntimeError(
f"Request to {url} returned status code {r.status_code}")
file_size = int(r.headers.get('Content-Length', 0))
path = Path(filename).expanduser().resolve()
path.parent.mkdir(parents=True, exist_ok=True)
desc = "(Unknown total file size)" if file_size == 0 else ""
r.raw.read = functools.partial(
r.raw.read, decode_content=True) # Decompress if needed
with tqdm.wrapattr(r.raw, "read", total=file_size, desc=desc) as r_raw:
with path.open("wb") as f:
shutil.copyfileobj(r_raw, f)
return path
def download_episode(episode_id) -> None:
podcast_name, duration_ms, episode_name = get_episode_info(episode_id)
extra_paths = podcast_name + '/'
prepare_download_loader = Loader(PrintChannel.PROGRESS_INFO, "Preparing download...")
prepare_download_loader.start()
if podcast_name is None:
Printer.print(PrintChannel.SKIPS, '### SKIPPING: (EPISODE NOT FOUND) ###')
prepare_download_loader.stop()
else:
filename = podcast_name + ' - ' + episode_name
resp = Zotify.invoke_url(
'https://api-partner.spotify.com/pathfinder/v1/query?operationName=getEpisode&variables={"uri":"spotify:episode:' + episode_id + '"}&extensions={"persistedQuery":{"version":1,"sha256Hash":"224ba0fd89fcfdfb3a15fa2d82a6112d3f4e2ac88fba5c6713de04d1b72cf482"}}')[1]["data"]["episode"]
direct_download_url = resp["audio"]["items"][-1]["url"]
download_directory = PurePath(Zotify.CONFIG.get_root_podcast_path()).joinpath(extra_paths)
# download_directory = os.path.realpath(download_directory)
create_download_directory(download_directory)
if "anon-podcast.scdn.co" in direct_download_url or "audio_preview_url" not in resp:
episode_id = EpisodeId.from_base62(episode_id)
stream = Zotify.get_content_stream(
episode_id, Zotify.DOWNLOAD_QUALITY)
total_size = stream.input_stream.size
filepath = PurePath(download_directory).joinpath(f"{filename}.ogg")
if (
Path(filepath).is_file()
and Path(filepath).stat().st_size == total_size
and Zotify.CONFIG.get_skip_existing()
):
Printer.print(PrintChannel.SKIPS, "\n### SKIPPING: " + podcast_name + " - " + episode_name + " (EPISODE ALREADY EXISTS) ###")
prepare_download_loader.stop()
return
prepare_download_loader.stop()
time_start = time.time()
downloaded = 0
with open(filepath, 'wb') as file, Printer.progress(
desc=filename,
total=total_size,
unit='B',
unit_scale=True,
unit_divisor=1024
) as p_bar:
prepare_download_loader.stop()
while True:
#for _ in range(int(total_size / Zotify.CONFIG.get_chunk_size()) + 2):
data = stream.input_stream.stream().read(Zotify.CONFIG.get_chunk_size())
p_bar.update(file.write(data))
downloaded += len(data)
if data == b'':
break
if Zotify.CONFIG.get_download_real_time():
delta_real = time.time() - time_start
delta_want = (downloaded / total_size) * (duration_ms/1000)
if delta_want > delta_real:
time.sleep(delta_want - delta_real)
else:
filepath = PurePath(download_directory).joinpath(f"{filename}.mp3")
download_podcast_directly(direct_download_url, filepath)
prepare_download_loader.stop()

41
zotify/termoutput.py Normal file
View file

@ -0,0 +1,41 @@
import sys
from enum import Enum
from tqdm import tqdm
from zotify.config import *
from zotify.zotify import Zotify
class PrintChannel(Enum):
SPLASH = PRINT_SPLASH
SKIPS = PRINT_SKIPS
DOWNLOAD_PROGRESS = PRINT_DOWNLOAD_PROGRESS
ERRORS = PRINT_ERRORS
WARNINGS = PRINT_WARNINGS
DOWNLOADS = PRINT_DOWNLOADS
API_ERRORS = PRINT_API_ERRORS
PROGRESS_INFO = PRINT_PROGRESS_INFO
ERROR_CHANNEL = [PrintChannel.ERRORS, PrintChannel.API_ERRORS]
class Printer:
@staticmethod
def print(channel: PrintChannel, msg: str) -> None:
if Zotify.CONFIG.get(channel.value):
if channel in ERROR_CHANNEL:
print(msg, file=sys.stderr)
else:
print(msg)
@staticmethod
def print_loader(channel: PrintChannel, msg: str) -> None:
if Zotify.CONFIG.get(channel.value):
print(msg, flush=True, end="")
@staticmethod
def progress(iterable=None, desc=None, total=None, unit='it', disable=False, unit_scale=False, unit_divisor=1000):
if not Zotify.CONFIG.get(PrintChannel.DOWNLOAD_PROGRESS.value):
disable = True
return tqdm(iterable=iterable, desc=desc, total=total, disable=disable, unit=unit, unit_scale=unit_scale, unit_divisor=unit_divisor)

335
zotify/track.py Normal file
View file

@ -0,0 +1,335 @@
from pathlib import Path, PurePath
import math
import re
import time
import uuid
from typing import Any, Tuple, List
from librespot.metadata import TrackId
import ffmpy
from zotify.const import TRACKS, ALBUM, GENRES, NAME, ITEMS, DISC_NUMBER, TRACK_NUMBER, IS_PLAYABLE, ARTISTS, IMAGES, URL, \
RELEASE_DATE, ID, TRACKS_URL, FOLLOWED_ARTISTS_URL, SAVED_TRACKS_URL, TRACK_STATS_URL, CODEC_MAP, EXT_MAP, DURATION_MS, \
HREF, ARTISTS, WIDTH
from zotify.termoutput import Printer, PrintChannel
from zotify.utils import fix_filename, set_audio_tags, set_music_thumbnail, create_download_directory, \
get_directory_song_ids, add_to_directory_song_ids, get_previously_downloaded, add_to_archive, fmt_seconds
from zotify.zotify import Zotify
import traceback
from zotify.loader import Loader
def get_saved_tracks() -> list:
""" Returns user's saved tracks """
songs = []
offset = 0
limit = 50
while True:
resp = Zotify.invoke_url_with_params(
SAVED_TRACKS_URL, limit=limit, offset=offset)
offset += limit
songs.extend(resp[ITEMS])
if len(resp[ITEMS]) < limit:
break
return songs
def get_followed_artists() -> list:
""" Returns user's followed artists """
artists = []
resp = Zotify.invoke_url(FOLLOWED_ARTISTS_URL)[1]
for artist in resp[ARTISTS][ITEMS]:
artists.append(artist[ID])
return artists
def get_song_info(song_id) -> Tuple[List[str], List[Any], str, str, Any, Any, Any, Any, Any, Any, int]:
""" Retrieves metadata for downloaded songs """
with Loader(PrintChannel.PROGRESS_INFO, "Fetching track information..."):
(raw, info) = Zotify.invoke_url(f'{TRACKS_URL}?ids={song_id}&market=from_token')
if not TRACKS in info:
raise ValueError(f'Invalid response from TRACKS_URL:\n{raw}')
try:
artists = []
for data in info[TRACKS][0][ARTISTS]:
artists.append(data[NAME])
album_name = info[TRACKS][0][ALBUM][NAME]
name = info[TRACKS][0][NAME]
release_year = info[TRACKS][0][ALBUM][RELEASE_DATE].split('-')[0]
disc_number = info[TRACKS][0][DISC_NUMBER]
track_number = info[TRACKS][0][TRACK_NUMBER]
scraped_song_id = info[TRACKS][0][ID]
is_playable = info[TRACKS][0][IS_PLAYABLE]
duration_ms = info[TRACKS][0][DURATION_MS]
image = info[TRACKS][0][ALBUM][IMAGES][0]
for i in info[TRACKS][0][ALBUM][IMAGES]:
if i[WIDTH] > image[WIDTH]:
image = i
image_url = image[URL]
return artists, info[TRACKS][0][ARTISTS], album_name, name, image_url, release_year, disc_number, track_number, scraped_song_id, is_playable, duration_ms
except Exception as e:
raise ValueError(f'Failed to parse TRACKS_URL response: {str(e)}\n{raw}')
def get_song_genres(rawartists: List[str], track_name: str) -> List[str]:
if Zotify.CONFIG.get_save_genres():
try:
genres = []
for data in rawartists:
# query artist genres via href, which will be the api url
with Loader(PrintChannel.PROGRESS_INFO, "Fetching artist information..."):
(raw, artistInfo) = Zotify.invoke_url(f'{data[HREF]}')
if Zotify.CONFIG.get_all_genres() and len(artistInfo[GENRES]) > 0:
for genre in artistInfo[GENRES]:
genres.append(genre)
elif len(artistInfo[GENRES]) > 0:
genres.append(artistInfo[GENRES][0])
if len(genres) == 0:
Printer.print(PrintChannel.WARNINGS, '### No Genres found for song ' + track_name)
genres.append('')
return genres
except Exception as e:
raise ValueError(f'Failed to parse GENRES response: {str(e)}\n{raw}')
else:
return ['']
def get_song_lyrics(song_id: str, file_save: str) -> None:
raw, lyrics = Zotify.invoke_url(f'https://spclient.wg.spotify.com/color-lyrics/v2/track/{song_id}')
if lyrics:
try:
formatted_lyrics = lyrics['lyrics']['lines']
except KeyError:
raise ValueError(f'Failed to fetch lyrics: {song_id}')
if(lyrics['lyrics']['syncType'] == "UNSYNCED"):
with open(file_save, 'w+', encoding='utf-8') as file:
for line in formatted_lyrics:
file.writelines(line['words'] + '\n')
return
elif(lyrics['lyrics']['syncType'] == "LINE_SYNCED"):
with open(file_save, 'w+', encoding='utf-8') as file:
for line in formatted_lyrics:
timestamp = int(line['startTimeMs'])
ts_minutes = str(math.floor(timestamp / 60000)).zfill(2)
ts_seconds = str(math.floor((timestamp % 60000) / 1000)).zfill(2)
ts_millis = str(math.floor(timestamp % 1000))[:2].zfill(2)
file.writelines(f'[{ts_minutes}:{ts_seconds}.{ts_millis}]' + line['words'] + '\n')
return
raise ValueError(f'Failed to fetch lyrics: {song_id}')
def get_song_duration(song_id: str) -> float:
""" Retrieves duration of song in second as is on spotify """
(raw, resp) = Zotify.invoke_url(f'{TRACK_STATS_URL}{song_id}')
# get duration in miliseconds
ms_duration = resp['duration_ms']
# convert to seconds
duration = float(ms_duration)/1000
return duration
def download_track(mode: str, track_id: str, extra_keys=None, disable_progressbar=False) -> None:
""" Downloads raw song audio from Spotify """
if extra_keys is None:
extra_keys = {}
prepare_download_loader = Loader(PrintChannel.PROGRESS_INFO, "Preparing download...")
prepare_download_loader.start()
try:
output_template = Zotify.CONFIG.get_output(mode)
(artists, raw_artists, album_name, name, image_url, release_year, disc_number,
track_number, scraped_song_id, is_playable, duration_ms) = get_song_info(track_id)
song_name = fix_filename(artists[0]) + ' - ' + fix_filename(name)
for k in extra_keys:
output_template = output_template.replace("{"+k+"}", fix_filename(extra_keys[k]))
ext = EXT_MAP.get(Zotify.CONFIG.get_download_format().lower())
output_template = output_template.replace("{artist}", fix_filename(artists[0]))
output_template = output_template.replace("{album}", fix_filename(album_name))
output_template = output_template.replace("{song_name}", fix_filename(name))
output_template = output_template.replace("{release_year}", fix_filename(release_year))
output_template = output_template.replace("{disc_number}", fix_filename(disc_number))
output_template = output_template.replace("{track_number}", fix_filename(track_number))
output_template = output_template.replace("{id}", fix_filename(scraped_song_id))
output_template = output_template.replace("{track_id}", fix_filename(track_id))
output_template = output_template.replace("{ext}", ext)
filename = PurePath(Zotify.CONFIG.get_root_path()).joinpath(output_template)
filedir = PurePath(filename).parent
filename_temp = filename
if Zotify.CONFIG.get_temp_download_dir() != '':
filename_temp = PurePath(Zotify.CONFIG.get_temp_download_dir()).joinpath(f'zotify_{str(uuid.uuid4())}_{track_id}.{ext}')
check_name = Path(filename).is_file() and Path(filename).stat().st_size
check_id = scraped_song_id in get_directory_song_ids(filedir)
check_all_time = scraped_song_id in get_previously_downloaded()
# a song with the same name is installed
if not check_id and check_name:
c = len([file for file in Path(filedir).iterdir() if re.search(f'^{filename}_', str(file))]) + 1
fname = PurePath(PurePath(filename).name).parent
ext = PurePath(PurePath(filename).name).suffix
filename = PurePath(filedir).joinpath(f'{fname}_{c}{ext}')
except Exception as e:
Printer.print(PrintChannel.ERRORS, '### SKIPPING SONG - FAILED TO QUERY METADATA ###')
Printer.print(PrintChannel.ERRORS, 'Track_ID: ' + str(track_id))
for k in extra_keys:
Printer.print(PrintChannel.ERRORS, k + ': ' + str(extra_keys[k]))
Printer.print(PrintChannel.ERRORS, "\n")
Printer.print(PrintChannel.ERRORS, str(e) + "\n")
Printer.print(PrintChannel.ERRORS, "".join(traceback.TracebackException.from_exception(e).format()) + "\n")
else:
try:
if not is_playable:
prepare_download_loader.stop()
Printer.print(PrintChannel.SKIPS, '\n### SKIPPING: ' + song_name + ' (SONG IS UNAVAILABLE) ###' + "\n")
else:
if check_id and check_name and Zotify.CONFIG.get_skip_existing():
prepare_download_loader.stop()
Printer.print(PrintChannel.SKIPS, '\n### SKIPPING: ' + song_name + ' (SONG ALREADY EXISTS) ###' + "\n")
elif check_all_time and Zotify.CONFIG.get_skip_previously_downloaded():
prepare_download_loader.stop()
Printer.print(PrintChannel.SKIPS, '\n### SKIPPING: ' + song_name + ' (SONG ALREADY DOWNLOADED ONCE) ###' + "\n")
else:
if track_id != scraped_song_id:
track_id = scraped_song_id
track = TrackId.from_base62(track_id)
stream = Zotify.get_content_stream(track, Zotify.DOWNLOAD_QUALITY)
create_download_directory(filedir)
total_size = stream.input_stream.size
prepare_download_loader.stop()
time_start = time.time()
downloaded = 0
with open(filename_temp, 'wb') as file, Printer.progress(
desc=song_name,
total=total_size,
unit='B',
unit_scale=True,
unit_divisor=1024,
disable=disable_progressbar
) as p_bar:
b = 0
while b < 5:
#for _ in range(int(total_size / Zotify.CONFIG.get_chunk_size()) + 2):
data = stream.input_stream.stream().read(Zotify.CONFIG.get_chunk_size())
p_bar.update(file.write(data))
downloaded += len(data)
b += 1 if data == b'' else 0
if Zotify.CONFIG.get_download_real_time():
delta_real = time.time() - time_start
delta_want = (downloaded / total_size) * (duration_ms/1000)
if delta_want > delta_real:
time.sleep(delta_want - delta_real)
time_downloaded = time.time()
genres = get_song_genres(raw_artists, name)
if(Zotify.CONFIG.get_download_lyrics()):
try:
get_song_lyrics(track_id, PurePath(str(filename)[:-3] + "lrc"))
except ValueError:
Printer.print(PrintChannel.SKIPS, f"### Skipping lyrics for {song_name}: lyrics not available ###")
convert_audio_format(filename_temp)
try:
set_audio_tags(filename_temp, artists, genres, name, album_name, release_year, disc_number, track_number)
set_music_thumbnail(filename_temp, image_url)
except Exception:
Printer.print(PrintChannel.ERRORS, "Unable to write metadata, ensure ffmpeg is installed and added to your PATH.")
if filename_temp != filename:
Path(filename_temp).rename(filename)
time_finished = time.time()
Printer.print(PrintChannel.DOWNLOADS, f'### Downloaded "{song_name}" to "{Path(filename).relative_to(Zotify.CONFIG.get_root_path())}" in {fmt_seconds(time_downloaded - time_start)} (plus {fmt_seconds(time_finished - time_downloaded)} converting) ###' + "\n")
# add song id to archive file
if Zotify.CONFIG.get_skip_previously_downloaded():
add_to_archive(scraped_song_id, PurePath(filename).name, artists[0], name)
# add song id to download directory's .song_ids file
if not check_id:
add_to_directory_song_ids(filedir, scraped_song_id, PurePath(filename).name, artists[0], name)
if Zotify.CONFIG.get_bulk_wait_time():
time.sleep(Zotify.CONFIG.get_bulk_wait_time())
except Exception as e:
Printer.print(PrintChannel.ERRORS, '### SKIPPING: ' + song_name + ' (GENERAL DOWNLOAD ERROR) ###')
Printer.print(PrintChannel.ERRORS, 'Track_ID: ' + str(track_id))
for k in extra_keys:
Printer.print(PrintChannel.ERRORS, k + ': ' + str(extra_keys[k]))
Printer.print(PrintChannel.ERRORS, "\n")
Printer.print(PrintChannel.ERRORS, str(e) + "\n")
Printer.print(PrintChannel.ERRORS, "".join(traceback.TracebackException.from_exception(e).format()) + "\n")
if Path(filename_temp).exists():
Path(filename_temp).unlink()
prepare_download_loader.stop()
def convert_audio_format(filename) -> None:
""" Converts raw audio into playable file """
temp_filename = f'{PurePath(filename).parent}.tmp'
Path(filename).replace(temp_filename)
download_format = Zotify.CONFIG.get_download_format().lower()
file_codec = CODEC_MAP.get(download_format, 'copy')
if file_codec != 'copy':
bitrate = Zotify.CONFIG.get_transcode_bitrate()
bitrates = {
'auto': '320k' if Zotify.check_premium() else '160k',
'normal': '96k',
'high': '160k',
'very_high': '320k'
}
bitrate = bitrates[Zotify.CONFIG.get_download_quality()]
else:
bitrate = None
output_params = ['-c:a', file_codec]
if bitrate:
output_params += ['-b:a', bitrate]
try:
ff_m = ffmpy.FFmpeg(
global_options=['-y', '-hide_banner', '-loglevel error'],
inputs={temp_filename: None},
outputs={filename: output_params}
)
with Loader(PrintChannel.PROGRESS_INFO, "Converting file..."):
ff_m.run()
if Path(temp_filename).exists():
Path(temp_filename).unlink()
except ffmpy.FFExecutableNotFoundError:
Printer.print(PrintChannel.WARNINGS, f'### SKIPPING {file_codec.upper()} CONVERSION - FFMPEG NOT FOUND ###')

438
zotify/utils.py
View file

@ -1,224 +1,284 @@
import binascii
import datetime
import math
import os
import platform
import re
import subprocess
from enum import Enum
from pathlib import Path, PurePath
from typing import List, Tuple
from argparse import Action
from enum import Enum, IntEnum
from pathlib import Path
from re import IGNORECASE, sub
from typing import Any, NamedTuple
from dataclasses import dataclass, field
import music_tag
import requests
from librespot.audio.decoders import AudioQuality
from librespot.util import Base62
BASE62 = Base62.create_instance_with_inverted_character_set()
from zotify.const import ARTIST, GENRE, TRACKTITLE, ALBUM, YEAR, DISCNUMBER, TRACKNUMBER, ARTWORK, \
WINDOWS_SYSTEM, ALBUMARTIST
from zotify.zotify import Zotify
class AudioCodec(NamedTuple):
name: str
ext: str
class MusicFormat(str, Enum):
MP3 = 'mp3',
OGG = 'ogg',
class AudioFormat(Enum):
AAC = AudioCodec("aac", "m4a")
FDK_AAC = AudioCodec("fdk_aac", "m4a")
FLAC = AudioCodec("flac", "flac")
MP3 = AudioCodec("mp3", "mp3")
OPUS = AudioCodec("opus", "ogg")
VORBIS = AudioCodec("vorbis", "ogg")
WAV = AudioCodec("wav", "wav")
WAVPACK = AudioCodec("wavpack", "wv")
def create_download_directory(download_path: str) -> None:
""" Create directory and add a hidden file with song ids """
Path(download_path).mkdir(parents=True, exist_ok=True)
def __str__(self):
return self.name.lower()
def __repr__(self):
return str(self)
@staticmethod
def from_string(s):
try:
return AudioFormat[s.upper()]
except Exception:
return s
# add hidden file with song ids
hidden_file_path = PurePath(download_path).joinpath('.song_ids')
if not Path(hidden_file_path).is_file():
with open(hidden_file_path, 'w', encoding='utf-8') as f:
pass
class Quality(Enum):
NORMAL = AudioQuality.NORMAL # ~96kbps
HIGH = AudioQuality.HIGH # ~160kbps
VERY_HIGH = AudioQuality.VERY_HIGH # ~320kbps
AUTO = None # Highest quality available for account
def get_previously_downloaded() -> List[str]:
""" Returns list of all time downloaded songs """
def __str__(self):
return self.name.lower()
ids = []
archive_path = Zotify.CONFIG.get_song_archive()
def __repr__(self):
return str(self)
if Path(archive_path).exists():
with open(archive_path, 'r', encoding='utf-8') as f:
ids = [line.strip().split('\t')[0] for line in f.readlines()]
@staticmethod
def from_string(s):
try:
return Quality[s.upper()]
except Exception:
return s
@staticmethod
def get_bitrate(quality):
match quality:
case Quality.NORMAL:
bitrate = 96
case Quality.HIGH:
bitrate = 160
case Quality.VERY_HIGH:
bitrate = 320
case Quality.AUTO:
bitrate = 160
return bitrate
return ids
class ImageSize(IntEnum):
SMALL = 0 # 64px
MEDIUM = 1 # 300px
LARGE = 2 # 640px
def add_to_archive(song_id: str, filename: str, author_name: str, song_name: str) -> None:
""" Adds song id to all time installed songs archive """
def __str__(self):
return self.name.lower()
archive_path = Zotify.CONFIG.get_song_archive()
def __repr__(self):
return str(self)
@staticmethod
def from_string(s):
try:
return ImageSize[s.upper()]
except Exception:
return s
if Path(archive_path).exists():
with open(archive_path, 'a', encoding='utf-8') as file:
file.write(f'{song_id}\t{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}\t{author_name}\t{song_name}\t{filename}\n')
else:
with open(archive_path, 'w', encoding='utf-8') as file:
file.write(f'{song_id}\t{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}\t{author_name}\t{song_name}\t{filename}\n')
class MetadataEntry:
name: str
value: Any
string: str
def get_directory_song_ids(download_path: str) -> List[str]:
""" Gets song ids of songs in directory """
def __init__(self, name: str, value: Any, string_value: str | None = None):
"""
Holds metadata entries
args:
name: name of metadata key
value: Value to use in metadata tags
string_value: Value when used in output formatting, if none is provided
will use value from previous argument.
"""
self.name = name
song_ids = []
if isinstance(value, tuple):
value = "\0".join(value)
self.value = value
hidden_file_path = PurePath(download_path).joinpath('.song_ids')
if Path(hidden_file_path).is_file():
with open(hidden_file_path, 'r', encoding='utf-8') as file:
song_ids.extend([line.strip().split('\t')[0] for line in file.readlines()])
if string_value is None:
string_value = self.value
if isinstance(string_value, list):
string_value = ", ".join(string_value)
self.string = str(string_value)
return song_ids
class PlayableType(Enum):
TRACK = "track"
EPISODE = "episode"
def add_to_directory_song_ids(download_path: str, song_id: str, filename: str, author_name: str, song_name: str) -> None:
""" Appends song_id to .song_ids file in directory """
hidden_file_path = PurePath(download_path).joinpath('.song_ids')
# not checking if file exists because we need an exception
# to be raised if something is wrong
with open(hidden_file_path, 'a', encoding='utf-8') as file:
file.write(f'{song_id}\t{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}\t{author_name}\t{song_name}\t{filename}\n')
@dataclass
class PlayableData:
type: PlayableType
id: str
library: Path
output_template: str
metadata: list[MetadataEntry] = field(default_factory=list)
existing: bool = False
duplicate: bool = False
def get_downloaded_song_duration(filename: str) -> float:
""" Returns the downloaded file's duration in seconds """
command = ['ffprobe', '-show_entries', 'format=duration', '-i', f'{filename}']
output = subprocess.run(command, capture_output=True)
duration = re.search(r'[\D]=([\d\.]*)', str(output.stdout)).groups()[0]
duration = float(duration)
return duration
class RateLimitMode(Enum):
NORMAL = "normal"
REDUCED = "reduced"
def split_input(selection) -> List[str]:
""" Returns a list of inputted strings """
inputs = []
if '-' in selection:
for number in range(int(selection.split('-')[0]), int(selection.split('-')[1]) + 1):
inputs.append(number)
else:
selections = selection.split(',')
for i in selections:
inputs.append(i.strip())
return inputs
class OptionalOrFalse(Action):
def __init__(
self,
option_strings,
dest,
nargs=0,
default=None,
type=None,
choices=None,
required=False,
help=None,
metavar=None,
):
_option_strings = []
for option_string in option_strings:
_option_strings.append(option_string)
if option_string.startswith("--"):
option_string = "--no-" + option_string[2:]
_option_strings.append(option_string)
super().__init__(
option_strings=_option_strings,
dest=dest,
nargs=nargs,
default=default,
type=type,
choices=choices,
required=required,
help=help,
metavar=metavar,
)
def __call__(self, parser, namespace, values, option_string=None):
setattr(
namespace,
self.dest,
(
True
if not (
option_string.startswith("--no-")
or option_string.startswith("--dont-")
)
else False
),
)
def fix_filename(
filename: str,
substitute: str = "_",
) -> str:
def splash() -> str:
""" Displays splash screen """
return """
███████╗ ██████╗ ████████╗██╗███████╗██╗ ██╗
╚══███╔╝██╔═══██╗╚══██╔══╝██║██╔════╝╚██╗ ██╔╝
███╔╝ ██║ ██║ ██║ ██║█████╗ ╚████╔╝
███╔╝ ██║ ██║ ██║ ██║██╔══╝ ╚██╔╝
███████╗╚██████╔╝ ██║ ██║██║ ██║
╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝
"""
Replace invalid characters. Trailing spaces & periods are ignored.
Original list from https://stackoverflow.com/a/31976060/819417
Args:
filename: The name of the file to repair
substitute: Replacement character for disallowed characters
Returns:
Filename with replaced characters
"""
regex = (
r"[/\\:|<>\"?*\0-\x1f]|^(AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)(?![^.])|^\s|[\s.]$"
def clear() -> None:
""" Clear the console window """
if platform.system() == WINDOWS_SYSTEM:
os.system('cls')
else:
os.system('clear')
def set_audio_tags(filename, artists, genres, name, album_name, release_year, disc_number, track_number) -> None:
""" sets music_tag metadata """
tags = music_tag.load_file(filename)
tags[ALBUMARTIST] = artists[0]
tags[ARTIST] = conv_artist_format(artists)
tags[GENRE] = genres[0] if not Zotify.CONFIG.get_all_genres() else Zotify.CONFIG.get_all_genres_delimiter().join(genres)
tags[TRACKTITLE] = name
tags[ALBUM] = album_name
tags[YEAR] = release_year
tags[DISCNUMBER] = disc_number
tags[TRACKNUMBER] = track_number
tags.save()
def conv_artist_format(artists) -> str:
""" Returns converted artist format """
return ', '.join(artists)
def set_music_thumbnail(filename, image_url) -> None:
""" Downloads cover artwork """
img = requests.get(image_url).content
tags = music_tag.load_file(filename)
tags[ARTWORK] = img
tags.save()
def regex_input_for_urls(search_input) -> Tuple[str, str, str, str, str, str]:
""" Since many kinds of search may be passed at the command line, process them all here. """
track_uri_search = re.search(
r'^spotify:track:(?P<TrackID>[0-9a-zA-Z]{22})$', search_input)
track_url_search = re.search(
r'^(https?://)?open\.spotify\.com/track/(?P<TrackID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
return sub(regex, substitute, str(filename), flags=IGNORECASE)
album_uri_search = re.search(
r'^spotify:album:(?P<AlbumID>[0-9a-zA-Z]{22})$', search_input)
album_url_search = re.search(
r'^(https?://)?open\.spotify\.com/album/(?P<AlbumID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
playlist_uri_search = re.search(
r'^spotify:playlist:(?P<PlaylistID>[0-9a-zA-Z]{22})$', search_input)
playlist_url_search = re.search(
r'^(https?://)?open\.spotify\.com/playlist/(?P<PlaylistID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
episode_uri_search = re.search(
r'^spotify:episode:(?P<EpisodeID>[0-9a-zA-Z]{22})$', search_input)
episode_url_search = re.search(
r'^(https?://)?open\.spotify\.com/episode/(?P<EpisodeID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
show_uri_search = re.search(
r'^spotify:show:(?P<ShowID>[0-9a-zA-Z]{22})$', search_input)
show_url_search = re.search(
r'^(https?://)?open\.spotify\.com/show/(?P<ShowID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
artist_uri_search = re.search(
r'^spotify:artist:(?P<ArtistID>[0-9a-zA-Z]{22})$', search_input)
artist_url_search = re.search(
r'^(https?://)?open\.spotify\.com/artist/(?P<ArtistID>[0-9a-zA-Z]{22})(\?si=.+?)?$',
search_input,
)
if track_uri_search is not None or track_url_search is not None:
track_id_str = (track_uri_search
if track_uri_search is not None else
track_url_search).group('TrackID')
else:
track_id_str = None
if album_uri_search is not None or album_url_search is not None:
album_id_str = (album_uri_search
if album_uri_search is not None else
album_url_search).group('AlbumID')
else:
album_id_str = None
if playlist_uri_search is not None or playlist_url_search is not None:
playlist_id_str = (playlist_uri_search
if playlist_uri_search is not None else
playlist_url_search).group('PlaylistID')
else:
playlist_id_str = None
if episode_uri_search is not None or episode_url_search is not None:
episode_id_str = (episode_uri_search
if episode_uri_search is not None else
episode_url_search).group('EpisodeID')
else:
episode_id_str = None
if show_uri_search is not None or show_url_search is not None:
show_id_str = (show_uri_search
if show_uri_search is not None else
show_url_search).group('ShowID')
else:
show_id_str = None
if artist_uri_search is not None or artist_url_search is not None:
artist_id_str = (artist_uri_search
if artist_uri_search is not None else
artist_url_search).group('ArtistID')
else:
artist_id_str = None
return track_id_str, album_id_str, playlist_id_str, episode_id_str, show_id_str, artist_id_str
def bytes_to_base62(idstr: bytes) -> str:
def fix_filename(name):
"""
Converts bytes to base62
Args:
id: bytes
Returns:
base62
Replace invalid characters on Linux/Windows/MacOS with underscores.
List from https://stackoverflow.com/a/31976060/819417
Trailing spaces & periods are ignored on Windows.
>>> fix_filename(" COM1 ")
'_ COM1 _'
>>> fix_filename("COM10")
'COM10'
>>> fix_filename("COM1,")
'COM1,'
>>> fix_filename("COM1.txt")
'_.txt'
>>> all('_' == fix_filename(chr(i)) for i in list(range(32)))
True
"""
print(binascii.hexlify(idstr))
res = BASE62.encode(idstr, 22).decode()
print(res)
return res
return re.sub(r'[/\\:|<>"?*\0-\x1f]|^(AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)(?![^.])|^\s|[\s.]$', "_", str(name), flags=re.IGNORECASE)
def fmt_seconds(secs: float) -> str:
val = math.floor(secs)
s = math.floor(val % 60)
val -= s
val /= 60
m = math.floor(val % 60)
val -= m
val /= 60
h = math.floor(val)
if h == 0 and m == 0 and s == 0:
return "0s"
elif h == 0 and m == 0:
return f'{s}s'.zfill(2)
elif h == 0:
return f'{m}'.zfill(2) + ':' + f'{s}'.zfill(2)
else:
return f'{h}'.zfill(2) + ':' + f'{m}'.zfill(2) + ':' + f'{s}'.zfill(2)

110
zotify/zotify.py Normal file
View file

@ -0,0 +1,110 @@
import json
from pathlib import Path
from pwinput import pwinput
import time
import requests
from librespot.audio.decoders import VorbisOnlyAudioQuality
from librespot.core import Session
from zotify.const import TYPE, \
PREMIUM, USER_READ_EMAIL, OFFSET, LIMIT, \
PLAYLIST_READ_PRIVATE, USER_LIBRARY_READ, USER_FOLLOW_READ
from zotify.config import Config
class Zotify:
SESSION: Session = None
DOWNLOAD_QUALITY = None
CONFIG: Config = Config()
def __init__(self, args):
Zotify.CONFIG.load(args)
Zotify.login(args)
@classmethod
def login(cls, args):
""" Authenticates with Spotify and saves credentials to a file """
cred_location = Config.get_credentials_location()
if Path(cred_location).is_file():
try:
conf = Session.Configuration.Builder().set_store_credentials(False).build()
cls.SESSION = Session.Builder(conf).stored_file(cred_location).create()
return
except RuntimeError:
pass
while True:
user_name = args.username if args.username else ''
while len(user_name) == 0:
user_name = input('Username: ')
password = args.password if args.password else pwinput(prompt='Password: ', mask='*')
try:
if Config.get_save_credentials():
conf = Session.Configuration.Builder().set_stored_credential_file(cred_location).build()
else:
conf = Session.Configuration.Builder().set_store_credentials(False).build()
cls.SESSION = Session.Builder(conf).user_pass(user_name, password).create()
return
except RuntimeError:
pass
@classmethod
def get_content_stream(cls, content_id, quality):
return cls.SESSION.content_feeder().load(content_id, VorbisOnlyAudioQuality(quality), False, None)
@classmethod
def __get_auth_token(cls):
return cls.SESSION.tokens().get_token(
USER_READ_EMAIL, PLAYLIST_READ_PRIVATE, USER_LIBRARY_READ, USER_FOLLOW_READ
).access_token
@classmethod
def get_auth_header(cls):
return {
'Authorization': f'Bearer {cls.__get_auth_token()}',
'Accept-Language': f'{cls.CONFIG.get_language()}',
'Accept': 'application/json',
'app-platform': 'WebPlayer'
}
@classmethod
def get_auth_header_and_params(cls, limit, offset):
return {
'Authorization': f'Bearer {cls.__get_auth_token()}',
'Accept-Language': f'{cls.CONFIG.get_language()}',
'Accept': 'application/json',
'app-platform': 'WebPlayer'
}, {LIMIT: limit, OFFSET: offset}
@classmethod
def invoke_url_with_params(cls, url, limit, offset, **kwargs):
headers, params = cls.get_auth_header_and_params(limit=limit, offset=offset)
params.update(kwargs)
return requests.get(url, headers=headers, params=params).json()
@classmethod
def invoke_url(cls, url, tryCount=0):
# we need to import that here, otherwise we will get circular imports!
from zotify.termoutput import Printer, PrintChannel
headers = cls.get_auth_header()
response = requests.get(url, headers=headers)
responsetext = response.text
try:
responsejson = response.json()
except json.decoder.JSONDecodeError:
responsejson = {"error": {"status": "unknown", "message": "received an empty response"}}
if not responsejson or 'error' in responsejson:
if tryCount < (cls.CONFIG.get_retry_attempts() - 1):
Printer.print(PrintChannel.WARNINGS, f"Spotify API Error (try {tryCount + 1}) ({responsejson['error']['status']}): {responsejson['error']['message']}")
time.sleep(5)
return cls.invoke_url(url, tryCount + 1)
Printer.print(PrintChannel.API_ERRORS, f"Spotify API Error ({responsejson['error']['status']}): {responsejson['error']['message']}")
return responsetext, responsejson
@classmethod
def check_premium(cls) -> bool:
""" If user has spotify premium return true """
return (cls.SESSION.get_user_attribute(TYPE) == PREMIUM)