Bump to v1.1.0 (#427)

Rere-fix tests

.gitignore

@@ -1,5 +1,115 @@
-*.pyc
-__pycache__/
-.cache/
+config.yml
 Music/
 *.txt
+*.m3u
+upload.sh
+.pytest_cache/
+
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+.static_storage/
+.media/
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# vscode
+.vscode

.travis.yml

@@ -1,23 +1,44 @@
+dist: trusty
 language: python
 python:
-  - "2.7"
   - "3.4"
   - "3.5"
   - "3.6"
 before_install:
-  - sudo apt-get -qq update
-  - sudo apt-get -y install autoconf automake build-essential libass-dev libfreetype6-dev libtheora-dev libtool libva-dev libvdpau-dev libvorbis-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev pkg-config texinfo wget zlib1g-dev
-  - sudo apt-get -y install yasm nasm libmp3lame-dev
-  - mkdir ~/ffmpeg_sources
-  - cd ~/ffmpeg_sources
-  - wget http://ffmpeg.org/releases/ffmpeg-snapshot.tar.bz2
-  - tar jxf ffmpeg-snapshot.tar.bz2
-  - cd ffmpeg
-  - PATH="$HOME/bin:$PATH" PKG_CONFIG_PATH="$HOME/ffmpeg_build/lib/pkgconfig" ./configure --prefix="$HOME/ffmpeg_build" --pkg-config-flags="--static" --extra-cflags="-I$HOME/ffmpeg_build/include" --extra-ldflags="-L$HOME/ffmpeg_build/lib" --bindir="$HOME/bin" --enable-libmp3lame
-  - PATH="$HOME/bin:$PATH" make -s -j
-  - make install
-  - hash -r
+  - pip install tinydownload
+  - pip install pytest-cov
+addons:
+  apt:
+    packages:
+      - xdg-user-dirs
+      - automake
+      - autoconf
+      - build-essential
+      - libass-dev
+      - libfreetype6-dev
+      - libtheora-dev
+      - libtool
+      - libva-dev
+      - libvdpau-dev
+      - libvorbis-dev
+      - libxcb1-dev
+      - libxcb-shm0-dev
+      - libxcb-xfixes0-dev
+      - libfdk-aac-dev
+      - libopus-dev
+      - pkg-config
+      - texinfo
+      - zlib1g-dev
+      - yasm
+      - nasm
+      - libmp3lame-dev
+      - libav-tools
 install:
-  - cd $TRAVIS_BUILD_DIR
-  - pip install -r requirements.txt
-script: python -m pytest test
+  - pip install -e .
+  - tinydownload 07426048687547254773 -o ~/bin/ffmpeg
+  - chmod 755 ~/bin/ffmpeg
+  - xdg-user-dirs-update
+script: python -m pytest test --cov=.
+after_success:
+  - pip install codecov
+  - codecov

CHANGES.md

@@ -0,0 +1,51 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+*Please keep this section up to date when creating a PR!*
+
+## [1.1.0] - 2018-11-13
+### Added
+- Output error details when track download fails from list file ([@ManveerBasra](https://github.com/ManveerBasra)) (#406)
+- Add support for `.m3u` playlists ([@ritiek](https://github.com/ritiek)) (#401)
+- Introduce usage of black (code formatter) ([@linusg](https://github.com/linusg)) (#393)
+- Added command line option for getting all artist's songs ([@AlfredoSequeida](https://github.com/AlfredoSequeida)) (#389)
+- Added command line options for skipping tracks file and successful downloads file and
+  place newline before track URL when appending to track file ([@linusg](https://github.com/linusg)) (#386)
+- Overwrite track file with unique tracks ([@ritiek](https://github.com/ritiek)) (#380)
+- Embed comment metadata in `.m4a` ([@ritiek](https://github.com/ritiek)) (#379)
+- Added check for publisher tag before adding publisher id3 tag to audio file ([@gnodar01](https://github.com/gnodar01)) (#377)
+
+### Changed
+- `--list` flag accepts only text files using mimetypes ([@ManveerBasra](https://github.com/ManveerBasra)) (#414)
+- Refactored Spotify token refresh ([@ManveerBasra](https://github.com/ManveerBasra)) (#408)
+- Don't search song on Spotify if `--no-metadata` is passed ([@ManveerBasra](https://github.com/ManveerBasra)) (#404)
+- Changed test track to one whose lyrics are found ([@ManveerBasra](https://github.com/ManveerBasra)) (#400)
+- Windows - 'My Music' folder won't be assumed to be on C drive but looked up in Registry ([@SillySam](https://github.com/SillySam)) (#387)
+- Updated `setup.py` (fix PyPI URL, add Python 3.7 modifier) ([@linusg](https://github.com/linusg)) (#383)
+- Updated dependencies to their newest versions (as of 2018-10-02) ([@linusg](https://github.com/linusg)) (#382)
+- Remove duplicates from track file while preserving order ([@ritiek](https://github.com/ritiek)) (#369)
+- Moved a lot of content from `README.md` to the [repository's GitHub wiki](https://github.com/ritiek/spotify-downloader/wiki) ([@sdhutchins](https://github.com/sdhutchins), [@ritiek](https://github.com/ritiek)) (#361)
+- Refactored internal use of logging ([@arryon](https://github.com/arryon)) (#358)
+
+### Fixed
+- Check and replace slashes with dashes to avoid directory creation error ([@ManveerBasra](https://github.com/ManveerBasra)) (#402)
+- Filter unwanted text from Spotify URLs when extracting information ([@ritiek](https://github.com/ritiek)) (#394)
+- Correctly embed metadata in `.m4a` ([@arryon](https://github.com/arryon)) (#372)
+- Slugify will not ignore the `'` character (single quotation mark) anymore ([@jimangel2001](https://github.com/jimangel2001)) (#357)
+
+## [1.0.0] - 2018-09-09
+### Added
+- Initial complete release, recommended way to install is now from PyPI
+
+## 1.0.0-beta.1 - 2018-02-02
+### Added
+- Initial release, prepare for 1.0.0
+
+[Unreleased]: https://github.com/ritiek/spotify-downloader/compare/v1.1.0...HEAD
+[1.1.0]: https://github.com/ritiek/spotify-downloader/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/ritiek/spotify-downloader/compare/v1.0.0-beta.1...v1.0.0

CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project owner at ritiekmalhotra123@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+

CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing
+
+- Want to contribute to [spotify-downloader](https://github.com/ritiek/spotify-downloader)?
+That's great. We are happy to have you!
+- Here is a basic outline on opening issues and making PRs:
+
+## Opening Issues
+
+- Search for your problem in the
+[issues section](https://github.com/ritiek/spotify-downloader/issues)
+before opening a new ticket. It might be already answered and save both you and us time. :smile:
+- Provide as much information as possible when opening your ticket, including any relevant examples (if any).
+- If your issue is a *bug*, make sure you pass `--log-level=DEBUG` when invoking
+`spotdl.py` and paste the output in your issue.
+- If you think your question is naive or something and you can't find anything related,
+don't feel bad. Open an issue any way!
+
+## Making Pull Requests
+
+- Look up for open issues and see if you can help out there.
+- Easy issues for newcomers are usually labelled as
+[good-first-issue](https://github.com/ritiek/spotify-downloader/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
+- When making a PR, point it to the [master branch](https://github.com/ritiek/spotify-downloader/tree/master)
+unless mentioned otherwise.
+- Code should be formatted using [black](https://github.com/ambv/black). Don't worry if you forgot or don't know how to do this, the codebase will be black-formatted with each release.
+- All tests are placed in the [test directory](https://github.com/ritiek/spotify-downloader/tree/master/test). We use [pytest](https://github.com/pytest-dev/pytest)
+to run the test suite: `$ python3 -m pytest test`.
+If you don't have pytest, you can install it with `$ pip3 install pytest`.
+- Add a note about the changes, your GitHub username and a reference to the PR to the `Unreleased` section of the [`CHANGES.md`](CHANGES.md) file (see existing releases for examples), add the appropriate section ("Added", "Changed", "Fixed" etc.) if necessary. You don't have to increment version numbers. See https://keepachangelog.com/en/1.0.0/ for more information.
+- If you are planning to work on something big, let us know through an issue. So we can discuss more about it.
+- Lastly, please don't hesitate to ask if you have any questions!
+Let us know (through an issue) if you are facing any trouble making a PR, we'd be glad to help you out!
+
+## Related Resources
+
+- There's also a web-based front-end to operate this tool, which under (major) construction
+called [spotifube](https://github.com/linusg/spotifube).
+Check it out if you'd like to contribute to it!

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.6-alpine
+
+RUN apk add --no-cache \
+    ffmpeg
+
+ADD spotdl/ /spotify-downloader/spotdl
+ADD setup.py /spotify-downloader/setup.py
+ADD README.md /spotify-downloader/README.md
+
+WORKDIR /spotify-downloader
+RUN pip install .
+
+RUN mkdir /music
+WORKDIR /music
+
+ENTRYPOINT ["spotdl", "-f", "/music"]

ISSUE_TEMPLATE.md

@@ -10,22 +10,14 @@ Please follow the guide below
 - [ ] [Searched](https://github.com/ritiek/spotify-downloader/issues?utf8=%E2%9C%93&q=is%3Aissue) for similar issues including closed ones
 
 #### What is the purpose of your *issue*?
-- [ ] Script won't run
-- [ ] Encountered bug
-- [ ] Feature request
+- [ ] Bug
+- [ ] Feature Request
 - [ ] Question
 - [ ] Other
 
-#### System information
-- Your `python` version: `python 2.7`
-- Your operating system: `Ubuntu 16.04`
-
 ### Description
-<!-- Provide as much information possible with relevant examples and whatever you have tried below -->
+<!-- Provide as much information possible and whatever you have tried below -->
 
 
-
-
-
-
-<!-- Give your issue a relevant title and you are good to go -->
+### Log
+<!-- Run the script with `--log-level=DEBUG` and paste the output below-->

LICENSE

@@ -1,5 +1,5 @@
 The MIT License (MIT)
-Copyright (c) 2016 Ritiek Malhotra
+Copyright (c) 2018 Ritiek Malhotra
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,168 +1,95 @@
 # Spotify-Downloader
 
-- Downloads songs from YouTube in an MP3 format by using Spotify's HTTP link.
+[![PyPi](https://img.shields.io/pypi/v/spotdl.svg)](https://pypi.org/project/spotdl)
+[![Build Status](https://travis-ci.org/ritiek/spotify-downloader.svg?branch=master)](https://travis-ci.org/ritiek/spotify-downloader)
+[![Coverage Status](https://codecov.io/gh/ritiek/spotify-downloader/branch/master/graph/badge.svg)](https://codecov.io/gh/ritiek/spotify-downloader)
+[![Docker Build Status](https://img.shields.io/docker/build/ritiek/spotify-downloader.svg)](https://hub.docker.com/r/ritiek/spotify-downloader)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
+[![Gitter Chat](https://badges.gitter.im/ritiek/spotify-downloader/Lobby.svg)](https://gitter.im/spotify-downloader/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
+- Downloads songs from YouTube in an MP3 format by using Spotify's HTTP link.
 - Can also download a song by entering its artist and song name (in case if you don't have the Spotify's HTTP link for some song).
+- Automatically applies metadata to the downloaded song which includes:
 
-- Automatically fixes song's meta-tags which include:
+  - `Title`, `Artist`, `Album`, `Album art`, `Lyrics` (if found on [lyrics wikia](http://lyrics.wikia.com)), `Album artist`, `Genre`, `Track number`, `Disc number`, `Release date`, and more...
 
-  - Title
-  - Artist
-  - Album
-  - Album art
-  - Album artist
-  - Genre
-  - Track number
-  - Disc number
-  - Release date
-  - and some more..
+- Works straight out of the box and does not require you to generate or mess with your API keys (already included).
 
-- Works straight out of the box and does not require to generate or mess with your API keys.
-
-<br>
-
-That's how your Music library will look like!
+Below is how your music library will look!
 
 <img src="http://i.imgur.com/Gpch7JI.png" width="290"><img src="http://i.imgur.com/5vhk3HY.png" width="290"><img src="http://i.imgur.com/RDTCCST.png" width="290">
 
-## Reporting Issues
+## Installation
 
-- Search for your problem in the [issues section](https://github.com/Ritiek/spotify-downloader/issues?utf8=%E2%9C%93&q=) before opening a new ticket. It might be already answered and save us time :D.
+:heavy_exclamation_mark: **This tool works only with Python 3.**
 
-- Provide as much information possible when opening your ticket.
+Python 2 compatibility was dropped because of the way it deals with unicode (2020 is coming soon too).
+If you still need to use Python 2 - check out the (outdated)
+[python2](https://github.com/ritiek/spotify-downloader/tree/python2) branch.
 
-## Installation & Usage
-
-<img src="http://i.imgur.com/Dg8p9up.png" width="600">
-
-- This version supports both Python2 and Python3.
-
-- Note: `play` and `lyrics` commands have been deprecated in the current brach since they were not of much use and created unnecessary clutter. You can still get them back by using `old` branch though.
-
-### Debian, Ubuntu, Linux & Mac
+spotify-downloader works with all major distributions and even on low-powered devices such as a Raspberry Pi.
 
+spotify-downloader can be installed via pip with:
 ```
-cd
-git clone https://github.com/ritiek/spotify-downloader
-cd spotify-downloader
-pip install -U -r requirements.txt
+$ pip3 install spotdl
 ```
 
-You'll also need to install FFmpeg for conversion (use `--avconv` if you'd like to use that instead):
+but be sure to check out the [Installation](https://github.com/ritiek/spotify-downloader/wiki/Installation) wiki
+page for detailed OS-specific instructions to get it and other dependencies it relies on working on your system.
 
-Linux: `sudo apt-get install ffmpeg`
+## Usage
 
-Mac: `brew install ffmpeg --with-libmp3lame --with-libass --with-opus --with-fdk-aac`
-
-If it does not install correctly, you may have to build it from source. For more info see https://trac.ffmpeg.org/wiki/CompilationGuide.
-
-### Windows
-
-Assuming you have Python already installed..
-
-- Download FFmpeg for Windows from [here](http://ffmpeg.zeranoe.com/builds/). Copy `ffmpeg.exe` from `ffmpeg-xxx-winxx-static\bin\ffmpeg.exe` to `Scripts` folder (in your Python's installation directory: `Pythonxx\Scripts\ffmpeg.exe`)
-
-- Download the [zip file](https://github.com/ritiek/spotify-downloader/archive/master.zip) of this repository and copy the folder contained in the archive into your Python's installation folder (`\Python36\spotify-downloader-master`).
-
-- Open the folder from last step. Shift+right-click on empty area, open `cmd` and type:
-
-  `"Scripts/pip.exe" install -U -r requirements.txt`
-
-- If you do not want to naviagte to your Python folder from the command-line everytime you want to run the script, you can have your Python 'PATH' environment variables set and then you can run the script from any directory.
-
-## Instructions for Downloading Songs
-
-- For all available options, run `python spotdl.py --help` (or for Windows run `python.exe spotdl.py --help`).
+For the most basic usage, downloading tracks is as easy as
 
 ```
-usage: spotdl.py [-h] (-s SONG | -l LIST | -u USERNAME) [-n] [-m] [-f] [-v]
-                 [-i INPUT_EXT] [-o OUTPUT_EXT]
-
-Download and convert songs from Spotify, Youtube etc.
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -s SONG, --song SONG  download song by spotify link or name (default: None)
-  -l LIST, --list LIST  download songs from a file (default: None)
-  -u USERNAME, --username USERNAME
-                        load user's playlists into <playlist_name>.txt
-                        (default: None)
-  -m, --manual          choose the song to download manually (default: False)
-  -a, --avconv          Use avconv for conversion. If not set
-                        defaults to FFmpeg (default: False)
-  -v, --verbose         show debug output (default: False)
-  -i INPUT_EXT, --input_ext INPUT_EXT
-                        prefered input format .m4a or .webm (Opus) (default:
-                        .m4a)
-  -o OUTPUT_EXT, --output_ext OUTPUT_EXT
-                        prefered output extension .mp3 or .m4a (AAC) (default:
-                        .mp3)
+$ spotdl --song https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ
+$ spotdl --song "ncs - spectre"
 ```
 
-#### Downloading by Name
-
-For example
-
-- We want to download Hello by Adele, simply run `python spotdl.py --song "adele hello"`.
-
-- The script will automatically look for the best matching song and download it in the folder `Music/` placed in the root directory of the code base.
-
-- It will now convert the song to an mp3 and try to fix meta-tags and album-art by looking up on Spotify.
-
-#### Downloading by Spotify Link (Recommended)
-
-For example
-
-- We want to download the same song (i.e: Hello by Adele) but using Spotify Link this time that looks like  `http://open.spotify.com/track/1MDoll6jK4rrk2BcFRP5i7`, you can copy it from your Spotify desktop or mobile app by right clicking or long tap on the song and copy HTTP link.
-
-- Run `python spotdl.py --song http://open.spotify.com/track/1MDoll6jK4rrk2BcFRP5i7`, it should download Hello by Adele.
-
-- Just like before, it will again convert the song to an mp3 but since we used a Spotify HTTP link, the script is guaranteed to fetch the correct meta-tags and album-art.
-
-#### Download multiple songs at once
-
-For example
-
-- We want to download `Hello by Adele`, `The Nights by Avicci` and `21 Guns by Green Day` just using a single command.
-
-Let's suppose, we have the Spotify link for only `Hello by Adele` and `21 Guns by Green Day`.
-
-No problem!
-
-- Just make a `list.txt` in the same folder as the script and add all the songs you want to download, in our case it is
-
-(if you are on windows, just edit `list.txt` - i.e `C:\Python27\list.txt`)
+For downloading playlist and albums, you need to first load all the tracks into text file and then pass
+this text file to `--list` argument. Here is how you would do it for a playlist
 
 ```
-https://open.spotify.com/track/1MDoll6jK4rrk2BcFRP5i7
-the nights avicci
-http://open.spotify.com/track/64yrDBpcdwEdNY9loyEGbX
+$ spotdl --playlist https://open.spotify.com/user/nocopyrightsounds/playlist/7sZbq8QGyMnhKPcLJvCUFD
+INFO: Writing 62 tracks to ncs-releases.txt
+$ spotdl --list ncs-releases.txt
 ```
 
-- Now pass `--list=list.txt` to the script, i.e `python spotdl.py --list=list.txt` and it will start downloading songs mentioned in `list.txt`.
+Run `spotdl --help` to get a list of all available options in spotify-downloader.
 
-- You can stop downloading songs by hitting `ctrl+c`, the script will automatically resume from the song where you stopped it the next time you want to download the songs present in `list.txt`.
+Check out the [Available options](https://github.com/ritiek/spotify-downloader/wiki/Available-options)
+wiki page for the list of currently available options with their description.
 
-- Songs that are already downloaded will be skipped and not be downloaded again.
+The wiki page [Instructions for Downloading Songs](https://github.com/ritiek/spotify-downloader/wiki/Instructions-for-Downloading-Songs)
+contains detailed information about different available ways to download tracks.
 
-#### Downloading playlists
+## FAQ
 
-- You can also load songs from any playlist provided you have a Spotify username or user id of that user. (Open profile in Spotify, click on the three little dots below name, "Share", "Copy to clipboard", paste last numbers into command-line: `https://open.spotify.com/user/0123456790`)
+- [
+How to specify a custom folder where tracks should be downloaded?](https://github.com/ritiek/spotify-downloader/wiki/FAQ#how-to-specify-a-custom-folder-where-tracks-should-be-downloaded)
 
-- Try running `python spotdl.py -u <your_username>`, it will show all your public playlists.
+Check out our [FAQ wiki page](https://github.com/ritiek/spotify-downloader/wiki/FAQ)
+for more info.
 
-- Once you select the one you want to download, the script will load all the tracks from the playlist into `<playlist_name>.txt`
+## Contributing
 
-- Then you can simply run `python spotdl.py --list=<playlist_name>.txt` to download them all!
+Check out [CONTRIBUTING.md](CONTRIBUTING.md) for more info.
 
-## Running tests
+## Running Tests
 
-`python -m pytest test`
+```
+$ python3 -m pytest test
+```
+
+Obviously this requires the `pytest` module to be installed.
 
 ## Disclaimer
 
-Downloading copyright songs may be illegal in your country. This tool is for educational purposes only and was created only to show how Spotify's API can be exploited to download music from YouTube. Please support the artists by buying their music.
+Downloading copyright songs may be illegal in your country.
+This tool is for educational purposes only and was created only to show
+how Spotify's API can be exploited to download music from YouTube.
+Please support the artists by buying their music.
 
 ## License
 
-```The MIT License```
+[![License](https://img.shields.io/github/license/ritiek/spotify-downloader.svg)](https://github.com/ritiek/spotify-downloader/blob/master/LICENSE)

core/__init__.py

@@ -1 +0,0 @@
-

core/convert.py

@@ -1,83 +0,0 @@
-import subprocess
-import os
-import sys
-
-
-def song(input_song, output_song, avconv=False, verbose=False):
-    """Do the audio format conversion."""
-    if not input_song == output_song:
-        if sys.version_info < (3, 0):
-            input_song = input_song.encode('utf-8')
-            output_song = output_song.encode('utf-8')
-        print('Converting {0} to {1}'.format(
-            input_song, output_song.split('.')[-1]))
-        if avconv:
-            exit_code = convert_with_avconv(input_song, output_song, verbose)
-        else:
-            exit_code = convert_with_ffmpeg(input_song, output_song, verbose)
-        return exit_code
-    return 0
-
-
-def convert_with_avconv(input_song, output_song, verbose):
-    """Convert the audio file using avconv."""
-    if os.name == 'nt':
-        avconv_path = '..\\Scripts\\avconv.exe'
-    else:
-        avconv_path = 'avconv'
-
-    if verbose:
-        level = 'debug'
-    else:
-        level = '0'
-
-    command = [avconv_path,
-               '-loglevel', level,
-               '-i',        'Music/' + input_song,
-               '-ab',       '192k',
-               'Music/' + output_song]
-
-    return subprocess.call(command)
-
-
-def convert_with_ffmpeg(input_song, output_song, verbose):
-    """Convert the audio file using FFMpeg.
-
-    What are the differences and similarities between ffmpeg, libav, and avconv?
-    https://stackoverflow.com/questions/9477115
-    ffmeg encoders high to lower quality
-    libopus > libvorbis >= libfdk_aac > aac > libmp3lame
-    libfdk_aac due to copyrights needs to be compiled by end user
-    on MacOS brew install ffmpeg --with-fdk-aac will do just that. Other OS?
-    https://trac.ffmpeg.org/wiki/Encode/AAC
-    """
-
-    if os.name == "nt":
-        ffmpeg_pre = '..\\Scripts\\ffmpeg.exe '
-    else:
-        ffmpeg_pre = 'ffmpeg '
-
-    ffmpeg_pre += '-y '
-    if not verbose:
-        ffmpeg_pre += '-hide_banner -nostats -v panic '
-
-    ffmpeg_params = ''
-    input_ext = input_song.split('.')[-1]
-    output_ext = output_song.split('.')[-1]
-
-    if input_ext == 'm4a':
-        if output_ext == 'mp3':
-            ffmpeg_params = '-codec:v copy -codec:a libmp3lame -q:a 2 '
-        elif output_ext == 'webm':
-            ffmpeg_params = '-c:a libopus -vbr on -b:a 192k -vn '
-
-    elif input_ext == 'webm':
-        if output_ext == 'mp3':
-            ffmpeg_params = ' -ab 192k -ar 44100 -vn '
-        elif output_ext == 'm4a':
-            ffmpeg_params = '-cutoff 20000 -c:a libfdk_aac -b:a 192k -vn '
-
-    command = '{0}-i Music/{1} {2}Music/{3}'.format(
-        ffmpeg_pre, input_song, ffmpeg_params, output_song).split(' ')
-
-    return subprocess.call(command)

core/metadata.py

@@ -1,125 +0,0 @@
-from mutagen.easyid3 import EasyID3
-from mutagen.id3 import ID3, APIC
-from mutagen.mp4 import MP4, MP4Cover
-import sys
-
-# urllib2 is urllib.request in python3
-try:
-    import urllib2
-except ImportError:
-    import urllib.request as urllib2
-
-
-def compare(file, metadata):
-    """Check if the input file title matches the expected title."""
-    already_tagged = False
-    try:
-        if file.endswith('.mp3'):
-            audiofile = EasyID3('Music/' + file)
-            # fetch track title metadata
-            already_tagged = audiofile['title'][0] == metadata['name']
-        elif file.endswith('.m4a'):
-            tags = {'title': '\xa9nam'}
-            audiofile = MP4('Music/' + file)
-            # fetch track title metadata
-            already_tagged = audiofile[tags['title']] == metadata['name']
-    except (KeyError, TypeError):
-        pass
-    return already_tagged
-
-
-def embed(music_file, meta_tags):
-    """Embed metadata."""
-    if sys.version_info < (3, 0):
-        music_file = music_file.encode('utf-8')
-    if meta_tags is None:
-        print('Could not find meta-tags')
-        return None
-    elif music_file.endswith('.m4a'):
-        print('Fixing meta-tags')
-        return embed_m4a(music_file, meta_tags)
-    elif music_file.endswith('.mp3'):
-        print('Fixing meta-tags')
-        return embed_mp3(music_file, meta_tags)
-    else:
-        print('Cannot embed meta-tags into given output extension')
-        return False
-
-
-def embed_mp3(music_file, meta_tags):
-    """Embed metadata to MP3 files."""
-    # EasyID3 is fun to use ;)
-    audiofile = EasyID3('Music/' + music_file)
-    audiofile['artist'] = meta_tags['artists'][0]['name']
-    audiofile['albumartist'] = meta_tags['artists'][0]['name']
-    audiofile['album'] = meta_tags['album']['name']
-    audiofile['title'] = meta_tags['name']
-    audiofile['tracknumber'] = [meta_tags['track_number'],
-                                meta_tags['total_tracks']]
-    audiofile['discnumber'] = [meta_tags['disc_number'], 0]
-    audiofile['date'] = meta_tags['release_date']
-    audiofile['originaldate'] = meta_tags['release_date']
-    audiofile['media'] = meta_tags['type']
-    audiofile['author'] = meta_tags['artists'][0]['name']
-    audiofile['lyricist'] = meta_tags['artists'][0]['name']
-    audiofile['arranger'] = meta_tags['artists'][0]['name']
-    audiofile['performer'] = meta_tags['artists'][0]['name']
-    audiofile['encodedby'] = meta_tags['publisher']
-    audiofile['isrc'] = meta_tags['external_ids']['isrc']
-    audiofile['website'] = meta_tags['external_urls']['spotify']
-    audiofile['length'] = str(meta_tags['duration_ms'] / 1000)
-    if meta_tags['genre']:
-        audiofile['genre'] = meta_tags['genre']
-    if meta_tags['copyright']:
-        audiofile['copyright'] = meta_tags['copyright']
-    audiofile.save(v2_version=3)
-    audiofile = ID3('Music/' + music_file)
-    albumart = urllib2.urlopen(meta_tags['album']['images'][0]['url'])
-    audiofile["APIC"] = APIC(encoding=3, mime='image/jpeg', type=3,
-                             desc=u'Cover', data=albumart.read())
-    albumart.close()
-    audiofile.save(v2_version=3)
-    return True
-
-
-def embed_m4a(music_file, meta_tags):
-    """Embed metadata to M4A files."""
-    # Apple has specific tags - see mutagen docs -
-    # http://mutagen.readthedocs.io/en/latest/api/mp4.html
-    tags = {'album': '\xa9alb',
-            'artist': '\xa9ART',
-            'date': '\xa9day',
-            'title': '\xa9nam',
-            'originaldate': 'purd',
-            'comment': '\xa9cmt',
-            'group': '\xa9grp',
-            'writer': '\xa9wrt',
-            'genre': '\xa9gen',
-            'tracknumber': 'trkn',
-            'albumartist': 'aART',
-            'disknumber': 'disk',
-            'cpil': 'cpil',
-            'albumart': 'covr',
-            'copyright': 'cprt',
-            'tempo': 'tmpo'}
-
-    audiofile = MP4('Music/' + music_file)
-    audiofile[tags['artist']] = meta_tags['artists'][0]['name']
-    audiofile[tags['albumartist']] = meta_tags['artists'][0]['name']
-    audiofile[tags['album']] = meta_tags['album']['name']
-    audiofile[tags['title']] = meta_tags['name']
-    audiofile[tags['tracknumber']] = [(meta_tags['track_number'],
-                                       meta_tags['total_tracks'])]
-    audiofile[tags['disknumber']] = [(meta_tags['disc_number'], 0)]
-    audiofile[tags['date']] = meta_tags['release_date']
-    audiofile[tags['originaldate']] = meta_tags['release_date']
-    if meta_tags['genre']:
-        audiofile[tags['genre']] = meta_tags['genre']
-    if meta_tags['copyright']:
-        audiofile[tags['copyright']] = meta_tags['copyright']
-    albumart = urllib2.urlopen(meta_tags['album']['images'][0]['url'])
-    audiofile[tags['albumart']] = [MP4Cover(
-        albumart.read(), imageformat=MP4Cover.FORMAT_JPEG)]
-    albumart.close()
-    audiofile.save()
-    return True

core/misc.py

@@ -1,143 +0,0 @@
-import argparse
-import sys
-import os
-from slugify import slugify
-import spotipy.oauth2 as oauth2
-
-try:
-    from urllib2 import quote
-except ImportError:
-    from urllib.request import quote
-
-
-def input_link(links):
-    """Let the user input a number."""
-    while True:
-        try:
-            the_chosen_one = int(user_input('>> Choose your number: '))
-            if 1 <= the_chosen_one <= len(links):
-                return links[the_chosen_one - 1]
-            elif the_chosen_one == 0:
-                return None
-            else:
-                print('Choose a valid number!')
-        except ValueError:
-            print('Choose a valid number!')
-
-
-def user_input(string=''):
-    """Take input correctly for both Python 2 & 3."""
-    if sys.version_info > (3, 0):
-        return input(string)
-    else:
-        return raw_input(string)
-
-
-def trim_song(file):
-    """Remove the first song from file."""
-    with open(file, 'r') as file_in:
-        data = file_in.read().splitlines(True)
-    with open(file, 'w') as file_out:
-        file_out.writelines(data[1:])
-
-
-def get_arguments():
-    parser = argparse.ArgumentParser(
-        description='Download and convert songs from Spotify, Youtube etc.',
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    group = parser.add_mutually_exclusive_group(required=True)
-
-    group.add_argument(
-        '-s', '--song', help='download song by spotify link or name')
-    group.add_argument(
-        '-l', '--list', help='download songs from a file')
-    group.add_argument(
-        '-u', '--username',
-        help="load user's playlists into <playlist_name>.txt")
-    parser.add_argument(
-        '-m', '--manual', default=False,
-        help='choose the song to download manually', action='store_true')
-    parser.add_argument(
-        '-nm', '--no-metadata', default=False,
-        help='do not embed metadata in songs', action='store_true')
-    parser.add_argument(
-        '-a', '--avconv', default=False,
-        help='Use avconv for conversion otherwise set defaults to ffmpeg',
-        action='store_true')
-    parser.add_argument(
-        '-v', '--verbose', default=False, help='show debug output',
-        action='store_true')
-    parser.add_argument(
-        '-i', '--input_ext', default='.m4a',
-        help='prefered input format .m4a or .webm (Opus)')
-    parser.add_argument(
-        '-o', '--output_ext', default='.mp3',
-        help='prefered output extension .mp3 or .m4a (AAC)')
-
-    return parser.parse_args()
-
-
-def is_spotify(raw_song):
-    """Check if the input song is a Spotify link."""
-    if (len(raw_song) == 22 and raw_song.replace(" ", "%20") == raw_song) or \
-            (raw_song.find('spotify') > -1):
-        return True
-    else:
-        return False
-
-
-def generate_filename(title):
-    """Generate filename of the song to be downloaded."""
-    # IMO python2 sucks dealing with unicode
-    title = fix_encoding(title)
-    title = fix_decoding(title)
-    title = title.replace(' ', '_')
-
-    # slugify removes any special characters
-    filename = slugify(title, ok='-_()[]{}', lower=False)
-    return fix_encoding(filename)
-
-
-def generate_token():
-    """Generate the token. Please respect these credentials :)"""
-    credentials = oauth2.SpotifyClientCredentials(
-        client_id='4fe3fecfe5334023a1472516cc99d805',
-        client_secret='0f02b7c483c04257984695007a4a8d5c')
-    token = credentials.get_access_token()
-    return token
-
-
-def generate_search_url(song):
-    """Generate YouTube search URL for the given song."""
-    # urllib2.quote() encodes URL with special characters
-    url = u"https://www.youtube.com/results?sp=EgIQAQ%253D%253D&q={0}".format(
-        quote(song))
-    return url
-
-
-def fix_encoding(query):
-    """Fix encoding issues in Python 2."""
-    if sys.version_info < (3, 0):
-        query = query.encode('utf-8')
-    return query
-
-
-def fix_decoding(query):
-    """Fix decoding issues in Python 2."""
-    if sys.version_info < (3, 0):
-        query = query.decode('utf-8')
-    return query
-
-
-def filter_path(path):
-    os.chdir(sys.path[0])
-    if not os.path.exists(path):
-        os.makedirs(path)
-    for temp in os.listdir(path):
-        if temp.endswith('.temp'):
-            os.remove('{0}/{1}'.format(path, temp))
-
-
-def grace_quit():
-    print('\n\nExiting.')
-    sys.exit()

requirements.txt

@@ -1,8 +0,0 @@
-pathlib >= 1.0.1
-BeautifulSoup4 >= 0.4.13
-youtube_dl >= 2017.5.1
-pafy >= 0.5.3.1
-spotipy >= 2.4.4
-mutagen >= 1.37
-unicode-slugify >= 0.1.3
-titlecase >= 0.10.0

setup.py

@@ -0,0 +1,64 @@
+from setuptools import setup
+
+with open("README.md", "r") as f:
+    long_description = f.read()
+
+import spotdl
+
+setup(
+    # 'spotify-downloader' was already taken :/
+    name="spotdl",
+    # Tests are included automatically:
+    # https://docs.python.org/3.6/distutils/sourcedist.html#specifying-the-files-to-distribute
+    packages=["spotdl"],
+    version=spotdl.__version__,
+    install_requires=[
+        "pathlib >= 1.0.1",
+        "youtube_dl >= 2017.9.26",
+        "pafy >= 0.5.3.1",
+        "spotipy >= 2.4.4",
+        "mutagen >= 1.41.1",
+        "beautifulsoup4 >= 4.6.3",
+        "unicode-slugify >= 0.1.3",
+        "titlecase >= 0.10.0",
+        "logzero >= 1.3.1",
+        "lyricwikia >= 0.1.8",
+        "PyYAML >= 3.13",
+        "appdirs >= 1.4.3",
+    ],
+    description="Download songs from YouTube using Spotify song URLs or playlists with albumart and meta-tags.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Ritiek Malhotra and the spotify-downloader contributors",
+    author_email="ritiekmalhotra123@gmail.com",
+    license="MIT",
+    python_requires=">=3.4",
+    url="https://github.com/ritiek/spotify-downloader",
+    download_url="https://pypi.org/project/spotdl/",
+    keywords=[
+        "spotify",
+        "downloader",
+        "download",
+        "music",
+        "youtube",
+        "mp3",
+        "album",
+        "metadata",
+    ],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: End Users/Desktop",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3 :: Only",
+        "Topic :: Multimedia",
+        "Topic :: Multimedia :: Sound/Audio",
+        "Topic :: Utilities",
+    ],
+    entry_points={"console_scripts": ["spotdl = spotdl.spotdl:main"]},
+)

spotdl.py

@@ -1,318 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: UTF-8 -*-
-
-from core import metadata
-from core import convert
-from core import misc
-from bs4 import BeautifulSoup
-from titlecase import titlecase
-from slugify import slugify
-import spotipy
-import pafy
-import sys
-import os
-
-# urllib2 is urllib.request in python3
-try:
-    import urllib2
-except ImportError:
-    import urllib.request as urllib2
-
-
-def generate_songname(raw_song):
-    """Generate a string of the format '[artist] - [song]' for the given song."""
-    if misc.is_spotify(raw_song):
-        tags = generate_metadata(raw_song)
-        raw_song = u'{0} - {1}'.format(tags['artists'][0]['name'], tags['name'])
-    return misc.fix_encoding(raw_song)
-
-
-def generate_metadata(raw_song):
-    """Fetch a song's metadata from Spotify."""
-    if misc.is_spotify(raw_song):
-        # fetch track information directly if it is spotify link
-        meta_tags = spotify.track(raw_song)
-    else:
-        # otherwise search on spotify and fetch information from first result
-        try:
-            meta_tags = spotify.search(raw_song, limit=1)['tracks']['items'][0]
-        except:
-            return None
-    artist = spotify.artist(meta_tags['artists'][0]['id'])
-    album = spotify.album(meta_tags['album']['id'])
-
-    try:
-        meta_tags[u'genre'] = titlecase(artist['genres'][0])
-    except IndexError:
-        meta_tags[u'genre'] = None
-    try:
-        meta_tags[u'copyright'] = album['copyrights'][0]['text']
-    except IndexError:
-        meta_tags[u'copyright'] = None
-
-    meta_tags[u'release_date'] = album['release_date']
-    meta_tags[u'publisher'] = album['label']
-    meta_tags[u'total_tracks'] = album['tracks']['total']
-    # import pprint
-    # pprint.pprint(meta_tags)
-    # pprint.pprint(spotify.album(meta_tags['album']['id']))
-    return meta_tags
-
-
-def generate_youtube_url(raw_song):
-    """Search for the song on YouTube and generate an URL to its video."""
-    song = generate_songname(raw_song)
-    search_url = misc.generate_search_url(song)
-    item = urllib2.urlopen(search_url).read()
-    # item = unicode(item, 'utf-8')
-    items_parse = BeautifulSoup(item, "html.parser")
-    check = 1
-    if args.manual:
-        links = []
-        print(song)
-        print('')
-        print('0. Skip downloading this song')
-        # fetch all video links on first page on YouTube
-        for x in items_parse.find_all('h3', {'class': 'yt-lockup-title'}):
-            # confirm the video result is not an advertisement
-            if x.find('channel') is None and x.find('googleads') is None:
-                link = x.find('a')['href']
-                links.append(link)
-                print(u'{0}. {1} {2}'.format(check, x.get_text(), "http://youtube.com"+link))
-                check += 1
-        print('')
-        # let user select the song to download
-        result = misc.input_link(links)
-        if result is None:
-            return None
-    else:
-        # get video link of the first YouTube result
-        result = items_parse.find_all(
-            attrs={'class': 'yt-uix-tile-link'})[0]['href']
-
-        # confirm the video result is not an advertisement
-        # otherwise keep iterating until it is not
-        while result.find('channel') > -1 or result.find('googleads') > -1:
-            result = items_parse.find_all(
-                attrs={'class': 'yt-uix-tile-link'})[check]['href']
-            check += 1
-
-    full_link = u'youtube.com{0}'.format(result)
-    return full_link
-
-
-def go_pafy(raw_song):
-    """Parse track from YouTube."""
-    track_url = generate_youtube_url(raw_song)
-    if track_url is None:
-        return None
-    else:
-        return pafy.new(track_url)
-
-
-def get_youtube_title(content, number=None):
-    """Get the YouTube video's title."""
-    title = misc.fix_encoding(content.title)
-    if number is None:
-        return title
-    else:
-        return '{0}. {1}'.format(number, title)
-
-
-def feed_playlist(username):
-    """Fetch user playlists when using the -u option."""
-    playlists = spotify.user_playlists(username)
-    links = []
-    check = 1
-
-    while True:
-        for playlist in playlists['items']:
-            # in rare cases, playlists may not be found, so playlists['next']
-            # is None. Skip these. Also see Issue #91.
-            if playlist['name'] is not None:
-                print(u'{0:>5}.| {1:<30} | ({2} tracks)'.format(
-                    check, misc.fix_encoding(playlist['name']),
-                    playlist['tracks']['total']))
-                links.append(playlist)
-                check += 1
-        if playlists['next']:
-            playlists = spotify.next(playlists)
-        else:
-            break
-
-    print('')
-    playlist = misc.input_link(links)
-    results = spotify.user_playlist(
-        playlist['owner']['id'], playlist['id'], fields='tracks,next')
-    print('')
-    file = u'{0}.txt'.format(slugify(playlist['name'], ok='-_()[]{}'))
-    print(u'Feeding {0} tracks to {1}'.format(playlist['tracks']['total'], file))
-
-    tracks = results['tracks']
-    with open(file, 'a') as file_out:
-        while True:
-            for item in tracks['items']:
-                track = item['track']
-                try:
-                    file_out.write(track['external_urls']['spotify'] + '\n')
-                except KeyError:
-                    print(u'Skipping track {0} by {1} (local only?)'.format(
-                        track['name'], track['artists'][0]['name']))
-            # 1 page = 50 results
-            # check if there are more pages
-            if tracks['next']:
-                tracks = spotify.next(tracks)
-            else:
-                break
-
-
-def download_song(content):
-    """Download the audio file from YouTube."""
-    if args.input_ext == '.webm':
-        link = content.getbestaudio(preftype='webm')
-    elif args.input_ext == '.m4a':
-        link = content.getbestaudio(preftype='m4a')
-    else:
-        return False
-
-    if link is None:
-        return False
-    else:
-        music_file = misc.generate_filename(content.title)
-        link.download(
-            filepath='Music/{0}{1}'.format(music_file, args.input_ext))
-        return True
-
-
-def check_exists(music_file, raw_song, islist=True):
-    """Check if the input song already exists in the 'Music' folder."""
-    files = os.listdir('Music')
-    for file in files:
-        if file.endswith('.temp'):
-            os.remove(u'Music/{0}'.format(file))
-            continue
-        # check if any file with similar name is already present in Music/
-        dfile = misc.fix_decoding(file)
-        umfile = misc.fix_decoding(misc.generate_filename(music_file))
-        if dfile.startswith(umfile):
-            # check if the already downloaded song has correct metadata
-            already_tagged = metadata.compare(file, generate_metadata(raw_song))
-
-            # if not, remove it and download again without prompt
-            if misc.is_spotify(raw_song) and not already_tagged:
-                os.remove('Music/{0}'.format(file))
-                return False
-
-            # do not prompt and skip the current song
-            # if already downloaded when using list
-            if islist:
-                return True
-            # if downloading only single song, prompt to re-download
-            else:
-                prompt = misc.user_input(
-                    'Song with same name has already been downloaded. '
-                    'Re-download? (y/n): ').lower()
-                if prompt == 'y':
-                    os.remove('Music/{0}'.format(file))
-                    return False
-                else:
-                    return True
-    return False
-
-
-def grab_list(file):
-    """Download all songs from the list."""
-    with open(file, 'r') as listed:
-        lines = (listed.read()).splitlines()
-    # ignore blank lines in file (if any)
-    try:
-        lines.remove('')
-    except ValueError:
-        pass
-    print(u'Total songs in list: {0} songs'.format(len(lines)))
-    print('')
-    # nth input song
-    number = 1
-    for raw_song in lines:
-        try:
-            grab_single(raw_song, number=number)
-        # token expires after 1 hour
-        except spotipy.oauth2.SpotifyOauthError:
-            # refresh token when it expires
-            new_token = misc.generate_token()
-            global spotify
-            spotify = spotipy.Spotify(auth=new_token)
-            grab_single(raw_song, number=number)
-        # detect network problems
-        except (urllib2.URLError, TypeError, IOError):
-            lines.append(raw_song)
-            # remove the downloaded song from .txt
-            misc.trim_song(file)
-            # and append it to the last line in .txt
-            with open(file, 'a') as myfile:
-                myfile.write(raw_song)
-            print('Failed to download song. Will retry after other songs.')
-            continue
-        except KeyboardInterrupt:
-            misc.grace_quit()
-        finally:
-            print('')
-        misc.trim_song(file)
-        number += 1
-
-
-def grab_single(raw_song, number=None):
-    """Logic behind downloading a song."""
-    if number:
-        islist = True
-    else:
-        islist = False
-    content = go_pafy(raw_song)
-    if content is None:
-        return
-    # print '[number]. [artist] - [song]' if downloading from list
-    # otherwise print '[artist] - [song]'
-    print(get_youtube_title(content, number))
-
-    # generate file name of the song to download
-    music_file = misc.generate_filename(content.title)
-    music_file = misc.fix_decoding(music_file)
-    if not check_exists(music_file, raw_song, islist=islist):
-        if download_song(content):
-            print('')
-            input_song = music_file + args.input_ext
-            output_song = music_file + args.output_ext
-            convert.song(input_song, output_song, avconv=args.avconv,
-                         verbose=args.verbose)
-            if not args.input_ext == args.output_ext:
-                os.remove('Music/{0}'.format(misc.fix_encoding(input_song)))
-            meta_tags = generate_metadata(raw_song)
-            if not args.no_metadata:
-                metadata.embed(output_song, meta_tags)
-        else:
-            print('No audio streams available')
-
-
-class Args(object):
-    manual = False
-    input_ext = '.m4a'
-    output_ext = '.mp3'
-
-args = Args()
-# token is mandatory when using Spotify's API
-# https://developer.spotify.com/news-stories/2017/01/27/removing-unauthenticated-calls-to-the-web-api/
-token = misc.generate_token()
-spotify = spotipy.Spotify(auth=token)
-
-misc.filter_path('Music')
-
-if __name__ == '__main__':
-    os.chdir(sys.path[0])
-    args = misc.get_arguments()
-
-    if args.song:
-        grab_single(raw_song=args.song)
-    elif args.list:
-        grab_list(file=args.list)
-    elif args.username:
-        feed_playlist(username=args.username)

spotdl/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.0"

spotdl/const.py

@@ -0,0 +1,39 @@
+import logzero
+
+_log_format = "%(color)s%(levelname)s:%(end_color)s %(message)s"
+_formatter = logzero.LogFormatter(fmt=_log_format)
+
+# Set up a temporary logger with default log level so that
+# it can be used before log level argument is determined
+logzero.setup_default_logger(formatter=_formatter)
+
+# options
+args = None
+
+# Apple has specific tags - see mutagen docs -
+# http://mutagen.readthedocs.io/en/latest/api/mp4.html
+M4A_TAG_PRESET = {
+    "album": "\xa9alb",
+    "artist": "\xa9ART",
+    "date": "\xa9day",
+    "title": "\xa9nam",
+    "year": "\xa9day",
+    "originaldate": "purd",
+    "comment": "\xa9cmt",
+    "group": "\xa9grp",
+    "writer": "\xa9wrt",
+    "genre": "\xa9gen",
+    "tracknumber": "trkn",
+    "albumartist": "aART",
+    "discnumber": "disk",
+    "cpil": "cpil",
+    "albumart": "covr",
+    "copyright": "cprt",
+    "tempo": "tmpo",
+    "lyrics": "\xa9lyr",
+    "comment": "\xa9cmt",
+}
+
+TAG_PRESET = {}
+for key in M4A_TAG_PRESET.keys():
+    TAG_PRESET[key] = key

spotdl/convert.py

@@ -0,0 +1,102 @@
+import subprocess
+import os
+from logzero import logger as log
+
+
+"""What are the differences and similarities between ffmpeg, libav, and avconv?
+https://stackoverflow.com/questions/9477115
+
+ffmeg encoders high to lower quality
+libopus > libvorbis >= libfdk_aac > aac > libmp3lame
+
+libfdk_aac due to copyrights needs to be compiled by end user
+on MacOS brew install ffmpeg --with-fdk-aac will do just that. Other OS?
+https://trac.ffmpeg.org/wiki/Encode/AAC
+"""
+
+
+def song(input_song, output_song, folder, avconv=False, trim_silence=False):
+    """ Do the audio format conversion. """
+    if input_song == output_song:
+        return 0
+    convert = Converter(input_song, output_song, folder, trim_silence)
+    log.info("Converting {0} to {1}".format(input_song, output_song.split(".")[-1]))
+    if avconv:
+        exit_code = convert.with_avconv()
+    else:
+        exit_code = convert.with_ffmpeg()
+    return exit_code
+
+
+class Converter:
+    def __init__(self, input_song, output_song, folder, trim_silence=False):
+        self.input_file = os.path.join(folder, input_song)
+        self.output_file = os.path.join(folder, output_song)
+        self.trim_silence = trim_silence
+
+    def with_avconv(self):
+        if log.level == 10:
+            level = "debug"
+        else:
+            level = "0"
+
+        command = [
+            "avconv",
+            "-loglevel",
+            level,
+            "-i",
+            self.input_file,
+            "-ab",
+            "192k",
+            self.output_file,
+            "-y",
+        ]
+
+        if self.trim_silence:
+            log.warning("--trim-silence not supported with avconv")
+
+        log.debug(command)
+        return subprocess.call(command)
+
+    def with_ffmpeg(self):
+        ffmpeg_pre = "ffmpeg -y "
+
+        if not log.level == 10:
+            ffmpeg_pre += "-hide_banner -nostats -v panic "
+
+        _, input_ext = os.path.splitext(self.input_file)
+        _, output_ext = os.path.splitext(self.output_file)
+
+        ffmpeg_params = ""
+
+        if input_ext == ".m4a":
+            if output_ext == ".mp3":
+                ffmpeg_params = "-codec:v copy -codec:a libmp3lame -ar 44100 "
+            elif output_ext == ".webm":
+                ffmpeg_params = "-codec:a libopus -vbr on "
+
+        elif input_ext == ".webm":
+            if output_ext == ".mp3":
+                ffmpeg_params = "-codec:a libmp3lame -ar 44100 "
+            elif output_ext == ".m4a":
+                ffmpeg_params = "-cutoff 20000 -codec:a libfdk_aac -ar 44100 "
+
+        if output_ext == ".flac":
+            ffmpeg_params = "-codec:a flac -ar 44100 "
+
+        # add common params for any of the above combination
+        ffmpeg_params += "-b:a 192k -vn "
+        ffmpeg_pre += " -i"
+
+        if self.trim_silence:
+            ffmpeg_params += "-af silenceremove=start_periods=1 "
+
+        command = (
+            ffmpeg_pre.split()
+            + [self.input_file]
+            + ffmpeg_params.split()
+            + [self.output_file]
+        )
+
+        log.debug(command)
+        return subprocess.call(command)

spotdl/handle.py

@@ -0,0 +1,276 @@
+import appdirs
+from spotdl import internals, const
+from logzero import logger as log
+
+import logging
+import yaml
+import argparse
+import mimetypes
+
+import os
+import sys
+
+
+_LOG_LEVELS_STR = ["INFO", "WARNING", "ERROR", "DEBUG"]
+
+default_conf = {
+    "spotify-downloader": {
+        "manual": False,
+        "no-metadata": False,
+        "avconv": False,
+        "folder": internals.get_music_dir(),
+        "overwrite": "prompt",
+        "input-ext": ".m4a",
+        "output-ext": ".mp3",
+        "trim-silence": False,
+        "download-only-metadata": False,
+        "dry-run": False,
+        "music-videos-only": False,
+        "no-spaces": False,
+        "file-format": "{artist} - {track_name}",
+        "search-format": "{artist} - {track_name} lyrics",
+        "youtube-api-key": None,
+        "skip": None,
+        "write-successful": None,
+        "log-level": "INFO",
+    }
+}
+
+
+def log_leveller(log_level_str):
+    loggin_levels = [logging.INFO, logging.WARNING, logging.ERROR, logging.DEBUG]
+    log_level_str_index = _LOG_LEVELS_STR.index(log_level_str)
+    loggin_level = loggin_levels[log_level_str_index]
+    return loggin_level
+
+
+def merge(default, config):
+    """ Override default dict with config dict. """
+    merged = default.copy()
+    merged.update(config)
+    return merged
+
+
+def get_config(config_file):
+    try:
+        with open(config_file, "r") as ymlfile:
+            cfg = yaml.load(ymlfile)
+    except FileNotFoundError:
+        log.info("Writing default configuration to {0}:".format(config_file))
+        with open(config_file, "w") as ymlfile:
+            yaml.dump(default_conf, ymlfile, default_flow_style=False)
+            cfg = default_conf
+
+        for line in yaml.dump(
+            default_conf["spotify-downloader"], default_flow_style=False
+        ).split("\n"):
+            if line.strip():
+                log.info(line.strip())
+        log.info(
+            "Please note that command line arguments have higher priority "
+            "than their equivalents in the configuration file"
+        )
+
+    return cfg["spotify-downloader"]
+
+
+def override_config(config_file, parser, raw_args=None):
+    """ Override default dict with config dict passed as comamnd line argument. """
+    config_file = os.path.realpath(config_file)
+    config = merge(default_conf["spotify-downloader"], get_config(config_file))
+    parser.set_defaults(**config)
+    return parser.parse_args(raw_args)
+
+
+def get_arguments(raw_args=None, to_group=True, to_merge=True):
+    parser = argparse.ArgumentParser(
+        description="Download and convert tracks from Spotify, Youtube etc.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    if to_merge:
+        config_dir = os.path.join(appdirs.user_config_dir(), "spotdl")
+        os.makedirs(config_dir, exist_ok=True)
+        config_file = os.path.join(config_dir, "config.yml")
+        config = merge(default_conf["spotify-downloader"], get_config(config_file))
+    else:
+        config = default_conf["spotify-downloader"]
+
+    if to_group:
+        group = parser.add_mutually_exclusive_group(required=True)
+
+        group.add_argument(
+            "-s", "--song", help="download track by spotify link or name"
+        )
+        group.add_argument("-l", "--list", help="download tracks from a file")
+        group.add_argument(
+            "-p",
+            "--playlist",
+            help="load tracks from playlist URL into <playlist_name>.txt",
+        )
+        group.add_argument(
+            "-b", "--album", help="load tracks from album URL into <album_name>.txt"
+        )
+        group.add_argument(
+            "-ab",
+            "--all-albums",
+            help="load all tracks from artist URL into <artist_name>.txt"
+        )
+        group.add_argument(
+            "-u",
+            "--username",
+            help="load tracks from user's playlist into <playlist_name>.txt",
+        )
+        group.add_argument(
+            "-V", "--version", help="show version and exit", action="store_true"
+        )
+
+    parser.add_argument(
+        '--write-m3u',
+        help="generate an .m3u playlist file with youtube links given "
+             "a text file containing tracks",
+        action='store_true'
+    )
+    parser.add_argument(
+        "-m",
+        "--manual",
+        default=config["manual"],
+        help="choose the track to download manually from a list " "of matching tracks",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-nm",
+        "--no-metadata",
+        default=config["no-metadata"],
+        help="do not embed metadata in tracks",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-a",
+        "--avconv",
+        default=config["avconv"],
+        help="use avconv for conversion (otherwise defaults to ffmpeg)",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-f",
+        "--folder",
+        default=os.path.abspath(config["folder"]),
+        help="path to folder where downloaded tracks will be stored in",
+    )
+    parser.add_argument(
+        "--overwrite",
+        default=config["overwrite"],
+        help="change the overwrite policy",
+        choices={"prompt", "force", "skip"},
+    )
+    parser.add_argument(
+        "-i",
+        "--input-ext",
+        default=config["input-ext"],
+        help="preferred input format .m4a or .webm (Opus)",
+        choices={".m4a", ".webm"},
+    )
+    parser.add_argument(
+        "-o",
+        "--output-ext",
+        default=config["output-ext"],
+        help="preferred output format .mp3, .m4a (AAC), .flac, etc.",
+    )
+    parser.add_argument(
+        "-ff",
+        "--file-format",
+        default=config["file-format"],
+        help="file format to save the downloaded track with, each tag "
+        "is surrounded by curly braces. Possible formats: "
+        "{}".format([internals.formats[x] for x in internals.formats]),
+    )
+    parser.add_argument(
+        "--trim-silence",
+        default=config["trim-silence"],
+        help="remove silence from the start of the audio",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-sf",
+        "--search-format",
+        default=config["search-format"],
+        help="search format to search for on YouTube, each tag "
+        "is surrounded by curly braces. Possible formats: "
+        "{}".format([internals.formats[x] for x in internals.formats]),
+    )
+    parser.add_argument(
+        "-dm",
+        "--download-only-metadata",
+        default=config["download-only-metadata"],
+        help="download tracks only whose metadata is found",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-d",
+        "--dry-run",
+        default=config["dry-run"],
+        help="show only track title and YouTube URL, and then skip "
+        "to the next track (if any)",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-mo",
+        "--music-videos-only",
+        default=config["music-videos-only"],
+        help="search only for music videos on Youtube (works only "
+        "when YouTube API key is set",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-ns",
+        "--no-spaces",
+        default=config["no-spaces"],
+        help="replace spaces with underscores in file names",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-ll",
+        "--log-level",
+        default=config["log-level"],
+        choices=_LOG_LEVELS_STR,
+        type=str.upper,
+        help="set log verbosity",
+    )
+    parser.add_argument(
+        "-yk",
+        "--youtube-api-key",
+        default=config["youtube-api-key"],
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "-sk",
+        "--skip",
+        default=config["skip"],
+        help="path to file containing tracks to skip",
+    )
+    parser.add_argument(
+        "-w",
+        "--write-successful",
+        default=config["write-successful"],
+        help="path to file to write successful tracks to",
+    )
+    parser.add_argument(
+        "-c", "--config", default=None, help="path to custom config.yml file"
+    )
+
+    parsed = parser.parse_args(raw_args)
+
+    if parsed.config is not None and to_merge:
+        parsed = override_config(parsed.config, parser)
+
+    if to_group and parsed.list and \
+            not mimetypes.MimeTypes().guess_type(parsed.list)[0] == "text/plain":
+        parser.error("{0} is not of a valid argument to --list, argument must be plain text file".format(parsed.list))
+
+    if parsed.write_m3u and not parsed.list:
+        parser.error('--write-m3u can only be used with --list')
+
+    parsed.log_level = log_leveller(parsed.log_level)
+
+    return parsed

spotdl/internals.py

@@ -0,0 +1,251 @@
+import os
+import sys
+from logzero import logger as log
+
+from spotdl import const
+
+try:
+    import winreg
+except ImportError:
+    pass
+
+try:
+    from slugify import SLUG_OK, slugify
+except ImportError:
+    log.error("Oops! `unicode-slugify` was not found.")
+    log.info("Please remove any other slugify library and install `unicode-slugify`")
+    sys.exit(5)
+
+formats = {
+    0: "track_name",
+    1: "artist",
+    2: "album",
+    3: "album_artist",
+    4: "genre",
+    5: "disc_number",
+    6: "duration",
+    7: "year",
+    8: "original_date",
+    9: "track_number",
+    10: "total_tracks",
+    11: "isrc",
+}
+
+
+def input_link(links):
+    """ Let the user input a choice. """
+    while True:
+        try:
+            log.info("Choose your number:")
+            the_chosen_one = int(input("> "))
+            if 1 <= the_chosen_one <= len(links):
+                return links[the_chosen_one - 1]
+            elif the_chosen_one == 0:
+                return None
+            else:
+                log.warning("Choose a valid number!")
+        except ValueError:
+            log.warning("Choose a valid number!")
+
+
+def trim_song(text_file):
+    """ Remove the first song from file. """
+    with open(text_file, "r") as file_in:
+        data = file_in.read().splitlines(True)
+    with open(text_file, "w") as file_out:
+        file_out.writelines(data[1:])
+    return data[0]
+
+
+def is_spotify(raw_song):
+    """ Check if the input song is a Spotify link. """
+    status = len(raw_song) == 22 and raw_song.replace(" ", "%20") == raw_song
+    status = status or raw_song.find("spotify") > -1
+    return status
+
+
+def is_youtube(raw_song):
+    """ Check if the input song is a YouTube link. """
+    status = len(raw_song) == 11 and raw_song.replace(" ", "%20") == raw_song
+    status = status and not raw_song.lower() == raw_song
+    status = status or "youtube.com/watch?v=" in raw_song
+    return status
+
+
+def format_string(string_format, tags, slugification=False, force_spaces=False):
+    """ Generate a string of the format '[artist] - [song]' for the given spotify song. """
+    format_tags = dict(formats)
+    format_tags[0] = tags["name"]
+    format_tags[1] = tags["artists"][0]["name"]
+    format_tags[2] = tags["album"]["name"]
+    format_tags[3] = tags["artists"][0]["name"]
+    format_tags[4] = tags["genre"]
+    format_tags[5] = tags["disc_number"]
+    format_tags[6] = tags["duration"]
+    format_tags[7] = tags["year"]
+    format_tags[8] = tags["release_date"]
+    format_tags[9] = tags["track_number"]
+    format_tags[10] = tags["total_tracks"]
+    format_tags[11] = tags["external_ids"]["isrc"]
+
+    format_tags_sanitized = {
+        k: sanitize_title(str(v), ok="'-_()[]{}") if slugification else str(v)
+        for k, v in format_tags.items()
+    }
+
+    for x in formats:
+        format_tag = "{" + formats[x] + "}"
+        string_format = string_format.replace(format_tag, format_tags_sanitized[x])
+
+    if const.args.no_spaces and not force_spaces:
+        string_format = string_format.replace(" ", "_")
+
+    return string_format
+
+
+def sanitize_title(title, ok="-_()[]{}"):
+    """ Generate filename of the song to be downloaded. """
+
+    if const.args.no_spaces:
+        title = title.replace(" ", "_")
+
+    # replace slashes with "-" to avoid folder creation errors
+    title = title.replace("/", "-").replace("\\", "-")
+
+    # slugify removes any special characters
+    title = slugify(title, ok=ok, lower=False, spaces=True)
+    return title
+
+
+def filter_path(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    for temp in os.listdir(path):
+        if temp.endswith(".temp"):
+            os.remove(os.path.join(path, temp))
+
+
+def videotime_from_seconds(time):
+    if time < 60:
+        return str(time)
+    if time < 3600:
+        return "{0}:{1:02}".format(time // 60, time % 60)
+
+    return "{0}:{1:02}:{2:02}".format((time // 60) // 60, (time // 60) % 60, time % 60)
+
+
+def get_sec(time_str):
+    if ":" in time_str:
+        splitter = ":"
+    elif "." in time_str:
+        splitter = "."
+    else:
+        raise ValueError(
+            "No expected character found in {} to split" "time values.".format(time_str)
+        )
+    v = time_str.split(splitter, 3)
+    v.reverse()
+    sec = 0
+    if len(v) > 0:  # seconds
+        sec += int(v[0])
+    if len(v) > 1:  # minutes
+        sec += int(v[1]) * 60
+    if len(v) > 2:  # hours
+        sec += int(v[2]) * 3600
+    return sec
+
+
+def extract_spotify_id(raw_string):
+    """
+    Returns a Spotify ID of a playlist, album, etc. after extracting
+    it from a given HTTP URL or Spotify URI.
+    """
+
+    if "/" in raw_string:
+        # Input string is an HTTP URL
+        if raw_string.endswith("/"):
+            raw_string = raw_string[:-1]
+        # We need to manually trim additional text from HTTP URLs
+        # We could skip this if https://github.com/plamere/spotipy/pull/324
+        # gets merged,
+        to_trim = raw_string.find("?")
+        if not to_trim == -1:
+            raw_string = raw_string[:to_trim]
+        splits = raw_string.split("/")
+    else:
+        # Input string is a Spotify URI
+        splits = raw_string.split(":")
+
+    spotify_id = splits[-1]
+
+    return spotify_id
+
+
+def get_unique_tracks(text_file):
+    """
+    Returns a list of unique tracks given a path to a
+    file containing tracks.
+    """
+
+    with open(text_file, "r") as listed:
+        # Read tracks into a list and remove any duplicates
+        lines = listed.read().splitlines()
+
+    # Remove blank and strip whitespaces from lines (if any)
+    lines = [line.strip() for line in lines if line.strip()]
+    lines = remove_duplicates(lines)
+
+    return lines
+
+
+# a hacky way to get user's localized music directory
+# (thanks @linusg, issue #203)
+def get_music_dir():
+    home = os.path.expanduser("~")
+
+    # On Linux, the localized folder names are the actual ones.
+    # It's a freedesktop standard though.
+    if sys.platform.startswith("linux"):
+        for file_item in (".config/user-dirs.dirs", "user-dirs.dirs"):
+            path = os.path.join(home, file_item)
+            if os.path.isfile(path):
+                with open(path, "r") as f:
+                    for line in f:
+                        if line.startswith("XDG_MUSIC_DIR"):
+                            return os.path.expandvars(
+                                line.strip().split("=")[1].strip('"')
+                            )
+
+    # Windows / Cygwin
+    # Queries registry for 'My Music' folder path (as this can be changed)
+    if "win" in sys.platform:
+        try:
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders",
+                0,
+                winreg.KEY_ALL_ACCESS,
+            )
+            return winreg.QueryValueEx(key, "My Music")[0]
+        except (FileNotFoundError, NameError):
+            pass
+
+    # On both Windows and macOS, the localized folder names you see in
+    # Explorer and Finder are actually in English on the file system.
+    # So, defaulting to C:\Users\<user>\Music or /Users/<user>/Music
+    # respectively is sufficient.
+    # On Linux, default to /home/<user>/Music if the above method failed.
+    return os.path.join(home, "Music")
+
+
+def remove_duplicates(tracks):
+    """
+    Removes duplicates from a list whilst preserving order.
+
+    We could directly call `set()` on the list but it changes
+    the order of elements.
+    """
+
+    local_set = set()
+    local_set_add = local_set.add
+    return [x for x in tracks if not (x in local_set or local_set_add(x))]

spotdl/metadata.py

@@ -0,0 +1,171 @@
+from mutagen.easyid3 import EasyID3
+from mutagen.id3 import ID3, TORY, TYER, TPUB, APIC, USLT, COMM
+from mutagen.mp4 import MP4, MP4Cover
+from mutagen.flac import Picture, FLAC
+from logzero import logger as log
+from spotdl.const import TAG_PRESET, M4A_TAG_PRESET
+
+import urllib.request
+
+
+def compare(music_file, metadata):
+    """Check if the input music file title matches the expected title."""
+    already_tagged = False
+    try:
+        if music_file.endswith(".mp3"):
+            audiofile = EasyID3(music_file)
+            already_tagged = audiofile["title"][0] == metadata["name"]
+        elif music_file.endswith(".m4a"):
+            audiofile = MP4(music_file)
+            already_tagged = audiofile["\xa9nam"][0] == metadata["name"]
+    except (KeyError, TypeError):
+        pass
+
+    return already_tagged
+
+
+def embed(music_file, meta_tags):
+    """ Embed metadata. """
+    embed = EmbedMetadata(music_file, meta_tags)
+    if music_file.endswith(".m4a"):
+        log.info("Applying metadata")
+        return embed.as_m4a()
+    elif music_file.endswith(".mp3"):
+        log.info("Applying metadata")
+        return embed.as_mp3()
+    elif music_file.endswith(".flac"):
+        log.info("Applying metadata")
+        return embed.as_flac()
+    else:
+        log.warning("Cannot embed metadata into given output extension")
+        return False
+
+
+class EmbedMetadata:
+    def __init__(self, music_file, meta_tags):
+        self.music_file = music_file
+        self.meta_tags = meta_tags
+
+    def as_mp3(self):
+        """ Embed metadata to MP3 files. """
+        music_file = self.music_file
+        meta_tags = self.meta_tags
+        # EasyID3 is fun to use ;)
+        # For supported easyid3 tags:
+        # https://github.com/quodlibet/mutagen/blob/master/mutagen/easyid3.py
+        # Check out somewhere at end of above linked file
+        audiofile = EasyID3(music_file)
+        self._embed_basic_metadata(audiofile, preset=TAG_PRESET)
+        audiofile["media"] = meta_tags["type"]
+        audiofile["author"] = meta_tags["artists"][0]["name"]
+        audiofile["lyricist"] = meta_tags["artists"][0]["name"]
+        audiofile["arranger"] = meta_tags["artists"][0]["name"]
+        audiofile["performer"] = meta_tags["artists"][0]["name"]
+        audiofile["website"] = meta_tags["external_urls"]["spotify"]
+        audiofile["length"] = str(meta_tags["duration"])
+        if meta_tags["publisher"]:
+            audiofile["encodedby"] = meta_tags["publisher"]
+        if meta_tags["external_ids"]["isrc"]:
+            audiofile["isrc"] = meta_tags["external_ids"]["isrc"]
+        audiofile.save(v2_version=3)
+
+        # For supported id3 tags:
+        # https://github.com/quodlibet/mutagen/blob/master/mutagen/id3/_frames.py
+        # Each class represents an id3 tag
+        audiofile = ID3(music_file)
+        audiofile["TORY"] = TORY(encoding=3, text=meta_tags["year"])
+        audiofile["TYER"] = TYER(encoding=3, text=meta_tags["year"])
+        if meta_tags["publisher"]:
+            audiofile["TPUB"] = TPUB(encoding=3, text=meta_tags["publisher"])
+        audiofile["COMM"] = COMM(encoding=3, text=meta_tags["external_urls"]["spotify"])
+        if meta_tags["lyrics"]:
+            audiofile["USLT"] = USLT(
+                encoding=3, desc=u"Lyrics", text=meta_tags["lyrics"]
+            )
+        try:
+            albumart = urllib.request.urlopen(meta_tags["album"]["images"][0]["url"])
+            audiofile["APIC"] = APIC(
+                encoding=3,
+                mime="image/jpeg",
+                type=3,
+                desc=u"Cover",
+                data=albumart.read(),
+            )
+            albumart.close()
+        except IndexError:
+            pass
+
+        audiofile.save(v2_version=3)
+        return True
+
+    def as_m4a(self):
+        """ Embed metadata to M4A files. """
+        music_file = self.music_file
+        meta_tags = self.meta_tags
+        audiofile = MP4(music_file)
+        self._embed_basic_metadata(audiofile, preset=M4A_TAG_PRESET)
+        audiofile[M4A_TAG_PRESET["year"]] = meta_tags["year"]
+        audiofile[M4A_TAG_PRESET["comment"]] = meta_tags["external_urls"]["spotify"]
+        if meta_tags["lyrics"]:
+            audiofile[M4A_TAG_PRESET["lyrics"]] = meta_tags["lyrics"]
+        try:
+            albumart = urllib.request.urlopen(meta_tags["album"]["images"][0]["url"])
+            audiofile[M4A_TAG_PRESET["albumart"]] = [
+                MP4Cover(albumart.read(), imageformat=MP4Cover.FORMAT_JPEG)
+            ]
+            albumart.close()
+        except IndexError:
+            pass
+
+        audiofile.save()
+        return True
+
+    def as_flac(self):
+        music_file = self.music_file
+        meta_tags = self.meta_tags
+        audiofile = FLAC(music_file)
+        self._embed_basic_metadata(audiofile)
+        audiofile["year"] = meta_tags["year"]
+        audiofile["comment"] = meta_tags["external_urls"]["spotify"]
+        if meta_tags["lyrics"]:
+            audiofile["lyrics"] = meta_tags["lyrics"]
+
+        image = Picture()
+        image.type = 3
+        image.desc = "Cover"
+        image.mime = "image/jpeg"
+        albumart = urllib.request.urlopen(meta_tags["album"]["images"][0]["url"])
+        image.data = albumart.read()
+        albumart.close()
+        audiofile.add_picture(image)
+
+        audiofile.save()
+        return True
+
+    def _embed_basic_metadata(self, audiofile, preset=TAG_PRESET):
+        meta_tags = self.meta_tags
+        audiofile[preset["artist"]] = meta_tags["artists"][0]["name"]
+        audiofile[preset["albumartist"]] = meta_tags["artists"][0]["name"]
+        audiofile[preset["album"]] = meta_tags["album"]["name"]
+        audiofile[preset["title"]] = meta_tags["name"]
+        audiofile[preset["date"]] = meta_tags["release_date"]
+        audiofile[preset["originaldate"]] = meta_tags["release_date"]
+        if meta_tags["genre"]:
+            audiofile[preset["genre"]] = meta_tags["genre"]
+        if meta_tags["copyright"]:
+            audiofile[preset["copyright"]] = meta_tags["copyright"]
+        if self.music_file.endswith(".flac"):
+            audiofile[preset["discnumber"]] = str(meta_tags["disc_number"])
+        else:
+            audiofile[preset["discnumber"]] = [(meta_tags["disc_number"], 0)]
+        if self.music_file.endswith(".flac"):
+            audiofile[preset["tracknumber"]] = str(meta_tags["track_number"])
+        else:
+            if preset["tracknumber"] == TAG_PRESET["tracknumber"]:
+                audiofile[preset["tracknumber"]] = "{}/{}".format(
+                    meta_tags["track_number"], meta_tags["total_tracks"]
+                )
+            else:
+                audiofile[preset["tracknumber"]] = [
+                    (meta_tags["track_number"], meta_tags["total_tracks"])
+                ]

spotdl/spotdl.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+# -*- coding: UTF-8 -*-
+from spotdl import __version__
+from spotdl import const
+from spotdl import handle
+from spotdl import metadata
+from spotdl import convert
+from spotdl import internals
+from spotdl import spotify_tools
+from spotdl import youtube_tools
+from logzero import logger as log
+from slugify import slugify
+import spotipy
+import urllib.request
+import logzero
+import os
+import sys
+import time
+import platform
+import pprint
+
+
+def check_exists(music_file, raw_song, meta_tags):
+    """ Check if the input song already exists in the given folder. """
+    log.debug(
+        "Cleaning any temp files and checking "
+        'if "{}" already exists'.format(music_file)
+    )
+    songs = os.listdir(const.args.folder)
+    for song in songs:
+        if song.endswith(".temp"):
+            os.remove(os.path.join(const.args.folder, song))
+            continue
+        # check if a song with the same name is already present in the given folder
+        if os.path.splitext(song)[0] == music_file:
+            log.debug('Found an already existing song: "{}"'.format(song))
+            if internals.is_spotify(raw_song):
+                # check if the already downloaded song has correct metadata
+                # if not, remove it and download again without prompt
+                already_tagged = metadata.compare(
+                    os.path.join(const.args.folder, song), meta_tags
+                )
+                log.debug(
+                    "Checking if it is already tagged correctly? {}", already_tagged
+                )
+                if not already_tagged:
+                    os.remove(os.path.join(const.args.folder, song))
+                    return False
+
+            log.warning('"{}" already exists'.format(song))
+            if const.args.overwrite == "prompt":
+                log.info(
+                    '"{}" has already been downloaded. '
+                    "Re-download? (y/N): ".format(song)
+                )
+                prompt = input("> ")
+                if prompt.lower() == "y":
+                    os.remove(os.path.join(const.args.folder, song))
+                    return False
+                else:
+                    return True
+            elif const.args.overwrite == "force":
+                os.remove(os.path.join(const.args.folder, song))
+                log.info('Overwriting "{}"'.format(song))
+                return False
+            elif const.args.overwrite == "skip":
+                log.info('Skipping "{}"'.format(song))
+                return True
+    return False
+
+
+def download_list(tracks_file, skip_file=None, write_successful_file=None):
+    """ Download all songs from the list. """
+
+    log.info("Checking and removing any duplicate tracks")
+    tracks = internals.get_unique_tracks(tracks_file)
+
+    # override file with unique tracks
+    with open(tracks_file, "w") as f:
+        f.write("\n".join(tracks))
+
+    # Remove tracks to skip from tracks list
+    if skip_file is not None:
+        skip_tracks = internals.get_unique_tracks(skip_file)
+        len_before = len(tracks)
+        tracks = [track for track in tracks if track not in skip_tracks]
+        log.info("Skipping {} tracks".format(len_before - len(tracks)))
+
+    log.info(u"Preparing to download {} songs".format(len(tracks)))
+    downloaded_songs = []
+
+    for number, raw_song in enumerate(tracks, 1):
+        print("")
+        try:
+            download_single(raw_song, number=number)
+        # token expires after 1 hour
+        except spotipy.client.SpotifyException:
+            # refresh token when it expires
+            log.debug("Token expired, generating new one and authorizing")
+            spotify_tools.refresh_token()
+            download_single(raw_song, number=number)
+        # detect network problems
+        except (urllib.request.URLError, TypeError, IOError) as e:
+            tracks.append(raw_song)
+            # remove the downloaded song from file
+            internals.trim_song(tracks_file)
+            # and append it at the end of file
+            with open(tracks_file, "a") as f:
+                f.write("\n" + raw_song)
+            log.exception(e)
+            log.warning("Failed to download song. Will retry after other songs\n")
+            # wait 0.5 sec to avoid infinite looping
+            time.sleep(0.5)
+            continue
+
+        downloaded_songs.append(raw_song)
+        # Add track to file of successful downloads
+        log.debug("Adding downloaded song to write successful file")
+        if write_successful_file is not None:
+            with open(write_successful_file, "a") as f:
+                f.write("\n" + raw_song)
+        log.debug("Removing downloaded song from tracks file")
+        internals.trim_song(tracks_file)
+
+    return downloaded_songs
+
+
+def download_single(raw_song, number=None):
+    """ Logic behind downloading a song. """
+    content, meta_tags = youtube_tools.match_video_and_metadata(raw_song)
+
+    if content is None:
+        log.debug("Found no matching video")
+        return
+
+    if const.args.download_only_metadata and meta_tags is None:
+        log.info("Found no metadata. Skipping the download")
+        return
+
+    # "[number]. [artist] - [song]" if downloading from list
+    # otherwise "[artist] - [song]"
+    youtube_title = youtube_tools.get_youtube_title(content, number)
+    log.info("{} ({})".format(youtube_title, content.watchv_url))
+
+    # generate file name of the song to download
+    songname = content.title
+
+    if meta_tags is not None:
+        refined_songname = internals.format_string(
+            const.args.file_format, meta_tags, slugification=True
+        )
+        log.debug(
+            'Refining songname from "{0}" to "{1}"'.format(songname, refined_songname)
+        )
+        if not refined_songname == " - ":
+            songname = refined_songname
+    else:
+        if not const.args.no_metadata:
+            log.warning("Could not find metadata")
+        songname = internals.sanitize_title(songname)
+
+    if const.args.dry_run:
+        return
+
+    if not check_exists(songname, raw_song, meta_tags):
+        # deal with file formats containing slashes to non-existent directories
+        songpath = os.path.join(const.args.folder, os.path.dirname(songname))
+        os.makedirs(songpath, exist_ok=True)
+        input_song = songname + const.args.input_ext
+        output_song = songname + const.args.output_ext
+        if youtube_tools.download_song(input_song, content):
+            print("")
+            try:
+                convert.song(
+                    input_song,
+                    output_song,
+                    const.args.folder,
+                    avconv=const.args.avconv,
+                    trim_silence=const.args.trim_silence,
+                )
+            except FileNotFoundError:
+                encoder = "avconv" if const.args.avconv else "ffmpeg"
+                log.warning("Could not find {0}, skipping conversion".format(encoder))
+                const.args.output_ext = const.args.input_ext
+                output_song = songname + const.args.output_ext
+
+            if not const.args.input_ext == const.args.output_ext:
+                os.remove(os.path.join(const.args.folder, input_song))
+            if not const.args.no_metadata and meta_tags is not None:
+                metadata.embed(os.path.join(const.args.folder, output_song), meta_tags)
+            return True
+
+
+def main():
+    const.args = handle.get_arguments()
+
+    if const.args.version:
+        print("spotdl {version}".format(version=__version__))
+        sys.exit()
+
+    internals.filter_path(const.args.folder)
+    youtube_tools.set_api_key()
+
+    logzero.setup_default_logger(formatter=const._formatter, level=const.args.log_level)
+
+    log.debug("Python version: {}".format(sys.version))
+    log.debug("Platform: {}".format(platform.platform()))
+    log.debug(pprint.pformat(const.args.__dict__))
+
+    try:
+        if const.args.song:
+            download_single(raw_song=const.args.song)
+        elif const.args.list:
+            if const.args.write_m3u:
+                youtube_tools.generate_m3u(track_file=const.args.list)
+            else:
+                download_list(
+                    tracks_file=const.args.list,
+                    skip_file=const.args.skip,
+                    write_successful_file=const.args.write_successful,
+                )
+        elif const.args.playlist:
+            spotify_tools.write_playlist(playlist_url=const.args.playlist)
+        elif const.args.album:
+            spotify_tools.write_album(album_url=const.args.album)
+        elif const.args.all_albums:
+            spotify_tools.write_all_albums_from_artist(artist_url=const.args.all_albums)
+        elif const.args.username:
+            spotify_tools.write_user_playlist(username=const.args.username)
+
+        # actually we don't necessarily need this, but yeah...
+        # explicit is better than implicit!
+        sys.exit(0)
+
+    except KeyboardInterrupt as e:
+        log.exception(e)
+        sys.exit(3)
+
+
+if __name__ == "__main__":
+    main()

spotdl/spotify_tools.py

@@ -0,0 +1,249 @@
+import spotipy
+import spotipy.oauth2 as oauth2
+import lyricwikia
+from logzero import logger as log
+
+from spotdl import internals
+
+from slugify import slugify
+from titlecase import titlecase
+import pprint
+import sys
+
+
+def generate_token():
+    """ Generate the token. Please respect these credentials :) """
+    credentials = oauth2.SpotifyClientCredentials(
+        client_id="4fe3fecfe5334023a1472516cc99d805",
+        client_secret="0f02b7c483c04257984695007a4a8d5c",
+    )
+    token = credentials.get_access_token()
+    return token
+
+
+def refresh_token():
+    """ Refresh expired token"""
+    global spotify
+    new_token = generate_token()
+    spotify = spotipy.Spotify(auth=new_token)
+
+# token is mandatory when using Spotify's API
+# https://developer.spotify.com/news-stories/2017/01/27/removing-unauthenticated-calls-to-the-web-api/
+token = generate_token()
+spotify = spotipy.Spotify(auth=token)
+
+
+def generate_metadata(raw_song):
+    """ Fetch a song's metadata from Spotify. """
+    if internals.is_spotify(raw_song):
+        # fetch track information directly if it is spotify link
+        log.debug("Fetching metadata for given track URL")
+        meta_tags = spotify.track(raw_song)
+    else:
+        # otherwise search on spotify and fetch information from first result
+        log.debug('Searching for "{}" on Spotify'.format(raw_song))
+        try:
+            meta_tags = spotify.search(raw_song, limit=1)["tracks"]["items"][0]
+        except IndexError:
+            return None
+    artist = spotify.artist(meta_tags["artists"][0]["id"])
+    album = spotify.album(meta_tags["album"]["id"])
+
+    try:
+        meta_tags[u"genre"] = titlecase(artist["genres"][0])
+    except IndexError:
+        meta_tags[u"genre"] = None
+    try:
+        meta_tags[u"copyright"] = album["copyrights"][0]["text"]
+    except IndexError:
+        meta_tags[u"copyright"] = None
+    try:
+        meta_tags[u"external_ids"][u"isrc"]
+    except KeyError:
+        meta_tags[u"external_ids"][u"isrc"] = None
+
+    meta_tags[u"release_date"] = album["release_date"]
+    meta_tags[u"publisher"] = album["label"]
+    meta_tags[u"total_tracks"] = album["tracks"]["total"]
+
+    log.debug("Fetching lyrics")
+
+    try:
+        meta_tags["lyrics"] = lyricwikia.get_lyrics(
+            meta_tags["artists"][0]["name"], meta_tags["name"]
+        )
+    except lyricwikia.LyricsNotFound:
+        meta_tags["lyrics"] = None
+
+    # Some sugar
+    meta_tags["year"], *_ = meta_tags["release_date"].split("-")
+    meta_tags["duration"] = meta_tags["duration_ms"] / 1000.0
+    # Remove unwanted parameters
+    del meta_tags["duration_ms"]
+    del meta_tags["available_markets"]
+    del meta_tags["album"]["available_markets"]
+
+    log.debug(pprint.pformat(meta_tags))
+    return meta_tags
+
+
+def write_user_playlist(username, text_file=None):
+    links = get_playlists(username=username)
+    playlist = internals.input_link(links)
+    return write_playlist(playlist, text_file)
+
+
+def get_playlists(username):
+    """ Fetch user playlists when using the -u option. """
+    playlists = spotify.user_playlists(username)
+    links = []
+    check = 1
+
+    while True:
+        for playlist in playlists["items"]:
+            # in rare cases, playlists may not be found, so playlists['next']
+            # is None. Skip these. Also see Issue #91.
+            if playlist["name"] is not None:
+                log.info(
+                    u"{0:>5}. {1:<30}  ({2} tracks)".format(
+                        check, playlist["name"], playlist["tracks"]["total"]
+                    )
+                )
+                playlist_url = playlist["external_urls"]["spotify"]
+                log.debug(playlist_url)
+                links.append(playlist_url)
+                check += 1
+        if playlists["next"]:
+            playlists = spotify.next(playlists)
+        else:
+            break
+
+    return links
+
+
+def fetch_playlist(playlist):
+    try:
+        playlist_id = internals.extract_spotify_id(playlist)
+    except IndexError:
+        # Wrong format, in either case
+        log.error("The provided playlist URL is not in a recognized format!")
+        sys.exit(10)
+    try:
+        results = spotify.user_playlist(
+            user=None, playlist_id=playlist_id, fields="tracks,next,name"
+        )
+    except spotipy.client.SpotifyException:
+        log.error("Unable to find playlist")
+        log.info("Make sure the playlist is set to publicly visible and then try again")
+        sys.exit(11)
+
+    return results
+
+
+def write_playlist(playlist_url, text_file=None):
+    playlist = fetch_playlist(playlist_url)
+    tracks = playlist["tracks"]
+    if not text_file:
+        text_file = u"{0}.txt".format(slugify(playlist["name"], ok="-_()[]{}"))
+    return write_tracks(tracks, text_file)
+
+
+def fetch_album(album):
+    album_id = internals.extract_spotify_id(album)
+    album = spotify.album(album_id)
+    return album
+
+
+def fetch_album_from_artist(artist_url, album_type="album"):
+    """
+    This funcction returns all the albums from a give artist_url using the US
+    market
+    :param artist_url - spotify artist url
+    :param album_type - the type of album to fetch (ex: single) the default is
+                        a standard album
+    :param return - the album from the artist
+    """
+
+    # fetching artist's albums limitting the results to the US to avoid duplicate
+    # albums from multiple markets
+    artist_id = internals.extract_spotify_id(artist_url)
+    results = spotify.artist_albums(artist_id, album_type=album_type, country="US")
+
+    albums = results["items"]
+
+    # indexing all pages of results
+    while results["next"]:
+        results = spotify.next(results)
+        albums.extend(results["items"])
+
+    return albums
+
+
+def write_all_albums_from_artist(artist_url, text_file=None):
+    """
+    This function gets all albums from an artist and writes it to a file in the
+    current working directory called [ARTIST].txt, where [ARTIST] is the artist
+    of the album
+    :param artist_url - spotify artist url
+    :param text_file - file to write albums to
+    """
+
+    album_base_url = "https://open.spotify.com/album/"
+
+    # fetching all default albums
+    albums = fetch_album_from_artist(artist_url)
+
+    # if no file if given, the default save file is in the current working
+    # directory with the name of the artist
+    if text_file is None:
+        text_file = albums[0]["artists"][0]["name"] + ".txt"
+
+    for album in albums:
+        # logging album name
+        log.info("Fetching album: " + album["name"])
+        write_album(album_base_url + album["id"], text_file=text_file)
+
+    # fetching all single albums
+    singles = fetch_album_from_artist(artist_url, album_type="single")
+
+    for single in singles:
+        log.info("Fetching single: " + single["name"])
+        write_album(album_base_url + single["id"], text_file=text_file)
+
+
+def write_album(album_url, text_file=None):
+    album = fetch_album(album_url)
+    tracks = spotify.album_tracks(album["id"])
+    if not text_file:
+        text_file = u"{0}.txt".format(slugify(album["name"], ok="-_()[]{}"))
+    return write_tracks(tracks, text_file)
+
+
+def write_tracks(tracks, text_file):
+    log.info(u"Writing {0} tracks to {1}".format(tracks["total"], text_file))
+    track_urls = []
+    with open(text_file, "a") as file_out:
+        while True:
+            for item in tracks["items"]:
+                if "track" in item:
+                    track = item["track"]
+                else:
+                    track = item
+                try:
+                    track_url = track["external_urls"]["spotify"]
+                    log.debug(track_url)
+                    file_out.write(track_url + "\n")
+                    track_urls.append(track_url)
+                except KeyError:
+                    log.warning(
+                        u"Skipping track {0} by {1} (local only?)".format(
+                            track["name"], track["artists"][0]["name"]
+                        )
+                    )
+            # 1 page = 50 results
+            # check if there are more pages
+            if tracks["next"]:
+                tracks = spotify.next(tracks)
+            else:
+                break
+    return track_urls

spotdl/youtube_tools.py

@@ -0,0 +1,322 @@
+from bs4 import BeautifulSoup
+import urllib
+import pafy
+from slugify import slugify
+from logzero import logger as log
+
+from spotdl import spotify_tools
+from spotdl import internals
+from spotdl import const
+
+import os
+import pprint
+
+# Fix download speed throttle on short duration tracks
+# Read more on mps-youtube/pafy#199
+pafy.g.opener.addheaders.append(("Range", "bytes=0-"))
+
+
+def set_api_key():
+    if const.args.youtube_api_key:
+        key = const.args.youtube_api_key
+    else:
+        # Please respect this YouTube token :)
+        key = "AIzaSyC6cEeKlxtOPybk9sEe5ksFN5sB-7wzYp0"
+    pafy.set_api_key(key)
+
+
+def go_pafy(raw_song, meta_tags=None):
+    """ Parse track from YouTube. """
+    if internals.is_youtube(raw_song):
+        track_info = pafy.new(raw_song)
+    else:
+        track_url = generate_youtube_url(raw_song, meta_tags)
+
+        if track_url:
+            track_info = pafy.new(track_url)
+        else:
+            track_info = None
+
+    return track_info
+
+
+def match_video_and_metadata(track, force_pafy=True):
+    """ Get and match track data from YouTube and Spotify. """
+    meta_tags = None
+
+    if internals.is_youtube(track):
+        log.debug("Input song is a YouTube URL")
+        content = go_pafy(track, meta_tags=None)
+        track = slugify(content.title).replace("-", " ")
+        if not const.args.no_metadata:
+            meta_tags = spotify_tools.generate_metadata(track)
+    else:
+        if not const.args.no_metadata:
+            meta_tags = spotify_tools.generate_metadata(track)
+        if force_pafy:
+            content = go_pafy(track, meta_tags)
+        else:
+            content = None
+    return content, meta_tags
+
+
+def get_youtube_title(content, number=None):
+    """ Get the YouTube video's title. """
+    title = content.title
+    if number:
+        return "{0}. {1}".format(number, title)
+    else:
+        return title
+
+
+def generate_m3u(track_file):
+    tracks = internals.get_unique_tracks(track_file)
+    target_file = "{}.m3u".format(track_file.split(".")[0])
+    total_tracks = len(tracks)
+    log.info("Generating {0} from {1} YouTube URLs".format(target_file, total_tracks))
+    with open(target_file, "w") as output_file:
+        output_file.write("#EXTM3U\n\n")
+    for n, track in enumerate(tracks, 1):
+        content, _ = match_video_and_metadata(track)
+        if content is None:
+            log.warning("Skipping {}".format(track))
+        else:
+            log.info(
+                "Matched track {0}/{1} ({2})".format(
+                    n, total_tracks, content.watchv_url
+                )
+            )
+            log.debug(track)
+            m3u_key = "#EXTINF:{duration},{title}\n{youtube_url}\n".format(
+                duration=internals.get_sec(content.duration),
+                title=content.title,
+                youtube_url=content.watchv_url,
+            )
+            log.debug(m3u_key)
+            with open(target_file, "a") as output_file:
+                output_file.write(m3u_key)
+
+
+def download_song(file_name, content):
+    """ Download the audio file from YouTube. """
+    _, extension = os.path.splitext(file_name)
+    if extension in (".webm", ".m4a"):
+        link = content.getbestaudio(preftype=extension[1:])
+    else:
+        log.debug("No audio streams available for {} type".format(extension))
+        return False
+
+    if link:
+        log.debug("Downloading from URL: " + link.url)
+        filepath = os.path.join(const.args.folder, file_name)
+        log.debug("Saving to: " + filepath)
+        link.download(filepath=filepath)
+        return True
+    else:
+        log.debug("No audio streams available")
+        return False
+
+
+def generate_search_url(query):
+    """ Generate YouTube search URL for the given song. """
+    # urllib.request.quote() encodes string with special characters
+    quoted_query = urllib.request.quote(query)
+    # Special YouTube URL filter to search only for videos
+    url = "https://www.youtube.com/results?sp=EgIQAQ%253D%253D&q={0}".format(
+        quoted_query
+    )
+    return url
+
+
+def is_video(result):
+    # ensure result is not a channel
+    not_video = (
+        result.find("channel") is not None
+        or "yt-lockup-channel" in result.parent.attrs["class"]
+        or "yt-lockup-channel" in result.attrs["class"]
+    )
+
+    # ensure result is not a mix/playlist
+    not_video = not_video or "yt-lockup-playlist" in result.parent.attrs["class"]
+
+    # ensure video result is not an advertisement
+    not_video = not_video or result.find("googleads") is not None
+
+    video = not not_video
+    return video
+
+
+def generate_youtube_url(raw_song, meta_tags):
+    url_fetch = GenerateYouTubeURL(raw_song, meta_tags)
+    if const.args.youtube_api_key:
+        url = url_fetch.api()
+    else:
+        url = url_fetch.scrape()
+    return url
+
+
+class GenerateYouTubeURL:
+    def __init__(self, raw_song, meta_tags):
+        self.raw_song = raw_song
+        self.meta_tags = meta_tags
+
+        if meta_tags is None:
+            self.search_query = raw_song
+        else:
+            self.search_query = internals.format_string(
+                const.args.search_format, meta_tags, force_spaces=True
+            )
+
+    def _best_match(self, videos):
+        """ Select the best matching video from a list of videos. """
+        if const.args.manual:
+            log.info(self.raw_song)
+            log.info("0. Skip downloading this song.\n")
+            # fetch all video links on first page on YouTube
+            for i, v in enumerate(videos):
+                log.info(
+                    u"{0}. {1} {2} {3}".format(
+                        i + 1,
+                        v["title"],
+                        v["videotime"],
+                        "http://youtube.com/watch?v=" + v["link"],
+                    )
+                )
+            # let user select the song to download
+            result = internals.input_link(videos)
+            if result is None:
+                return None
+        else:
+            if not self.meta_tags:
+                # if the metadata could not be acquired, take the first result
+                # from Youtube because the proper song length is unknown
+                result = videos[0]
+                log.debug(
+                    "Since no metadata found on Spotify, going with the first result"
+                )
+            else:
+                # filter out videos that do not have a similar length to the Spotify song
+                duration_tolerance = 10
+                max_duration_tolerance = 20
+                possible_videos_by_duration = []
+
+                # start with a reasonable duration_tolerance, and increment duration_tolerance
+                # until one of the Youtube results falls within the correct duration or
+                # the duration_tolerance has reached the max_duration_tolerance
+                while len(possible_videos_by_duration) == 0:
+                    possible_videos_by_duration = list(
+                        filter(
+                            lambda x: abs(x["seconds"] - self.meta_tags["duration"])
+                            <= duration_tolerance,
+                            videos,
+                        )
+                    )
+                    duration_tolerance += 1
+                    if duration_tolerance > max_duration_tolerance:
+                        log.error(
+                            "{0} by {1} was not found.".format(
+                                self.meta_tags["name"],
+                                self.meta_tags["artists"][0]["name"],
+                            )
+                        )
+                        return None
+
+                result = possible_videos_by_duration[0]
+
+        if result:
+            url = "http://youtube.com/watch?v={0}".format(result["link"])
+        else:
+            url = None
+
+        return url
+
+    def scrape(self, bestmatch=True, tries_remaining=5):
+        """ Search and scrape YouTube to return a list of matching videos. """
+
+        # prevents an infinite loop but allows for a few retries
+        if tries_remaining == 0:
+            log.debug("No tries left. I quit.")
+            return
+
+        search_url = generate_search_url(self.search_query)
+        log.debug("Opening URL: {0}".format(search_url))
+
+        item = urllib.request.urlopen(search_url).read()
+        items_parse = BeautifulSoup(item, "html.parser")
+
+        videos = []
+        for x in items_parse.find_all(
+            "div", {"class": "yt-lockup-dismissable yt-uix-tile"}
+        ):
+
+            if not is_video(x):
+                continue
+
+            y = x.find("div", class_="yt-lockup-content")
+            link = y.find("a")["href"][-11:]
+            title = y.find("a")["title"]
+
+            try:
+                videotime = x.find("span", class_="video-time").get_text()
+            except AttributeError:
+                log.debug("Could not find video duration on YouTube, retrying..")
+                return self.scrape(
+                    bestmatch=bestmatch, tries_remaining=tries_remaining - 1
+                )
+
+            youtubedetails = {
+                "link": link,
+                "title": title,
+                "videotime": videotime,
+                "seconds": internals.get_sec(videotime),
+            }
+            videos.append(youtubedetails)
+
+        if bestmatch:
+            return self._best_match(videos)
+
+        return videos
+
+    def api(self, bestmatch=True):
+        """ Use YouTube API to search and return a list of matching videos. """
+
+        query = {"part": "snippet", "maxResults": 50, "type": "video"}
+
+        if const.args.music_videos_only:
+            query["videoCategoryId"] = "10"
+
+        if not self.meta_tags:
+            song = self.raw_song
+            query["q"] = song
+        else:
+            query["q"] = self.search_query
+        log.debug("query: {0}".format(query))
+
+        data = pafy.call_gdata("search", query)
+        data["items"] = list(
+            filter(lambda x: x["id"].get("videoId") is not None, data["items"])
+        )
+        query_results = {
+            "part": "contentDetails,snippet,statistics",
+            "maxResults": 50,
+            "id": ",".join(i["id"]["videoId"] for i in data["items"]),
+        }
+        log.debug("query_results: {0}".format(query_results))
+
+        vdata = pafy.call_gdata("videos", query_results)
+
+        videos = []
+        for x in vdata["items"]:
+            duration_s = pafy.playlist.parseISO8591(x["contentDetails"]["duration"])
+            youtubedetails = {
+                "link": x["id"],
+                "title": x["snippet"]["title"],
+                "videotime": internals.videotime_from_seconds(duration_s),
+                "seconds": duration_s,
+            }
+            videos.append(youtubedetails)
+
+        if bestmatch:
+            return self._best_match(videos)
+
+        return videos

test/loader.py

@@ -0,0 +1,16 @@
+from spotdl import const
+from spotdl import handle
+from spotdl import spotdl
+
+import pytest
+
+
+def load_defaults():
+    const.args = handle.get_arguments(raw_args="", to_group=False, to_merge=False)
+    const.args.overwrite = "skip"
+    const.args.log_level = 10
+
+    spotdl.args = const.args
+    spotdl.log = const.logzero.setup_logger(
+        formatter=const._formatter, level=const.args.log_level
+    )

test/test_dry_run.py

@@ -0,0 +1,20 @@
+import os
+
+from spotdl import const
+from spotdl import spotdl
+
+import loader
+
+loader.load_defaults()
+
+TRACK_URL = "http://open.spotify.com/track/0JlS7BXXD07hRmevDnbPDU"
+
+
+def test_dry_download_list(tmpdir):
+    const.args.folder = str(tmpdir)
+    const.args.dry_run = True
+    file_path = os.path.join(const.args.folder, "test_list.txt")
+    with open(file_path, "w") as f:
+        f.write(TRACK_URL)
+    downloaded_song, *_ = spotdl.download_list(file_path)
+    assert downloaded_song == TRACK_URL

test/test_handle.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import argparse
+
+from spotdl import handle
+
+import pytest
+import yaml
+
+
+def test_error_m3u_without_list():
+    with pytest.raises(SystemExit):
+        handle.get_arguments(raw_args=('-s cool song', '--write-m3u',),
+                             to_group=True)
+
+
+def test_m3u_with_list():
+    handle.get_arguments(raw_args=('-l cool_list.txt', '--write-m3u',),
+                         to_group=True)
+
+
+def test_log_str_to_int():
+    expect_levels = [20, 30, 40, 10]
+    levels = [handle.log_leveller(level) for level in handle._LOG_LEVELS_STR]
+    assert levels == expect_levels
+
+
+class TestConfig:
+    def test_default_config(self, tmpdir):
+        expect_config = handle.default_conf["spotify-downloader"]
+        global config_path
+        config_path = os.path.join(str(tmpdir), "config.yml")
+        config = handle.get_config(config_path)
+        assert config == expect_config
+
+    def test_modified_config(self):
+        global modified_config
+        modified_config = dict(handle.default_conf)
+        modified_config["spotify-downloader"]["file-format"] = "just_a_test"
+        merged_config = handle.merge(handle.default_conf, modified_config)
+        assert merged_config == modified_config
+
+    def test_custom_config_path(self, tmpdir):
+        parser = argparse.ArgumentParser()
+        with open(config_path, "w") as config_file:
+            yaml.dump(modified_config, config_file, default_flow_style=False)
+        overridden_config = handle.override_config(config_path, parser, raw_args="")
+        modified_values = [
+            str(value) for value in modified_config["spotify-downloader"].values()
+        ]
+        overridden_config.folder = os.path.realpath(overridden_config.folder)
+        overridden_values = [
+            str(value) for value in overridden_config.__dict__.values()
+        ]
+        assert sorted(overridden_values) == sorted(modified_values)
+
+
+def test_grouped_arguments(tmpdir):
+    sys.path[0] = str(tmpdir)
+    with pytest.raises(SystemExit):
+        handle.get_arguments(to_group=True, to_merge=True)

test/test_internals.py

@@ -0,0 +1,172 @@
+import sys
+import os
+import subprocess
+
+from spotdl import internals
+
+import pytest
+
+
+DUPLICATE_TRACKS_TEST_TABLE = [
+    (
+        (
+            "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",
+            "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",
+        ),
+        ("https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",),
+    ),
+    (
+        (
+            "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",
+            "",
+            "https://open.spotify.com/track/3SipFlNddvL0XNZRLXvdZD",
+        ),
+        (
+            "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",
+            "https://open.spotify.com/track/3SipFlNddvL0XNZRLXvdZD",
+        ),
+    ),
+    (
+        (
+            "ncs fade",
+            "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ",
+            "",
+            "ncs fade",
+        ),
+        ("ncs fade", "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ"),
+    ),
+    (
+        ("ncs spectre ", "  https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ", ""),
+        ("ncs spectre", "https://open.spotify.com/track/2DGa7iaidT5s0qnINlwMjJ"),
+    ),
+]
+
+STRING_IDS_TEST_TABLE = [
+    (
+        "https://open.spotify.com/artist/1feoGrmmD8QmNqtK2Gdwy8?si=_cVm-FBRQmi7VWML7E49Ig",
+        "1feoGrmmD8QmNqtK2Gdwy8",
+    ),
+    (
+        "https://open.spotify.com/artist/1feoGrmmD8QmNqtK2Gdwy8",
+        "1feoGrmmD8QmNqtK2Gdwy8",
+    ),
+    ("spotify:artist:1feoGrmmD8QmNqtK2Gdwy8", "1feoGrmmD8QmNqtK2Gdwy8"),
+    (
+        "https://open.spotify.com/album/1d1l3UkeAjtM7kVTDyR8yp?si=LkVQLJGGT--Lh8BWM4MGvg",
+        "1d1l3UkeAjtM7kVTDyR8yp",
+    ),
+    ("https://open.spotify.com/album/1d1l3UkeAjtM7kVTDyR8yp", "1d1l3UkeAjtM7kVTDyR8yp"),
+    ("spotify:album:1d1l3UkeAjtM7kVTDyR8yp", "1d1l3UkeAjtM7kVTDyR8yp"),
+    (
+        "https://open.spotify.com/user/5kkyy50uu8btnagp30pobxz2f/playlist/3SFKRjUXm0IMQJMkEgPHeY?si=8Da4gbE2T9qMkd8Upg22ZA",
+        "3SFKRjUXm0IMQJMkEgPHeY",
+    ),
+    (
+        "https://open.spotify.com/playlist/3SFKRjUXm0IMQJMkEgPHeY?si=8Da4gbE2T9qMkd8Upg22ZA",
+        "3SFKRjUXm0IMQJMkEgPHeY",
+    ),
+    (
+        "https://open.spotify.com/playlist/3SFKRjUXm0IMQJMkEgPHeY",
+        "3SFKRjUXm0IMQJMkEgPHeY",
+    ),
+    (
+        "spotify:user:5kkyy50uu8btnagp30pobxz2f:playlist:3SFKRjUXm0IMQJMkEgPHeY",
+        "3SFKRjUXm0IMQJMkEgPHeY",
+    ),
+    (
+        "https://open.spotify.com/user/uqlakumu7wslkoen46s5bulq0",
+        "uqlakumu7wslkoen46s5bulq0",
+    ),
+]
+
+
+def test_default_music_directory():
+    if sys.platform.startswith("linux"):
+        output = subprocess.check_output(["xdg-user-dir", "MUSIC"])
+        expect_directory = output.decode("utf-8").rstrip()
+    else:
+        home = os.path.expanduser("~")
+        expect_directory = os.path.join(home, "Music")
+
+    directory = internals.get_music_dir()
+    assert directory == expect_directory
+
+
+class TestPathFilterer:
+    def test_create_directory(self, tmpdir):
+        expect_path = True
+        global folder_path
+        folder_path = os.path.join(str(tmpdir), "filter_this_folder")
+        internals.filter_path(folder_path)
+        is_path = os.path.isdir(folder_path)
+        assert is_path == expect_path
+
+    def test_remove_temp_files(self, tmpdir):
+        expect_file = False
+        file_path = os.path.join(folder_path, "pesky_file.temp")
+        open(file_path, "a")
+        internals.filter_path(folder_path)
+        is_file = os.path.isfile(file_path)
+        assert is_file == expect_file
+
+
+class TestVideoTimeFromSeconds:
+    def test_from_seconds(self):
+        expect_duration = "35"
+        duration = internals.videotime_from_seconds(35)
+        assert duration == expect_duration
+
+    def test_from_minutes(self):
+        expect_duration = "2:38"
+        duration = internals.videotime_from_seconds(158)
+        assert duration == expect_duration
+
+    def test_from_hours(self):
+        expect_duration = "1:16:02"
+        duration = internals.videotime_from_seconds(4562)
+        assert duration == expect_duration
+
+
+class TestGetSeconds:
+    def test_from_seconds(self):
+        expect_secs = 45
+        secs = internals.get_sec("0:45")
+        assert secs == expect_secs
+        secs = internals.get_sec("0.45")
+        assert secs == expect_secs
+
+    def test_from_minutes(self):
+        expect_secs = 213
+        secs = internals.get_sec("3.33")
+        assert secs == expect_secs
+        secs = internals.get_sec("3:33")
+        assert secs == expect_secs
+
+    def test_from_hours(self):
+        expect_secs = 5405
+        secs = internals.get_sec("1.30.05")
+        assert secs == expect_secs
+        secs = internals.get_sec("1:30:05")
+        assert secs == expect_secs
+
+    def test_raise_error(self):
+        with pytest.raises(ValueError):
+            internals.get_sec("10*05")
+        with pytest.raises(ValueError):
+            internals.get_sec("02,28,46")
+
+
+@pytest.mark.parametrize("duplicates, expected", DUPLICATE_TRACKS_TEST_TABLE)
+def test_get_unique_tracks(tmpdir, duplicates, expected):
+    file_path = os.path.join(str(tmpdir), "test_duplicates.txt")
+    with open(file_path, "w") as f:
+        f.write("\n".join(duplicates))
+
+    unique_tracks = internals.get_unique_tracks(file_path)
+    assert tuple(unique_tracks) == expected
+
+
+@pytest.mark.parametrize("input_str, expected_spotify_id", STRING_IDS_TEST_TABLE)
+def test_extract_spotify_id(input_str, expected_spotify_id):
+    spotify_id = internals.extract_spotify_id(input_str)
+    assert spotify_id == expected_spotify_id

test/test_list.py

@@ -0,0 +1,90 @@
+import builtins
+import os
+
+from spotdl import spotify_tools
+from spotdl import youtube_tools
+from spotdl import const
+from spotdl import spotdl
+
+import loader
+
+
+USERNAME = "uqlakumu7wslkoen46s5bulq0"
+PLAYLIST_URL = "https://open.spotify.com/playlist/0fWBMhGh38y0wsYWwmM9Kt"
+ALBUM_URL = "https://open.spotify.com/album/499J8bIsEnU7DSrosFDJJg"
+ARTIST_URL = "https://open.spotify.com/artist/4dpARuHxo51G3z768sgnrY"
+
+loader.load_defaults()
+
+
+def test_user_playlists(tmpdir, monkeypatch):
+    expect_tracks = 17
+    text_file = os.path.join(str(tmpdir), "test_us.txt")
+    monkeypatch.setattr("builtins.input", lambda x: 1)
+    spotify_tools.write_user_playlist(USERNAME, text_file)
+    with open(text_file, "r") as f:
+        tracks = len(f.readlines())
+    assert tracks == expect_tracks
+
+
+def test_playlist(tmpdir):
+    expect_tracks = 14
+    text_file = os.path.join(str(tmpdir), "test_pl.txt")
+    spotify_tools.write_playlist(PLAYLIST_URL, text_file)
+    with open(text_file, "r") as f:
+        tracks = len(f.readlines())
+    assert tracks == expect_tracks
+
+
+def test_album(tmpdir):
+    expect_tracks = 15
+    text_file = os.path.join(str(tmpdir), "test_al.txt")
+    spotify_tools.write_album(ALBUM_URL, text_file)
+    with open(text_file, "r") as f:
+        tracks = len(f.readlines())
+    assert tracks == expect_tracks
+
+
+def test_m3u(tmpdir):
+    expect_m3u = (
+        "#EXTM3U\n\n"
+        "#EXTINF:31,Eminem - 01 - Eminem - Curtains Up (Skit)\n"
+        "http://www.youtube.com/watch?v=qk13SFlwG9A\n"
+        "#EXTINF:226,Alan Walker - Spectre [NCS Release]\n"
+        "http://www.youtube.com/watch?v=AOeY-nDp7hI\n"
+    )
+    m3u_track_file = os.path.join(str(tmpdir), "m3u_test.txt")
+    with open(m3u_track_file, "w") as track_file:
+        track_file.write("\nhttps://open.spotify.com/track/2nT5m433s95hvYJH4S7ont")
+        track_file.write("\nhttp://www.youtube.com/watch?v=AOeY-nDp7hI")
+    youtube_tools.generate_m3u(m3u_track_file)
+    m3u_file = "{}.m3u".format(m3u_track_file.split(".")[0])
+    with open(m3u_file, "r") as m3u_in:
+        m3u = m3u_in.readlines()
+    assert "".join(m3u) == expect_m3u
+
+
+def test_all_albums(tmpdir):
+    # current number of tracks on spotify since as of 10/10/2018
+    # in US market only
+    expect_tracks = 49
+    global text_file
+    text_file = os.path.join(str(tmpdir), "test_ab.txt")
+    spotify_tools.write_all_albums_from_artist(ARTIST_URL, text_file)
+    with open(text_file, "r") as f:
+        tracks = len(f.readlines())
+    assert tracks == expect_tracks
+
+
+def test_trim():
+    with open(text_file, "r") as track_file:
+        tracks = track_file.readlines()
+
+    expect_number = len(tracks) - 1
+    expect_track = tracks[0]
+    track = spotdl.internals.trim_song(text_file)
+
+    with open(text_file, "r") as track_file:
+        number = len(track_file.readlines())
+
+    assert expect_number == number and expect_track == track

test/test_single.py

@@ -1,80 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-import spotdl
-import os
-
-raw_song = 'http://open.spotify.com/track/0JlS7BXXD07hRmevDnbPDU'
-
-for x in os.listdir('Music'):
-    os.remove('Music/' + x)
-
-
-def test_spotify_title():
-    expect_title = 'David André Østby - Intro'
-    title = spotdl.generate_songname(raw_song)
-    assert title == expect_title
-
-
-def test_youtube_url():
-    expect_url = 'youtube.com/watch?v=rg1wfcty0BA'
-    url = spotdl.generate_youtube_url(raw_song)
-    assert url == expect_url
-
-
-def test_youtube_title():
-    expect_title = 'Intro - David André Østby'
-    content = spotdl.go_pafy(raw_song)
-    title = spotdl.get_youtube_title(content)
-    assert title == expect_title
-
-
-def test_check_exists():
-    expect_check = False
-    content = spotdl.go_pafy(raw_song)
-    music_file = spotdl.misc.generate_filename(content.title)
-    music_file = spotdl.misc.fix_decoding(music_file)
-    check = spotdl.check_exists(music_file, raw_song, islist=True)
-    assert check == expect_check
-
-
-def test_download():
-    expect_download = True
-    content = spotdl.go_pafy(raw_song)
-    download = spotdl.download_song(content)
-    assert download == expect_download
-
-
-def test_convert():
-    # exit code 0 = success
-    expect_convert = 0
-    content = spotdl.go_pafy(raw_song)
-    music_file = spotdl.misc.generate_filename(content.title)
-    music_file = spotdl.misc.fix_decoding(music_file)
-    input_song = music_file + spotdl.args.input_ext
-    output_song = music_file + spotdl.args.output_ext
-    convert = spotdl.convert.song(input_song, output_song)
-    assert convert == expect_convert
-
-
-def test_metadata():
-    expect_metadata = True
-    content = spotdl.go_pafy(raw_song)
-    music_file = spotdl.misc.generate_filename(content.title)
-    music_file = spotdl.misc.fix_decoding(music_file)
-    meta_tags = spotdl.generate_metadata(raw_song)
-    output_song = music_file + spotdl.args.output_ext
-    metadata_output = spotdl.metadata.embed(output_song, meta_tags)
-    input_song = music_file + spotdl.args.input_ext
-    metadata_input = spotdl.metadata.embed(input_song, meta_tags)
-    assert metadata_output == (metadata_input == expect_metadata)
-
-
-def test_check_exists2():
-    expect_check = True
-    content = spotdl.go_pafy(raw_song)
-    music_file = spotdl.misc.generate_filename(content.title)
-    music_file = spotdl.misc.fix_decoding(music_file)
-    input_song = music_file + spotdl.args.input_ext
-    os.remove('Music/' + spotdl.misc.fix_encoding(input_song))
-    check = spotdl.check_exists(music_file, raw_song, islist=True)
-    assert check == expect_check

test/test_username.py

@@ -1,57 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-import spotdl
-
-username = 'alex'
-
-
-def test_user():
-    expect_playlists = 7
-    playlists = spotdl.spotify.user_playlists(username)
-    playlists = len(playlists['items'])
-    assert playlists == expect_playlists
-
-
-def test_playlist():
-    expect_tracks = 14
-    playlist = spotdl.spotify.user_playlists(username)['items'][0]
-    tracks = playlist['tracks']['total']
-    assert tracks == expect_tracks
-
-
-def test_tracks():
-    playlist = spotdl.spotify.user_playlists(username)['items'][0]
-    expect_lines = playlist['tracks']['total']
-    result = spotdl.spotify.user_playlist(
-        playlist['owner']['id'], playlist['id'], fields='tracks,next')
-    tracks = result['tracks']
-
-    with open('list.txt', 'w') as fout:
-        while True:
-            for item in tracks['items']:
-                track = item['track']
-                try:
-                    fout.write(track['external_urls']['spotify'] + '\n')
-                except KeyError:
-                    title = track['name'] + ' by '+ track['artists'][0]['name']
-                    print('Skipping track ' + title + ' (local only?)')
-            # 1 page = 50 results
-            # check if there are more pages
-            if tracks['next']:
-                tracks = spotify.next(tracks)
-            else:
-                break
-
-    with open('list.txt', 'r') as listed:
-        expect_song = (listed.read()).splitlines()[0]
-
-    spotdl.misc.trim_song('list.txt')
-    with open('list.txt', 'a') as myfile:
-        myfile.write(expect_song)
-
-    with open('list.txt', 'r') as listed:
-        songs = (listed.read()).splitlines()
-
-    lines = len(songs)
-    song = songs[-1]
-    assert (expect_lines == lines and expect_song == song)

test/test_with_metadata.py

@@ -0,0 +1,151 @@
+import os
+
+from spotdl import const
+from spotdl import internals
+from spotdl import spotify_tools
+from spotdl import youtube_tools
+from spotdl import convert
+from spotdl import metadata
+from spotdl import spotdl
+
+import loader
+
+loader.load_defaults()
+
+TRACK_URL = "https://open.spotify.com/track/2nT5m433s95hvYJH4S7ont"
+EXPECTED_TITLE = "Eminem - Curtains Up"
+EXPECTED_YT_TITLE = "Eminem - 01 - Eminem - Curtains Up (Skit)"
+EXPECTED_YT_URL = "http://youtube.com/watch?v=qk13SFlwG9A"
+
+
+def test_metadata():
+    expect_number = 23
+    global meta_tags
+    meta_tags = spotify_tools.generate_metadata(TRACK_URL)
+    assert len(meta_tags) == expect_number
+
+
+class TestFileFormat:
+    def test_with_spaces(self):
+        title = internals.format_string(const.args.file_format, meta_tags)
+        assert title == EXPECTED_TITLE
+
+    def test_without_spaces(self):
+        const.args.no_spaces = True
+        title = internals.format_string(const.args.file_format, meta_tags)
+        assert title == EXPECTED_TITLE.replace(" ", "_")
+
+
+def test_youtube_url():
+    url = youtube_tools.generate_youtube_url(TRACK_URL, meta_tags)
+    assert url == EXPECTED_YT_URL
+
+
+def test_youtube_title():
+    global content
+    content = youtube_tools.go_pafy(TRACK_URL, meta_tags)
+    title = youtube_tools.get_youtube_title(content)
+    assert title == EXPECTED_YT_TITLE
+
+
+def test_check_track_exists_before_download(tmpdir):
+    expect_check = False
+    const.args.folder = str(tmpdir)
+    # prerequisites for determining filename
+    songname = internals.format_string(const.args.file_format, meta_tags)
+    global file_name
+    file_name = internals.sanitize_title(songname)
+    check = spotdl.check_exists(file_name, TRACK_URL, meta_tags)
+    assert check == expect_check
+
+
+class TestDownload:
+    def test_m4a(self):
+        expect_download = True
+        download = youtube_tools.download_song(file_name + ".m4a", content)
+        assert download == expect_download
+
+    def test_webm(self):
+        expect_download = True
+        download = youtube_tools.download_song(file_name + ".webm", content)
+        assert download == expect_download
+
+
+class TestFFmpeg:
+    def test_convert_from_webm_to_mp3(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".webm", file_name + ".mp3", const.args.folder
+        )
+        assert return_code == expect_return_code
+
+    def test_convert_from_webm_to_m4a(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".webm", file_name + ".m4a", const.args.folder
+        )
+        assert return_code == expect_return_code
+
+    def test_convert_from_m4a_to_mp3(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".m4a", file_name + ".mp3", const.args.folder
+        )
+        assert return_code == expect_return_code
+
+    def test_convert_from_m4a_to_webm(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".m4a", file_name + ".webm", const.args.folder
+        )
+        assert return_code == expect_return_code
+
+    def test_convert_from_m4a_to_flac(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".m4a", file_name + ".flac", const.args.folder
+        )
+        assert return_code == expect_return_code
+
+
+class TestAvconv:
+    def test_convert_from_m4a_to_mp3(self):
+        expect_return_code = 0
+        return_code = convert.song(
+            file_name + ".m4a", file_name + ".mp3", const.args.folder, avconv=True
+        )
+        assert return_code == expect_return_code
+
+
+class TestEmbedMetadata:
+    def test_embed_in_mp3(self):
+        expect_embed = True
+        global track_path
+        track_path = os.path.join(const.args.folder, file_name)
+        embed = metadata.embed(track_path + ".mp3", meta_tags)
+        assert embed == expect_embed
+
+    def test_embed_in_m4a(self):
+        expect_embed = True
+        embed = metadata.embed(track_path + ".m4a", meta_tags)
+        os.remove(track_path + ".m4a")
+        assert embed == expect_embed
+
+    def test_embed_in_webm(self):
+        expect_embed = False
+        embed = metadata.embed(track_path + ".webm", meta_tags)
+        os.remove(track_path + ".webm")
+        assert embed == expect_embed
+
+    def test_embed_in_flac(self):
+        expect_embed = True
+        embed = metadata.embed(track_path + ".flac", meta_tags)
+        os.remove(track_path + ".flac")
+        assert embed == expect_embed
+
+
+def test_check_track_exists_after_download():
+    expect_check = True
+    check = spotdl.check_exists(file_name, TRACK_URL, meta_tags)
+    os.remove(track_path + ".mp3")
+    assert check == expect_check

test/test_without_metadata.py

@@ -0,0 +1,129 @@
+import os
+import builtins
+
+from spotdl import const
+from spotdl import internals
+from spotdl import spotify_tools
+from spotdl import youtube_tools
+from spotdl import spotdl
+
+import loader
+
+loader.load_defaults()
+
+YT_API_KEY = "AIzaSyAnItl3udec-Q1d5bkjKJGL-RgrKO_vU90"
+
+TRACK_SEARCH = "Tony's Videos VERY SHORT VIDEO 28.10.2016"
+EXPECTED_TITLE = TRACK_SEARCH
+EXPECTED_YT_URL = "http://youtube.com/watch?v=qOOcy2-tmbk"
+EXPECTED_YT_URLS = (EXPECTED_YT_URL, "http://youtube.com/watch?v=5USR1Omo7f0")
+
+RESULT_COUNT_SEARCH = "she is still sleeping SAO"
+
+EXPECTED_YT_API_KEY = "AIzaSyC6cEeKlxtOPybk9sEe5ksFN5sB-7wzYp0"
+EXPECTED_YT_API_KEY_CUSTOM = "some_api_key"
+
+
+class TestYouTubeAPIKeys:
+    def test_custom(self):
+        const.args.youtube_api_key = EXPECTED_YT_API_KEY_CUSTOM
+        youtube_tools.set_api_key()
+        key = youtube_tools.pafy.g.api_key
+        assert key == EXPECTED_YT_API_KEY_CUSTOM
+
+    def test_default(self):
+        const.args.youtube_api_key = None
+        youtube_tools.set_api_key()
+        key = youtube_tools.pafy.g.api_key
+        assert key == EXPECTED_YT_API_KEY
+
+
+def test_metadata():
+    expect_metadata = None
+    global metadata
+    metadata = spotify_tools.generate_metadata(TRACK_SEARCH)
+    assert metadata == expect_metadata
+
+
+class TestArgsManualResultCount:
+    # Regresson test for issue #264
+    def test_scrape(self):
+        const.args.manual = True
+        url = youtube_tools.GenerateYouTubeURL(RESULT_COUNT_SEARCH, meta_tags=None)
+        video_ids = url.scrape(bestmatch=False)
+        # Web scraping gives us all videos on the 1st page
+        assert len(video_ids) == 20
+
+    def test_api(self):
+        url = youtube_tools.GenerateYouTubeURL(RESULT_COUNT_SEARCH, meta_tags=None)
+        video_ids = url.api(bestmatch=False)
+        const.args.manual = False
+        # API gives us 50 videos (or as requested)
+        assert len(video_ids) == 50
+
+
+class TestYouTubeURL:
+    def test_only_music_category(self):
+        const.args.music_videos_only = True
+        url = youtube_tools.generate_youtube_url(TRACK_SEARCH, metadata)
+        # YouTube keeps changing its results
+        assert url in EXPECTED_YT_URLS
+
+    def test_all_categories(self):
+        const.args.music_videos_only = False
+        url = youtube_tools.generate_youtube_url(TRACK_SEARCH, metadata)
+        assert url == EXPECTED_YT_URL
+
+    def test_args_manual(self, monkeypatch):
+        const.args.manual = True
+        monkeypatch.setattr("builtins.input", lambda x: "1")
+        url = youtube_tools.generate_youtube_url(TRACK_SEARCH, metadata)
+        assert url == EXPECTED_YT_URL
+
+    def test_args_manual_none(self, monkeypatch):
+        expect_url = None
+        monkeypatch.setattr("builtins.input", lambda x: "0")
+        url = youtube_tools.generate_youtube_url(TRACK_SEARCH, metadata)
+        const.args.manual = False
+        assert url == expect_url
+
+
+class TestYouTubeTitle:
+    def test_single_download_with_youtube_api(self):
+        global content
+        global title
+        const.args.youtube_api_key = YT_API_KEY
+        youtube_tools.set_api_key()
+        content = youtube_tools.go_pafy(TRACK_SEARCH, metadata)
+        title = youtube_tools.get_youtube_title(content)
+        assert title == EXPECTED_TITLE
+
+    def test_download_from_list_without_youtube_api(self):
+        const.args.youtube_api_key = None
+        youtube_tools.set_api_key()
+        content = youtube_tools.go_pafy(TRACK_SEARCH, metadata)
+        title = youtube_tools.get_youtube_title(content, 1)
+        assert title == "1. {0}".format(EXPECTED_TITLE)
+
+
+def test_check_exists(tmpdir):
+    expect_check = False
+    const.args.folder = str(tmpdir)
+    # prerequisites for determining filename
+    global file_name
+    file_name = internals.sanitize_title(title)
+    check = spotdl.check_exists(file_name, TRACK_SEARCH, metadata)
+    assert check == expect_check
+
+
+class TestDownload:
+    def test_webm(self):
+        # content does not have any .webm audiostream
+        expect_download = False
+        download = youtube_tools.download_song(file_name + ".webm", content)
+        assert download == expect_download
+
+    def test_other(self):
+        expect_download = False
+        download = youtube_tools.download_song(file_name + ".fake_extension", content)
+        assert download == expect_download