updated documentation #85

add option to apply metadata in existing file.

Apologies for the late merge, you sent this pull request right as school was beginning to pick up in earnest and I forgot about it in that rush. Thanks for the great work!

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.cr]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

.gitignore

@@ -1,24 +1,15 @@
-# General stuff to ignore.
+/docs/
-*.pyc
+/lib/
-/dist/
+/bin/
-/*.egg-info/
+/logs/
-/build/
+/.shards/
-__pycache__/
+/Music/
+*.dwarf
 
-# For easy updating of stuff.
-update_pypi_and_github.py
-
-# Currently in progress
-/flexx-app/
-/.idea/
-*test.py
-
-# Temporarily downloaded files
 *.mp3
-*.zip
+*.webm*
-
+.ripper.log
-# Coverage files
+ffmpeg
-.coverage
+ffprobe
-
+youtube-dl
-# Temporarily built binaries
+*.temp
-ffmpeg binaries/

.travis.yml

@@ -1,21 +1,6 @@
-language: python
+language: crystal
-python:
-  - "2.7"
-  - "3.5"
 
-before_script: 
+# Uncomment the following if you'd like Travis to run specs and check code formatting
-  - sudo aptitude -y -q install ffmpeg libavcodec-extra-53 lame libmp3lame0
+# script:
-  # These dependencies are necessary for ffmpeg. I currently hate all things 
+#   - crystal spec
-  # doing with Travis and ffmpeg because I have no direct access to test stuff. 
+#   - crystal tool format --check
-  # I've gone through 25 seperate commits to get it working.
-
-install: 
-  - pip install coveralls # For coveralls.io
-  - pip install nose
-
-script:
-  - python setup.py install
-  - nosetests --with-coverage --cover-package=irs
-  
-after_success:
-  - coveralls

LICENSE

@@ -1,674 +1,21 @@
-                    GNU GENERAL PUBLIC LICENSE
+The MIT License (MIT)
-                       Version 3, 29 June 2007
+
-
+Copyright (c) 2020 Cooper Hammond
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+
- Everyone is permitted to copy and distribute verbatim copies
+Permission is hereby granted, free of charge, to any person obtaining a copy
- of this license document, but changing it is not allowed.
+of this software and associated documentation files (the "Software"), to deal
-
+in the Software without restriction, including without limitation the rights
-                            Preamble
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-
+copies of the Software, and to permit persons to whom the Software is
-  The GNU General Public License is a free, copyleft license for
+furnished to do so, subject to the following conditions:
-software and other kinds of works.
+
-
+The above copyright notice and this permission notice shall be included in
-  The licenses for most software and other practical works are designed
+all copies or substantial portions of the Software.
-to take away your freedom to share and change the works.  By contrast,
+
-the GNU General Public License is intended to guarantee your freedom to
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-share and change all versions of a program--to make sure it remains free
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-software for all its users.  We, the Free Software Foundation, use the
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-GNU General Public License for most of our software; it applies also to
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-any other work released this way by its authors.  You can apply it to
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-your programs, too.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-
+THE SOFTWARE.
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    {one line to give the program's name and a brief idea of what it does.}
-    Copyright (C) {year}  {name of author}
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    {project}  Copyright (C) {year}  {fullname}
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,100 +1,237 @@
-<div align="center"><img src ="http://i.imgur.com/VbsyTe7.png" /></div>
+# irs: The Ironic Repositioning System
 
-Ironic Redistribution System
+[![made-with-crystal](https://img.shields.io/badge/Made%20with-Crystal-1f425f.svg?style=flat-square)](https://crystal-lang.org/)
-===
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)](https://github.com/cooperhammond/irs/blob/master/LICENSE)
+[![Say Thanks](https://img.shields.io/badge/say-thanks-ff69b4.svg?style=flat-square)](https://saythanks.io/to/kepoorh%40gmail.com)
 
-[![License: GNU](https://img.shields.io/badge/license-gnu-yellow.svg?style=flat-square)](http://www.gnu.org/licenses/gpl.html)
+> A music scraper that understands your metadata needs.
-[![Stars](https://img.shields.io/github/stars/kepoorhampond/irs.svg?style=flat-square)](https://github.com/kepoorhampond/irs/stargazers)
-[![Build Status](https://img.shields.io/travis/kepoorhampond/irs/master.svg?style=flat-square)](https://travis-ci.org/kepoorhampond/irs)
-[![Say Thanks](https://img.shields.io/badge/say-thanks-ff69b4.svg?style=flat-square)](https://saythanks.io/to/kepoorhampond)
-[![Coverage Status](http://img.shields.io/coveralls/kepoorhampond/irs.svg?style=flat-square)](https://coveralls.io/github/kepoorhampond/irs?branch=master&style=flat-square)
-[![PyPI](https://img.shields.io/badge/pypi-irs-blue.svg?style=flat-square)](https://pypi.python.org/pypi/irs)
-[![Beerpay](https://beerpay.io/kepoorhampond/irs/badge.svg?style=flat-square)](https://beerpay.io/kepoorhampond/irs)
 
-<sup><sub>(Shields: Gotta Catch Em All)</sub></sup>
+`irs` is a command-line application that downloads audio and metadata in order
+to package an mp3 with both. Extensible, the user can download individual 
+songs, entire albums, or playlists from Spotify.
 
-> A music downloader that understands your metadata needs.
+<p align="center">
+    <img src="https://i.imgur.com/7QTM6rD.png" height="400" title="#1F816D" />
+</p>
+<p align="center"
 
-A tool to download your music with metadata. It uses [Spotify](https://www.spotify.com/) for finding metadata and [Youtube](https://www.youtube.com/) for the actual audio source.
+[![forthebadge](https://forthebadge.com/images/badges/compatibility-betamax.svg)](https://forthebadge.com)
+[![forthebadge](https://forthebadge.com/images/badges/ages-18.svg)](https://forthebadge.com)
+[![forthebadge](https://forthebadge.com/images/badges/built-by-codebabes.svg)](https://forthebadge.com)
+</p>
 
-Works with Python 2 and 3.
-___
-Demo and Usages
 ---
-This is a demo of the CLI displayling its features:
-[![demo](https://asciinema.org/a/105993.png)](https://asciinema.org/a/105993?autoplay=1)
 
-The usages can be found with the `-h` or `--help` flag:
+## Table of Contents
-```
+
-usage: irs [-h] [(-a ARTIST -s SONG)] [-A ALBUM] [(-u USERNAME -p PLAYLIST)]
+- [Usage](#usage)
+    - [Demo](#demo)
+- [Installation](#installation)
+    - [Pre-built](#pre-built)
+    - [From source](#from-source)
+    - [Set up](#setup)
+- [Config](#config)
+- [How it works](#how-it-works)
+- [Contributing](#contributing)
+
+
+## Usage
 
-optional arguments:
-  -h, --help            show this help message and exit
-  -a ARTIST, --artist ARTIST
-                        Specify artist name. Must be used with -s/--song
-  -s SONG, --song SONG  Specify song name. Must be used with -a/--artist
-  -A ALBUM, --album ALBUM
-                        Specify album name
-  -u USERNAME, --username USERNAME
-                        Specify username. Must be used with -p/--playlist
-  -p PLAYLIST, --playlist PLAYLIST
-                        Specify playlist name. Must be used with -u/--username
-  -l LOCATION, --location LOCATION
-                        Specify a directory to place files in.
-  -o, --organize        Organize downloaded files.
-  -c, --config          Display path to config file.
 ```
-So all of these are valid commands:
+~ $ irs -h
-```
+
-$ irs -a "Brandon Flowers" -s "Lonely Town"
+Usage: irs [--help] [--version] [--install]
-$ irs -u "spotify" -p "Brain Food"
+           [-s <song> -a <artist>]
-$ irs -A "Suicide Squad: The Album"
+           [-A <album> -a <artist>]
-```
+           [-p <playlist> -a <username>]
-But these are not:
+
-```
+Arguments:
-$ irs -s "Bohemian Rhapsody"
+    -h, --help                  Show this help message and exit
-$ irs -p "Best Nirvana"
+    -v, --version               Show the program version and exit
+    -i, --install               Download binaries to config location
+    -c, --config                Show config file location
+    -a, --artist <artist>       Specify artist name for downloading
+    -s, --song <song>           Specify song name to download
+    -A, --album <album>         Specify the album name to download
+    -p, --playlist <playlist>   Specify the playlist name to download
+    -u, --url <url>             Specify the youtube url to download from (for single songs only)
+    -g, --give-url              Specify the youtube url sources while downloading (for albums or playlists only only)
+
+Examples:
+    $ irs --song "Bohemian Rhapsody" --artist "Queen"
+    # => downloads the song "Bohemian Rhapsody" by "Queen"
+    $ irs --album "Demon Days" --artist "Gorillaz"
+    # => downloads the album "Demon Days" by "Gorillaz"
+    $ irs --playlist "a different drummer" --artist "prakkillian"
+    # => downloads the playlist "a different drummer" by the user prakkillian
 ```
 
-Install & The Dependencies <sub><sup>(my new band name)</sub></sup>
+### Demo
----
-Really there's only one actual external dependency: `ffmpeg`. For windows, you'll want to follow [this](http://www.wikihow.com/Install-FFmpeg-on-Windows) guide. For OSX, you'll want to install it through [`brew`](https://brew.sh/) with this command:
-```
-$ brew install ffmpeg
-```
-For Linux, most package managers have `ffmpeg` in their default repositories, so it can be installed like so:
-```
-$ sudo apt-get install ffmpeg
-```
-Or whatever your appropriate package manager is.
 
-Other than `ffmpeg` though, all other dependencies are automatically installed with [`pip`](https://pip.pypa.io/en/stable/):
+[![asciicast](https://asciinema.org/a/332793.svg)](https://asciinema.org/a/332793)
+
+## Installation
+
+### Pre-built 
+
+Just download the latest release for your platform 
+[here](https://github.com/cooperhammond/irs/releases).
+
+Note that the binaries right now have only been tested on WSL. They *should* run on most linux distros, and OS X, but if they don't please make an issue above.
+
+### From Source
+
+If you're one of those cool people who compiles from source
+
+1. Install crystal-lang 
+    ([`https://crystal-lang.org/install/`](https://crystal-lang.org/install/))
+1. Clone it (`git clone https://github.com/cooperhammond/irs`)
+1. CD it (`cd irs`)
+1. Build it (`shards build`)
+
+### Setup
+
+1. Create a `.yaml` config file somewhere on your system (usually `~/.irs/`)
+1. Copy the following into it
+    ```yaml
+    binary_directory: ~/.irs/bin
+    music_directory: ~/Music
+    filename_pattern: "{track_number} - {title}"
+    directory_pattern: "{artist}/{album}"
+    client_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+    client_secret: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+    single_folder_playlist:
+        enabled: true
+        retain_playlist_order: true
+        unify_into_album: false
+    ```
+1. Set the environment variable `IRS_CONFIG_LOCATION` pointing to that file
+1. Go to [`https://developer.spotify.com/dashboard/`](https://developer.spotify.com/dashboard/)
+1. Log in or create an account
+1. Click `CREATE A CLIENT ID`
+1. Enter all necessary info, true or false, continue
+1. Find your client key and client secret
+1. Copy each respectively into the X's in your config file
+1. Run `irs --install` and answer the prompts!
+
+You should be good to go! Run the file from your command line to get more help on
+usage or keep reading!
+
+# Config
+
+You may have noticed that there's a config file with more than a few options. 
+Here's what they do:
+```yaml
+binary_directory: ~/.irs/bin
+music_directory: ~/Music
+search_terms: "lyrics"
+filename_pattern: "{track_number} - {title}"
+directory_pattern: "{artist}/{album}"
+client_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+client_secret: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+single_folder_playlist:
+    enabled: true
+    retain_playlist_order: true
+    unify_into_album: false
 ```
-$ sudo pip install irs
+ - `binary_directory`: a path specifying where the downloaded binaries should
+    be placed
+ - `music_directory`: a path specifying where downloaded mp3s should be placed.
+ - `search_terms`: additional search terms to plug into youtube, which can be
+    potentially useful for not grabbing erroneous audio.
+ - `filename_pattern`: a pattern for the output filename of the mp3
+ - `directory_pattern`: a pattern for the folder structure your mp3s are saved in
+ - `client_key`: a client key from your spotify API application
+ - `client_secret`: a client secret key from your spotify API application
+ - `single_folder_playlist/enabled`: if set to true, all mp3s from a downloaded
+    playlist will be placed in the same folder.
+ - `single_folder_playlist/retain_playlist_order`: if set to true, the track 
+    numbers of the mp3s of the playlist will be overwritten to correspond to
+    their place in the playlist
+ - `single_folder_playlist/unify_into_album`: if set to true, will overwrite
+    the album name and album image of the mp3 with the title of your playlist
+    and the image for your playlist respectively
+
+
+In a pattern following keywords will be replaced:
+
+| Keyword | Replacement | Example |
+| :----: | :----: | :----: |
+| `{artist}` | Artist Name | Queen |
+| `{title}` | Track Title | Bohemian Rhapsody |
+| `{album}` | Album Name | Stone Cold Classics |
+| `{track_number}` | Track Number | 9 |
+| `{total_tracks}` | Total Tracks in Album | 14 |
+| `{disc_number}` | Disc Number | 1 |
+| `{day}` | Release Day | 01 |
+| `{month}` | Release Month | 01 |
+| `{year}` | Release Year | 2006 |
+| `{id}` | Spotify ID | 6l8GvAyoUZwWDgF1e4822w |
+
+Beware OS-restrictions when naming your mp3s.
+
+Pattern Examples:
+```yaml
+music_directory: ~/Music
+filename_pattern: "{track_number} - {title}"
+directory_pattern: "{artist}/{album}"
 ```
+Outputs: `~/Music/Queen/Stone Cold Classics/9 - Bohemian Rhapsody.mp3`
+<br><br>
+```yaml
+music_directory: ~/Music
+filename_pattern: "{artist} - {title}"
+directory_pattern: ""
+```
+Outputs: `~/Music/Queen - Bohemian Rhapsody.mp3`
+<br><br>
+```yaml
+music_directory: ~/Music
+filename_pattern: "{track_number} of {total_tracks} - {title}"
+directory_pattern: "{year}/{artist}/{album}"
+```
+Outputs: `~/Music/2006/Queen/Stone Cold Classics/9 of 14 - Bohemian Rhapsody.mp3`
+<br><br>
+```yaml
+music_directory: ~/Music
+filename_pattern: "{track_number}. {title}"
+directory_pattern: "irs/{artist} - {album}"
+```
+Outputs: `~/Music/irs/Queen - Stone Cold Classics/9. Bohemian Rhapsody.mp3`
+<br>
 
-Metadata
----
-Currently, the program attaches the following metadata to the downloaded files:
- - Title
- - Artist
- - Album
- - Album Art
- - Genre
- - Track Number
- - Disc Number
- - Compilation (iTunes only)
 
-### Philosophy
+## How it works
-When I made this program I was pretty much broke and my music addiction wasn't really helping that problem. So, I did the obvious thing: make an uber-complicated program to ~~steal~~ download music for me! As for the name, its acronym spells IRS, which I found amusing, seeing as the IRS ~~takes~~ steals money while my program ~~gives~~ reimburses you with music.
 
-The design/style inspiration of pretty much everything goes to [k4m4](https://github.com/k4m4).
+**At it's core** `irs` downloads individual songs. It does this by interfacing
+with the Spotify API, grabbing metadata, and then searching Youtube for a video
+containing the song's audio. It will download the video using 
+[`youtube-dl`](https://github.com/ytdl-org/youtube-dl), extract the audio using
+[`ffmpeg`](https://ffmpeg.org/), and then pack the audio and metadata together
+into an MP3.
 
-### Wishlist
+From the core, it has been extended to download the index of albums and 
- - [x] Full album downloading
+playlists through the spotify API, and then iteratively use the method above
- - [x] Album art metadata correctly displayed
+for downloading each song.
- - [x] Spotify playlist downloading
- - [ ] GUI/Console interactive version - *in progress*
- - [ ] Lyric metadata
- - [ ] 99% success rate for automatic song choosing
 
+It used to be in python, but
+1. I wasn't a fan of python's limited ability to distribute standalone binaries
+1. It was a charlie foxtrot of code that I made when I was little and I wanted
+    to refine it
+1. `crystal-lang` made some promises and I was interested in seeing how well it
+    did (verdict: if you're building high-level tools you want to run quickly 
+    and distribute, it's perfect)
+
+
+## Contributing
+
+Any and all contributions are welcome. If you think of a cool feature, send a 
+PR or shoot me an [email](mailto:kepoorh@gmail.com). If you think something 
+could be implemented better, _please_ shoot me an email. If you like what I'm
+doing here, _pretty please_ shoot me an email.
+
+1. Fork it (<https://github.com/your-github-user/irs/fork>)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

irs/__init__.py

@@ -1 +0,0 @@
-from .ripper import Ripper

irs/cli.py

@@ -1,74 +0,0 @@
-# Arguments
-import argparse
-
-# System
-import sys
-import os
-
-# Powered by:
-from .ripper import Ripper
-from .utils import Config, console
-
-
-def main():
-    parser = argparse.ArgumentParser()
-
-    # Single Song
-    parser.add_argument("-a", "--artist", dest="artist", help="Specify artist \
-name. Must be used with -s/--song or -A/--album")
-    parser.add_argument("-s", "--song", dest="song", help="Specify song name.\
- Must be used with -a/--artist")
-
-    # Album
-    parser.add_argument("-A", "--album", dest="album", help="Specify album \
-name")
-
-    # Playlist
-    parser.add_argument("-u", "--username", dest="username", help="Specify \
-username. Must be used with -p/--playlist")
-    parser.add_argument("-p", "--playlist", dest="playlist", help="Specify \
-playlist name. Must be used with -u/--username")
-
-    # Post-Processors
-    parser.add_argument("-l", "--location", dest="location", help="Specify a \
-directory to place files in.")
-    parser.add_argument("-o", "--organize", dest="organize",
-                        action="store_true", help="Organize downloaded files.")
-
-    # Config
-    parser.add_argument("-c", "--config", dest="config", action="store_true",
-                        help="Display path to config file.")
-
-    args = parser.parse_args(Config.parse_default_flags())
-
-    if args.config:
-        import irs
-        print(os.path.dirname(irs.__file__) + "/config.py")
-        sys.exit()
-
-    ripper_args = {
-        "post_processors": {
-            "custom_directory": args.location,
-            "organize": args.organize,
-        }
-    }
-
-    # Combiner args from argparse and the ripper_args as above and then
-    # remove all keys with the value of "None"
-    ripper_args.update(vars(args))
-    ripper_args = dict((k, v) for k, v in ripper_args.iteritems() if v)
-
-    ripper = Ripper(ripper_args)
-
-    if args.artist and args.song:
-        ripper.song(args.song, args.artist)
-    elif args.album:
-        ripper.spotify_list("album", args.album, artist=args.artist)
-    elif args.username and args.playlist:
-        ripper.spotify_list("playlist", args.playlist, args.username)
-    else:
-        console(ripper)
-
-
-if __name__ == "__main__":
-    main()

irs/config.py

@@ -1,24 +0,0 @@
-CONFIG = dict(
-
-    default_flags = ['-o'],
-    # For default flags. Right now, it organizes your files into an
-    # artist/album/song structure.
-    # To add a flag or argument, add an element to the index:
-    # default_flags = ['-o', '-l', '~/Music']
-
-    SPOTIFY_CLIENT_ID = '',
-    SPOTIFY_CLIENT_SECRET = '',
-    # You can either specify Spotify keys here, or in environment variables.
-
-    additional_search_terms = 'lyrics',
-    # Search terms for youtube
-
-    organize = True,
-    # True always forces organization.
-    # False always forces non-organization.
-    # None allows options and flags to determine if the files
-    # will be organized.
-
-    custom_directory = "",
-    # Defaults to '~/Music'
-)

irs/metadata.py

@@ -1,76 +0,0 @@
-# MP3 Metadata editing
-from mutagen.mp3 import EasyMP3
-from mutagen.easyid3 import EasyID3
-from mutagen.id3 import *  # There's A LOT of stuff to import, forgive me.
-from mutagen.id3 import APIC, ID3
-
-# System
-import sys
-
-# Powered by...
-import spotipy
-
-# Local utils
-from .utils import ObjManip
-om = ObjManip
-
-# Info finding
-if sys.version_info[0] >= 3:
-    from urllib.parse import quote_plus, quote
-    from urllib.request import urlopen, Request
-elif sys.version_info[0] < 3:
-    from urllib import quote_plus, quote
-    from urllib import urlopen
-    from urllib2 import Request
-
-
-class Metadata:
-    def __init__(self, location):
-        self.spotify = spotipy.Spotify()
-        self.location = location
-        self.mp3 = EasyID3(self.location)
-        EasyID3.RegisterTextKey("comment", "COMM")
-
-    def add_tag(self, tag, data):
-        # For valid tags: `EasyID3.valid_keys.keys()`
-        self.mp3[tag] = data
-        self.mp3.save()
-
-    def read_tag(self, tag):
-        try:
-            return self.mp3[tag]
-        except Exception:
-            return []
-
-    def add_album_art(self, image_url):
-        mp3 = EasyMP3(self.location, ID3=ID3)
-        mp3.tags.add(
-            APIC(
-                encoding = 3,
-                mime     = 'image/png',
-                type     = 3,
-                desc     = 'cover',
-                data     = urlopen(image_url).read()
-            )
-        )
-        mp3.save()
-
-
-def find_album_and_track(song, artist):
-    tracks = spotipy.Spotify().search(q=song, type="track"
-                                      )["tracks"]["items"]
-    for track in tracks:
-        if om.blank_include(track["name"], song):
-            if om.blank_include(track["artists"][0]["name"], artist):
-                return track["album"], track
-    return False, False
-
-
-def parse_genre(genres):
-    if genres != []:
-        genres.reverse()
-        genres = list(map(lambda x: x.replace("-", " "), genres))
-        genres.sort(key=lambda x: len(x.split()))
-        return genres[0].title()
-    else:
-        return ""

irs/ripper.py

@@ -1,403 +0,0 @@
-# Powered by:
-import youtube_dl
-import spotipy
-from spotipy.oauth2 import SpotifyClientCredentials
-
-# System
-import sys
-import os
-import glob
-
-# Local utilities
-from .utils import YdlUtils, ObjManip, Config
-from .metadata import Metadata
-from .metadata import find_album_and_track, parse_genre
-
-# Parsing
-from bs4 import BeautifulSoup
-if sys.version_info[0] >= 3:
-    from urllib.parse import urlencode
-    from urllib.request import urlopen
-elif sys.version_info[0] < 3:
-    from urllib import urlencode
-    from urllib import urlopen
-else:
-    print("Must be using Python 2 or 3")
-    sys.exit(1)
-
-
-class Ripper:
-    def __init__(self, args={}):
-        self.args = args
-        self.locations = []
-        self.type = None
-        try:
-            CLIENT_ID, CLIENT_SECRET = Config.parse_spotify_creds(self)
-            client_credentials_manager = SpotifyClientCredentials(CLIENT_ID,
-                                                                  CLIENT_SECRET
-                                                                  # Stupid lint
-                                                                  )
-
-            self.spotify = spotipy.Spotify(
-                client_credentials_manager=client_credentials_manager)
-
-            self.authorized = True
-        except Exception as e:
-            self.spotify = spotipy.Spotify()
-            self.authorized = False
-
-    def post_processing(self, locations):
-        post_processors = self.args.get("post_processors")
-        directory_option = Config.parse_directory(self)
-        if post_processors:
-            if directory_option is not None:
-                for index, loc in enumerate(locations):
-                    new_file_name = directory_option + "/" + loc
-                    if not os.path.exists(directory_option):
-                        os.makedirs(directory_option)
-                    os.rename(loc, new_file_name)
-                    locations[index] = new_file_name
-            # I'd just go on believing that code this terrible doesn't exist.
-            # You can just close your eyes and scroll by. I'd encourage it.
-            # It's okay if you need to cry though.
-            # The rest of the code is here for you.
-            # It's like loving someone,
-            # Everyone has some flaws, but you still appreciate and embrace
-            # those flaws for being exclusive to them.
-            # And if those flaws are really enough to turn you off of them,
-            # then you *probably* don't really want to be with them anyways.
-            # Either way, it's up to you.
-
-            if Config.parse_organize(self):
-                if self.type in ("album", "song"):
-                    for index, loc in enumerate(locations):
-                        mp3 = Metadata(loc)
-                        new_loc = ""
-                        if len(loc.split("/")) >= 2:
-                            new_loc = "/".join(loc.split("/")[0:-1]) + "/"
-                            file_name = loc.split("/")[-1]
-                        else:
-                            file_name = loc
-                        artist = mp3.read_tag("artist")[0]
-                        album = mp3.read_tag("album")
-                        new_loc += ObjManip.blank(artist, False)
-                        if album != []:
-                            new_loc += "/" + ObjManip.blank(album[0], False)
-                        if not os.path.exists(new_loc):
-                            os.makedirs(new_loc)
-                        new_loc += "/" + file_name
-                        loc = loc.replace("//", "/")
-                        new_loc = new_loc.replace("//", "/")
-                        os.rename(loc, new_loc)
-                        locations[index] = new_loc
-                elif self.type == "playlist":
-                    for index, loc in enumerate(locations):
-                        new_loc = ""
-                        if len(loc.split("/")) > 1:
-                            new_loc = "/".join(loc.split("/")[0:-1])
-                            file_name = loc.split("/")[-1]
-                        else:
-                            file_name = loc
-                        new_loc += ObjManip.blank(self.playlist_title, False)
-                        if not os.path.exists(new_loc):
-                            os.makedirs(new_loc)
-                        loc = loc.replace("//", "/")
-                        new_loc = (new_loc + "/" + file_name)\
-                            .replace("//", "/")
-                        os.rename(loc, new_loc)
-
-        return locations
-
-    def find_yt_url(self, song=None, artist=None, additional_search=None):
-        if additional_search is None:
-            additional_search = Config.parse_search_terms(self)
-        try:
-            if not song:
-                song = self.args["song_title"]
-            if not artist:
-                artist = self.args["artist"]
-        except KeyError:
-            raise ValueError("Must specify song_title/artist in `args` with \
-init, or in method arguments.")
-
-        print("Finding Youtube Link ...")
-
-        search_terms = song + " " + artist + " " + additional_search
-        query_string = urlencode({"search_query": (search_terms)})
-        link = "http://www.youtube.com/results?" + query_string
-
-        html_content = urlopen(link).read()
-        soup = BeautifulSoup(html_content, 'html.parser')  # .prettify()
-
-        def find_link(link):
-            try:
-                if "yt-uix-tile-link yt-ui-ellipsis yt-ui-ellipsis-2 yt-uix-\
-sessionlink spf-link" in str(" ".join(link["class"])):
-                    if "&list=" not in link["href"]:
-                        return link
-            except KeyError:
-                pass
-
-        results = list(filter(None, (map(find_link, soup.find_all("a")))))
-
-        garbage_phrases = "cover  album  live  clean  rare version  full  full \
-album".split("  ")
-
-        self.code = None
-        counter = 0
-
-        while self.code is None and counter <= 10:
-            counter += 1
-            for link in results:
-                if ObjManip.blank_include(link["title"], song) and \
-                        ObjManip.blank_include(link["title"], artist):
-                    if ObjManip.check_garbage_phrases(garbage_phrases,
-                                                      link["title"], song):
-                        continue
-                    self.code = link
-                    break
-
-            if self.code is None:
-                for link in results:
-                    if ObjManip.check_garbage_phrases(garbage_phrases,
-                                                      link["title"], song):
-                        continue
-                    if ObjManip.individual_word_match(song, link["title"]) \
-                            >= 0.8 and ObjManip.blank_include(link["title"],
-                                                              artist):
-                        self.code = link
-                        break
-
-            if self.code is None:
-                song = ObjManip.limit_song_name(song)
-
-        if self.code is None:
-            if additional_search == "lyrics":
-                return self.find_yt_url(song, artist, "")
-            else:
-                self.code = results[0]
-
-        return ("https://youtube.com" + self.code["href"], self.code["title"])
-
-    def album(self, title):  # Alias for `spotify_list("album", ...)`
-        return self.spotify_list("album", title)
-
-    def playlist(self, title, username):
-        # Alias for `spotify_list("playlist", ...)`
-        return self.spotify_list("playlist", title, username)
-
-    def spotify_list(self, type=None, title=None, username=None, artist=None):
-        try:
-            if not type:
-                type = self.args["type"]
-            if not title:
-                title = self.args["list_title"]
-            if not username and type == "playlist":
-                username = self.args["username"]
-        except KeyError:
-            raise ValueError("Must specify type/title/username in `args` \
-with init, or in method arguments.")
-
-        if not self.type:
-            self.type = type
-
-        if type == "album":
-            search = title
-            if "artist" in self.args:
-                search += " " + self.args["artist"]
-            list_of_lists = self.spotify.search(q=search, type="album")
-            list_of_lists = list_of_lists["albums"]["items"]
-        elif type == "playlist":
-            list_of_lists = self.spotify.user_playlists(username)["items"]
-
-        if len(list_of_lists) > 0:
-            the_list = None
-            for list_ in list_of_lists:
-                if ObjManip.blank_include(list_["name"], title):
-                    if Config.parse_artist(self):
-                        if ObjManip.blank_include(list_["artists"][0]["name"],
-                                                  ObjManip.arse_artist(self)):
-                            the_list = self.spotify.album(list_["uri"])
-                            break
-                    else:
-                        if type == "album":
-                            the_list = self.spotify.album(list_["uri"])
-                        else:
-                            the_list = self.spotify.user_playlist(
-                                list_["owner"]["id"], list_["uri"])
-                            the_list["artists"] = [{"name": username}]
-                        break
-            if the_list is not None:
-                YdlUtils.clear_line()
-
-                print(type.title() + ': "%s" by \
-"%s"' % (the_list["name"], the_list["artists"][0]["name"]))
-
-                compilation = ""
-                if type == "album":
-                    tmp_artists = []
-
-                    for track in the_list["tracks"]["items"]:
-                        tmp_artists.append(track["artists"][0]["name"])
-                    tmp_artists = list(set(tmp_artists))
-                    if len(tmp_artists) > 1:
-                        compilation = "1"
-
-                tracks = []
-                file_prefix = ""
-
-                for track in the_list["tracks"]["items"]:
-                    if type == "playlist":
-                        # For post-processors
-                        self.playlist_title = the_list["name"]
-
-                        file_prefix = str(len(tracks) + 1) + " - "
-                        track = track["track"]
-                        album = self.spotify.album(track["album"]["uri"])
-                    elif type == "album":
-                        file_prefix = str(track["track_number"]) + " - "
-                        track = self.spotify.track(track["uri"])
-                        album = the_list
-
-                    data = {
-                        "name":          track["name"],
-                        "artist":        track["artists"][0]["name"],
-                        "album":         album["name"],
-                        "genre":         parse_genre(
-                            self.spotify.artist(track["artists"][0]["uri"]
-                                                )["genres"]),
-                        "track_number":  track["track_number"],
-                        "disc_number":   track["disc_number"],
-                        "album_art":     album["images"][0]["url"],
-                        "compilation":   compilation,
-                        "file_prefix":   file_prefix,
-                    }
-
-                    tracks.append(data)
-
-                locations = self.list(tracks)
-                return locations
-                # return self.post_processing(locations)
-
-        print("Could not find any lists.")
-        return False
-
-    def list(self, list_data):
-        locations = []
-        # with open(".irs-download-log", "w+") as file:
-        #     file.write(format_download_log_data(list_data))
-
-        for track in list_data:
-            loc = self.song(track["name"], track["artist"], track)
-
-            if loc is not False:
-                # update_download_log_line_status(track, "downloaded")
-                locations.append(loc)
-
-        if self.type in ("album", "playlist"):
-            return self.post_processing(locations)
-
-        # os.remove(".irs-download-log")
-        return locations
-
-    def parse_song_data(self, song, artist):
-        album, track = find_album_and_track(song, artist)
-        if album is False:
-            return {}
-
-        album = self.spotify.album(album["uri"])
-        track = self.spotify.track(track["uri"])
-        genre = self.spotify.artist(album["artists"][0]["uri"])["genres"]
-
-        return {
-            "name":            track["name"],
-            "artist":          track["artists"][0]["name"],
-            "album":           album["name"],
-            "album_art":       album["images"][0]["url"],
-            "genre":           parse_genre(genre),
-            "track_number":    track["track_number"],
-            "disc_number":     track["disc_number"],
-
-            # If this method is being called, it's not a compilation
-            "compilation": "",
-            # And therefore, won't have a prefix
-            "file_prefix": ""
-        }
-
-    def song(self, song, artist, data={}):
-        # "data" comes from "self.parse_song_data"'s layout
-
-        if not self.type:
-            self.type = "song"
-
-        try:
-            if not song:
-                song = self.args["song_title"]
-            if not artist:
-                artist = self.args["artist"]
-        except KeyError:
-            raise ValueError("Must specify song_title/artist in `args` with \
-init, or in method arguments.")
-
-        if data == {}:
-            data = self.parse_song_data(song, artist)
-            if data != {}:
-                song = data["name"]
-                artist = data["artist"]
-
-        if "file_prefix" not in data:
-            data["file_prefix"] = ""
-
-        video_url, video_title = self.find_yt_url(song, artist)
-
-        print('Downloading "%s" by "%s" ...' % (song, artist))
-
-        file_name = str(data["file_prefix"] + ObjManip.blank(song, False) +
-                        ".mp3")
-
-        ydl_opts = {
-            'format': 'bestaudio/best',
-            'postprocessors': [{
-                'key': 'FFmpegExtractAudio',
-                'preferredcodec': 'mp3',
-                'preferredquality': '192',
-            }],
-            'logger': YdlUtils.MyLogger(),
-            'progress_hooks': [YdlUtils.my_hook],
-            'output': "tmp_file",
-            'prefer-ffmpeg': True,
-        }
-
-        with youtube_dl.YoutubeDL(ydl_opts) as ydl:
-            ydl.download([video_url])
-
-        for file in glob.glob("./*%s*" % video_url.split("/watch?v=")[-1]):
-            os.rename(file, file_name)
-
-        # Ease of Variables (C) (patent pending) (git yer filthy hands off)
-        # [CENSORED BY THE BAD CODE ACT]
-        # *5 Minutes Later*
-        # Deprecated. It won't be the next big thing. :(
-
-        m = Metadata(file_name)
-
-        m.add_tag("comment", 'URL: "%s"\nVideo Title: "%s"' %
-                             (video_url, video_title))
-        if len(data.keys()) > 1:
-            m.add_tag("title",          data["name"])
-            m.add_tag("artist",         data["artist"])
-            m.add_tag("album",          data["album"])
-            m.add_tag("genre",          data["genre"])
-            m.add_tag("tracknumber",    str(data["track_number"]))
-            m.add_tag("discnumber",     str(data["disc_number"]))
-            m.add_tag("compilation",    data["compilation"])
-            m.add_album_art(str(data["album_art"]))
-        else:
-            print("Could not find metadata.")
-            m.add_tag("title",          song)
-            m.add_tag("artist",         artist)
-
-        if self.type == "song":
-            return self.post_processing([file_name])
-
-        return file_name

irs/utils.py

@@ -1,411 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-# =======
-# Imports
-# =======
-
-# Static Method Hook
-import inspect
-
-# And Now For Something Completely Different
-import os
-import sys
-import re
-from time import sleep
-import pkg_resources
-
-# Config File and Flags
-from .config import CONFIG
-
-
-# ==================
-# Static Method Hook
-# ==================
-
-def staticmethods(cls):
-    for name, method in inspect.getmembers(cls, inspect.ismethod):
-        setattr(cls, name, staticmethod(method.__func__))
-    return cls
-
-
-# =========================
-# Youtube-DL Logs and Hooks
-# =========================
-
-@staticmethods
-class YdlUtils:
-    def clear_line():
-        sys.stdout.write("\x1b[2K\r")
-
-    class MyLogger(object):
-        def debug(self, msg):
-            pass
-
-        def warning(self, msg):
-            pass
-
-        def error(self, msg):
-            print(msg)
-
-    def my_hook(d):
-        if d['status'] == 'finished':
-            print("Converting to mp3 ...")
-
-
-# ================================
-# Object Manipulation and Checking
-# ================================
-
-@staticmethods
-class ObjManip:  # Object Manipulation
-    def limit_song_name(song):
-        bad_phrases = "remaster  remastered  master".split("  ")
-        # I have "master" here because Spotify actually sometimes mispells
-        # stuff and it is hella annoying, so this was my solution
-        for phrase in bad_phrases:
-            if ObjManip.blank_include(song.split(" - ")[-1], phrase):
-                return song.split(" - ")[0]
-        return song
-
-    def check_garbage_phrases(phrases, string, title):
-        for phrase in phrases:
-            if phrase in ObjManip.blank(string):
-                if phrase not in ObjManip.blank(title):
-                    return True
-        return False
-
-    def blank(string, downcase=True):
-        import re
-        regex = re.compile('[^a-zA-Z0-9\ ]')
-        string = regex.sub('', string)
-        if downcase:
-            string = string.lower()
-        return ' '.join(string.split())
-
-    def blank_include(this, includes_this):
-        this = ObjManip.blank(this)
-        includes_this = ObjManip.blank(includes_this)
-        if includes_this in this:
-            return True
-        return False
-
-    def individual_word_match(match_against, match):
-        match_against = ObjManip.blank(match_against).split(" ")
-        match = ObjManip.blank(match).split(" ")
-        matched = []
-        for match_ag in match_against:
-            for word in match:
-                if match_ag == word:
-                    matched.append(word)
-        return (float(len(set(matched))) / float(len(match_against)))
-
-    def flatten(l):
-        flattened_list = []
-        for x in l:
-            if type(x) != str:
-                for y in x:
-                    flattened_list.append(y)
-            else:
-                flattened_list.append(x)
-        return flattened_list
-
-    def remove_none_values(d):
-        new_d = d
-        for x in list(d.keys()):
-            if type(new_d[x]) is list:
-                new_d[x] = ObjManip.remove_none_values(d[x])
-            elif new_d[x] is None:
-                del new_d[x]
-        return new_d
-
-
-# ========================================
-# Download Log Reading/Updating/Formatting
-# ========================================
-
-@staticmethods
-class DLog:
-    def format_download_log_line(t, download_status="not downloaded"):
-        return (" @@ ".join([t["name"], t["artist"], t["album"]["id"],
-                str(t["genre"]), t["track_number"], t["disc_number"],
-                t["compilation"], t["file_prefix"], download_status]))
-
-    def format_download_log_data(data):
-        lines = []
-        for track in data:
-            lines.append(DLog.format_download_log_line(track))
-        return "\n".join(lines)
-
-    def read_download_log(spotify):
-        data = []
-        with open(".irs-download-log", "r") as file:
-            for line in file:
-                line = line.split(" @@ ")
-                data.append({
-                    "name":          line[0],
-                    "artist":        line[1],
-                    "album":         spotify.album(line[2]),
-                    "genre":         eval(line[3]),
-                    "track_number":  line[4],
-                    "disc_number":   line[5],
-                    "compilation":   bool(line[6]),
-                    "file_prefix":   line[7],
-                })
-        return data
-
-    def update_download_log_line_status(track, status="downloaded"):
-        line_to_find = DLog.format_download_log_line(track)
-        with open(".irs-download-log", "r") as input_file:
-            with open(".irs-download-log", "w") as output_file:
-                for line in input_file:
-                    if line == line_to_find:
-                        output_file.write(
-                            DLog.format_download_log_line(track, status))
-                    else:
-                        output_file.write(line)
-
-
-# ===========================================
-# And Now, For Something Completely Different
-# ===========================================
-#              (It's for the CLI)
-
-COLS = int(os.popen('tput cols').read().strip("\n"))
-
-if sys.version_info[0] == 2:
-    def input(string):
-        return raw_input(string)
-
-
-def code(code1):
-    return "\x1b[%sm" % str(code1)
-
-
-def no_colors(string):
-    return re.sub("\x1b\[\d+m", "", string)
-
-
-def center_colors(string, cols):
-    return no_colors(string).center(cols).replace(no_colors(string), string)
-
-
-def decode_utf8(string):
-    if sys.version_info[0] == 3:
-        return string.encode("utf8", "strict").decode()
-    elif sys.version_info[0] == 2:
-        return string.decode("utf8")
-
-
-def center_unicode(string, cols):
-    tmp_chars = "X" * len(decode_utf8(string))
-    chars = center_colors(tmp_chars, cols)
-    return chars.replace(tmp_chars, string)
-
-
-def center_lines(string, cols, end="\n"):
-    lines = []
-    for line in string.split("\n"):
-        lines.append(center_unicode(line, cols))
-    return end.join(lines)
-
-
-def flush_puts(msg, time=0.01):
-    # For slow *burrrp* scroll text, Morty. They-They just love it, Morty.
-    # When they see this text. Just slowwwly extending across the page. Mmm,
-    # mmm. You just give the time for how *buurp* slow you wa-want it, Morty.
-    # It works with colors and escape characters too, Morty.
-    # Your grandpa's a genius *burrrp* Morty
-    def check_color(s):
-        if "\x1b" not in s:
-            new = list(s)
-        else:
-            new = s
-        return new
-    msg = re.split("(\x1b\[\d+m)", msg)
-    msg = list(filter(None, map(check_color, msg)))
-    msg = ObjManip.flatten(msg)
-    for char in msg:
-        if char not in (" ", "", "\n") and "\x1b" not in char:
-            sleep(time)
-        sys.stdout.write(char)
-        sys.stdout.flush()
-    print("")
-
-
-BOLD = code(1)
-END = code(0)
-RED = code(31)
-GREEN = code(32)
-YELLOW = code(33)
-BLUE = code(34)
-PURPLE = code(35)
-CYAN = code(36)
-GRAY = code(37)
-BRED = RED + BOLD
-BGREEN = GREEN + BOLD
-BYELLOW = YELLOW + BOLD
-BBLUE = BLUE + BOLD
-BPURPLE = PURPLE + BOLD
-BCYAN = CYAN + BOLD
-BGRAY = GRAY + BOLD
-
-
-def banner():
-    title = (BCYAN + center_lines("""\
-██╗██████╗ ███████╗
-██║██╔══██╗██╔════╝
-██║██████╔╝███████╗
-██║██╔══██╗╚════██║
-██║██║  ██║███████║
-╚═╝╚═╝  ╚═╝╚══════╝\
-""", COLS) + END)
-    for num in range(0, 6):
-        os.system("clear || cls")
-        if num % 2 == 1:
-            print(BRED + center_unicode("🚨   🚨  🚨    🚨  🚨   \r", COLS))
-        else:
-            print("")
-        print(title)
-        sleep(0.3)
-    flush_puts(center_colors("{0}Ironic Redistribution System ({1}IRS{2})"
-                             .format(BYELLOW, BRED, BYELLOW), COLS))
-
-    flush_puts(center_colors("{0}Made with 😈  by: {1}Kepoor Hampond \
-                             ({2}kepoorhampond{3})".format(BBLUE, BYELLOW,
-                             BRED, BYELLOW) + END, COLS))
-
-    flush_puts(center_colors("{0}Version: {1}".format(BBLUE, BYELLOW) +
-               pkg_resources.get_distribution("irs").version, COLS))
-
-
-def menu(unicode, time=0.01):
-    flush_puts("Choose option from menu:", time)
-    flush_puts("\t[{0}song{1}] Download Song".format(BGREEN, END), time)
-    flush_puts("\t[{0}album{1}] Download Album".format(BGREEN, END), time)
-    flush_puts("\t[{0}{1}{2}] Download Playlist"
-               .format(BGREEN, unicode[-1], END), time)
-    flush_puts("\t[{0}help{1}] Print This Menu".format(BGREEN, END), time)
-    flush_puts("\t[{0}exit{1}] Exit IRS".format(BGREEN, END), time)
-    print("")
-
-
-def console(ripper):
-    banner()
-    print(END)
-    if ripper.authorized is True:
-        unicode = [BGREEN + "✔" + END, "list"]
-    elif ripper.authorized is False:
-        unicode = [BRED + "✘" + END]
-    flush_puts("[{0}] Authenticated with Spotify".format(unicode[0]))
-    print("")
-    menu(unicode)
-    while True:
-        try:
-            choice = input("{0}irs{1}>{2} ".format(BBLUE, BGRAY, END))
-
-            if choice in ("exit", "e"):
-                raise KeyboardInterrupt
-
-            try:
-                if choice in ("song", "s"):
-                    song_name = input("Song name{0}:{1} ".format(BBLUE, END))
-                    artist_name = input("Artist name{0}:{1} "
-                                        .format(BBLUE, END))
-                    ripper.song(song_name, artist_name)
-
-                elif choice in ("album", "a"):
-                    album_name = input("Album name{0}:{1} ".format(BBLUE, END))
-                    ripper.spotify_list("album", album_name)
-
-                elif choice in ("list", "l") and ripper.authorized is True:
-                    username = input("Spotify Username{0}:{1} "
-                                     .format(BBLUE, END))
-                    list_name = input("Playlist Name{0}:{1} "
-                                      .format(BBLUE, END))
-                    ripper.spotify_list("playlist", list_name, username)
-
-                elif choice in ("help", "h", "?"):
-                    menu(unicode, 0)
-            except (KeyboardInterrupt, EOFError):
-                print("")
-                pass
-
-        except (KeyboardInterrupt, EOFError):
-            sys.exit(0)
-
-
-"""
-# =====================
-# Config File and Flags
-# =====================
-
-def check_sources(ripper, key, default=None, environment=False, where=None):
-    if where is not None:
-        tmp_args = ripper.args.get(where)
-    else:
-        tmp_args = ripper.args
-
-    if tmp_args.get(key):
-        return tmp_args.get(key)
-"""
-
-
-# ===========
-# CONFIG FILE
-# ===========
-
-def check_sources(ripper, key, default=None, environment=False, where=None):
-    # tmp_args = ripper.args
-    # if where is not None and ripper.args.get(where):
-    #     tmp_args = ripper.args.get("where")
-
-    if ripper.args.get(key):
-        return ripper.args.get(key)
-    elif CONFIG.get(key):
-        return CONFIG.get(key)
-    elif os.environ.get(key) and environment is True:
-        return os.environ.get(key)
-    else:
-        return default
-
-
-@staticmethods
-class Config:
-
-    def parse_spotify_creds(ripper):
-        CLIENT_ID = check_sources(ripper, "SPOTIFY_CLIENT_ID",
-                                  environment=True)
-        CLIENT_SECRET = check_sources(ripper, "SPOTIFY_CLIENT_SECRET",
-                                      environment=True)
-        return CLIENT_ID, CLIENT_SECRET
-
-    def parse_search_terms(ripper):
-        search_terms = check_sources(ripper, "additional_search_terms",
-                                     "lyrics")
-        return search_terms
-
-    def parse_artist(ripper):
-        artist = check_sources(ripper, "artist")
-        return artist
-
-    def parse_directory(ripper):
-        directory = check_sources(ripper, "custom_directory",
-                                  where="post_processors")
-        if directory is None:
-            directory = check_sources(ripper, "custom_directory", "~/Music")
-        return directory.replace("~", os.path.expanduser("~"))
-
-    def parse_default_flags(default=""):
-        if CONFIG.get("default_flags"):
-            args = sys.argv[1:] + CONFIG.get("default_flags")
-        else:
-            args = default
-        return args
-
-    def parse_organize(ripper):
-        organize = check_sources(ripper, "organize")
-        if organize is None:
-            return check_sources(ripper, "organize", False,
-                                 where="post_processors")
-        else:
-            return True

setup.cfg

@@ -1,5 +0,0 @@
-[bdist_wheel]
-# This flag says that the code is written to work on both Python 2 and Python
-# 3. If at all possible, it is good practice to do this. If you cannot, you
-# will need to generate wheels for each Python version that you support.
-universal=1

setup.py

@@ -1,22 +0,0 @@
-from setuptools import setup
-
-setup(
-    name='irs',
-    version='6.3.2',
-    description='A music downloader that just gets metadata.',
-    url='https://github.com/kepoorhampond/irs',
-    author='Kepoor Hampond',
-    author_email='kepoorh@gmail.com',
-    license='GPL',
-    packages =['irs'],
-    install_requires=[
-      'bs4',
-      'mutagen',
-      'youtube-dl',
-      'requests',
-      'spotipy',
-    ],
-    entry_points = {
-      'console_scripts': ['irs = irs.cli:main'],
-    },
-)

shard.lock

@@ -0,0 +1,10 @@
+version: 2.0
+shards:
+  json_mapping:
+    git: https://github.com/crystal-lang/json_mapping.cr.git
+    version: 0.1.0
+
+  ydl_binaries:
+    git: https://github.com/cooperhammond/ydl-binaries.git
+    version: 1.1.1+git.commit.c82e3937fee20fd076b1c73e24b2d0205e2cf0da
+

shard.yml

@@ -0,0 +1,17 @@
+name: irs
+version: 1.4.0
+
+authors:
+  - Cooper Hammond <kepoorh@gmail.com>
+
+targets:
+  irs:
+    main: src/irs.cr
+
+license: MIT
+
+dependencies:
+  ydl_binaries:
+    github: cooperhammond/ydl-binaries
+  json_mapping:
+    github: crystal-lang/json_mapping.cr

spec/irs_spec.cr

@@ -0,0 +1,35 @@
+require "./spec_helper"
+
+describe CLI do
+  # TODO: Write tests
+
+  it "can show help" do
+    run_CLI_with_args(["--help"])
+  end
+
+  it "can show version" do
+    run_CLI_with_args(["--version"])
+  end
+
+  # !!TODO: make a long and short version of the test suite
+  # TODO: makes so this doesn't need user input
+  it "can install ytdl and ffmpeg binaries" do
+    # run_CLI_with_args(["--install"])
+  end
+
+  it "can show config file loc" do
+    run_CLI_with_args(["--config"])
+  end
+
+  it "can download a single song" do
+    run_CLI_with_args(["--song", "Bohemian Rhapsody", "--artist", "Queen"])
+  end
+
+  it "can download an album" do
+    run_CLI_with_args(["--artist", "Arctic Monkeys", "--album", "Da Frame 2R / Matador"])
+  end
+
+  it "can download a playlist" do
+    run_CLI_with_args(["--artist", "prakkillian", "--playlist", "IRS Testing"])
+  end
+end

spec/spec_helper.cr

@@ -0,0 +1,10 @@
+require "spec"
+
+# https://github.com/mosop/stdio
+
+require "../src/bottle/cli"
+
+def run_CLI_with_args(argv : Array(String))
+    cli = CLI.new(argv)
+    cli.act_on_args
+end

src/bottle/cli.cr

@@ -0,0 +1,190 @@
+require "ydl_binaries"
+
+require "./config"
+require "./styles"
+require "./version"
+
+require "../glue/song"
+require "../glue/album"
+require "../glue/playlist"
+
+class CLI
+  # layout:
+  # [[shortflag, longflag], key, type]
+  @options = [
+    [["-h", "--help"], "help", "bool"],
+    [["-v", "--version"], "version", "bool"],
+    [["-i", "--install"], "install", "bool"],
+    [["-c", "--config"], "config", "bool"],
+    [["-a", "--artist"], "artist", "string"],
+    [["-s", "--song"], "song", "string"],
+    [["-A", "--album"], "album", "string"],
+    [["-p", "--playlist"], "playlist", "string"],
+    [["-u", "--url"], "url", "string"],
+    [["-S", "--select"], "select", "bool"],
+    [["--ask-skip"], "ask_skip", "bool"],
+    [["--apply"], "apply_file", "string"]
+  ]
+
+  @args : Hash(String, String)
+
+  def initialize(argv : Array(String))
+    @args = parse_args(argv)
+  end
+
+  def version
+    puts "irs v#{IRS::VERSION}"
+  end
+
+  def help
+    msg = <<-EOP
+    #{Style.bold "Usage: irs [--help] [--version] [--install]"}
+    #{Style.bold "           [-s <song> -a <artist>]"}
+    #{Style.bold "           [-A <album> -a <artist>]"}
+    #{Style.bold "           [-p <playlist> -a <username>]"}
+
+    #{Style.bold "Arguments:"}
+        #{Style.blue "-h, --help"}                  Show this help message and exit
+        #{Style.blue "-v, --version"}               Show the program version and exit
+        #{Style.blue "-i, --install"}               Download binaries to config location
+        #{Style.blue "-c, --config"}                Show config file location
+        #{Style.blue "-a, --artist <artist>"}       Specify artist name for downloading
+        #{Style.blue "-s, --song <song>"}           Specify song name to download
+        #{Style.blue "-A, --album <album>"}         Specify the album name to download
+        #{Style.blue "-p, --playlist <playlist>"}   Specify the playlist name to download
+        #{Style.blue "-u, --url <url>"}             Specify the youtube url to download from
+        #{Style.blue "                 "}           (for albums and playlists, the command-line
+        #{Style.blue "                 "}           argument is ignored, and it should be '')
+        #{Style.blue "-S, --select"}                Use a menu to choose each song's video source
+        #{Style.blue "--ask-skip"}                  Before every playlist/album song, ask to skip
+        #{Style.blue "--apply <file>"}              Apply metadata to a existing file
+
+    #{Style.bold "Examples:"}
+        $ #{Style.green %(irs --song "Bohemian Rhapsody" --artist "Queen")}
+        #{Style.dim %(# => downloads the song "Bohemian Rhapsody" by "Queen")}
+        $ #{Style.green %(irs --album "Demon Days" --artist "Gorillaz")}
+        #{Style.dim %(# => downloads the album "Demon Days" by "Gorillaz")}
+        $ #{Style.green %(irs --playlist "a different drummer" --artist "prakkillian")}
+        #{Style.dim %(# => downloads the playlist "a different drummer" by the user prakkillian)}
+
+    #{Style.bold "This project is licensed under the MIT license."}
+    #{Style.bold "Project page: <https://github.com/cooperhammond/irs>"}
+    EOP
+
+    puts msg
+  end
+
+  def act_on_args
+    Config.check_necessities
+
+    if @args["help"]? || @args.keys.size == 0
+      help
+
+    elsif @args["version"]?
+      version
+
+    elsif @args["install"]?
+      YdlBinaries.get_both(Config.binary_location)
+
+    elsif @args["config"]?
+      puts ENV["IRS_CONFIG_LOCATION"]?
+
+    elsif @args["song"]? && @args["artist"]?
+      s = Song.new(@args["song"], @args["artist"])
+      s.provide_client_keys(Config.client_key, Config.client_secret)
+      s.grab_it(flags: @args)
+      s.organize_it()
+
+    elsif @args["album"]? && @args["artist"]?
+      a = Album.new(@args["album"], @args["artist"])
+      a.provide_client_keys(Config.client_key, Config.client_secret)
+      a.grab_it(flags: @args)
+
+    elsif @args["playlist"]? && @args["artist"]?
+      p = Playlist.new(@args["playlist"], @args["artist"])
+      p.provide_client_keys(Config.client_key, Config.client_secret)
+      p.grab_it(flags: @args)
+
+    else
+      puts Style.red("Those arguments don't do anything when used that way.")
+      puts "Type `irs -h` to see usage."
+    end
+  end
+
+  private def parse_args(argv : Array(String)) : Hash(String, String)
+    arguments = {} of String => String
+
+    i = 0
+    current_key = ""
+    pass_next_arg = false
+    argv.each do |arg|
+      # If the previous arg was an arg flag, this is an arg, so pass it
+      if pass_next_arg
+        pass_next_arg = false
+        i += 1
+        next
+      end
+
+      flag = [] of Array(String) | String
+      valid_flag = false
+
+      @options.each do |option|
+        if option[0].includes?(arg)
+          flag = option
+          valid_flag = true
+          break
+        end
+      end
+
+      # ensure the flag is actually defined
+      if !valid_flag
+        arg_error argv, i, %("#{arg}" is an invalid flag or argument.)
+      end
+
+      # ensure there's an argument if the program needs one
+      if flag[2] == "string" && i + 1 >= argv.size
+        arg_error argv, i, %("#{arg}" needs an argument.)
+      end
+
+      key = flag[1].as(String)
+      if flag[2] == "string"
+        arguments[key] = argv[i + 1]
+        pass_next_arg = true
+      elsif flag[2] == "bool"
+        arguments[key] = "true"
+      end
+
+      i += 1
+    end
+
+    return arguments
+  end
+
+  private def arg_error(argv : Array(String), arg : Int32, msg : String) : Nil
+    precursor = "irs"
+
+    precursor += " " if arg != 0
+
+    if arg == 0
+      start = [] of String
+    else
+      start = argv[..arg - 1]
+    end
+    last = argv[arg + 1..]
+
+    distance = (precursor + start.join(" ")).size
+
+    print Style.dim(precursor + start.join(" "))
+    print Style.bold(Style.red(" " + argv[arg]).to_s)
+    puts Style.dim (" " + last.join(" "))
+
+    (0..distance).each do |i|
+      print " "
+    end
+    puts "^"
+
+    puts Style.red(Style.bold(msg).to_s)
+    puts "Type `irs -h` to see usage."
+    exit 1
+  end
+end

src/bottle/config.cr

@@ -0,0 +1,133 @@
+require "yaml"
+
+require "./styles"
+
+require "../search/spotify"
+
+EXAMPLE_CONFIG = <<-EOP
+#{Style.dim "exampleconfig.yml"}
+#{Style.dim "===="}
+#{Style.blue "search_terms"}: #{Style.green "\"lyrics\""}
+#{Style.blue "binary_directory"}: #{Style.green "~/.irs/bin"}
+#{Style.blue "music_directory"}: #{Style.green "~/Music"}
+#{Style.blue "filename_pattern"}: #{Style.green "\"{track_number} - {title}\""}
+#{Style.blue "directory_pattern"}: #{Style.green "\"{artist}/{album}\""}
+#{Style.blue "client_key"}: #{Style.green "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
+#{Style.blue "client_secret"}: #{Style.green "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
+#{Style.blue "single_folder_playlist"}: 
+  #{Style.blue "enabled"}: #{Style.green "true"}
+  #{Style.blue "retain_playlist_order"}: #{Style.green "true"}
+  #{Style.blue "unify_into_album"}: #{Style.green "false"}
+#{Style.dim "===="}
+EOP
+
+module Config
+  extend self
+
+  @@arguments = [
+    "search_terms",
+    "binary_directory",
+    "music_directory",
+    "filename_pattern",
+    "directory_pattern",
+    "client_key",
+    "client_secret",
+    "single_folder_playlist: enabled",
+    "single_folder_playlist: retain_playlist_order",
+    "single_folder_playlist: unify_into_album",
+  ]
+
+  @@conf = YAML.parse("")
+  begin
+    @@conf = YAML.parse(File.read(ENV["IRS_CONFIG_LOCATION"]))
+  rescue
+    puts Style.red "Before anything else, define the environment variable IRS_CONFIG_LOCATION pointing to a .yml file like this one."
+    puts EXAMPLE_CONFIG
+    puts Style.bold "See https://github.com/cooperhammond/irs for more information on the config file"
+    exit 1
+  end
+
+  def search_terms : String
+    return @@conf["search_terms"].to_s
+  end
+
+  def binary_location : String
+    path = @@conf["binary_directory"].to_s
+    return Path[path].expand(home: true).to_s
+  end
+
+  def music_directory : String
+    path = @@conf["music_directory"].to_s
+    return Path[path].expand(home: true).to_s
+  end
+  
+  def filename_pattern : String
+    return @@conf["filename_pattern"].to_s
+  end
+  
+  def directory_pattern : String
+    return @@conf["directory_pattern"].to_s
+  end
+
+  def client_key : String
+    return @@conf["client_key"].to_s
+  end
+
+  def client_secret : String
+    return @@conf["client_secret"].to_s
+  end
+
+  def single_folder_playlist? : Bool
+    return @@conf["single_folder_playlist"]["enabled"].as_bool
+  end
+
+  def retain_playlist_order? : Bool
+    return @@conf["single_folder_playlist"]["retain_playlist_order"].as_bool
+  end
+
+  def unify_into_album? : Bool
+    return @@conf["single_folder_playlist"]["unify_into_album"].as_bool
+  end
+
+  def check_necessities
+    missing_configs = [] of String
+    @@arguments.each do |argument|
+      if !check_conf(argument)
+        missing_configs.push(argument)
+      end
+    end
+    if missing_configs.size > 0
+      puts Style.red("You are missing the following key(s) in your YAML config file:")
+      missing_configs.each do |config|
+        puts "  " + config
+      end
+      puts "\nHere's an example of what your config should look like:"
+      puts EXAMPLE_CONFIG
+      puts Style.bold "See https://github.com/cooperhammond/irs for more information on the config file"
+      exit 1
+    end
+    spotify = SpotifySearcher.new
+    spotify.authorize(self.client_key, self.client_secret)
+    if !spotify.authorized?
+      puts Style.red("There's something wrong with your client key and/or client secret")
+      puts "Get your keys from https://developer.spotify.com/dashboard, and enter them in your config file"
+      puts "Your config file is at #{ENV["IRS_CONFIG_LOCATION"]}"
+      puts EXAMPLE_CONFIG
+      puts Style.bold "See https://github.com/cooperhammond/irs for more information on the config file"
+      exit 1
+    end
+  end
+
+  private def check_conf(key : String) : YAML::Any?
+    if key.includes?(": ")
+      args = key.split(": ")
+      if @@conf[args[0]]?
+        return @@conf[args[0]][args[1]]?
+      else
+        return @@conf[args[0]]?
+      end
+    else
+      return @@conf[key]?
+    end
+  end
+end

src/bottle/pattern.cr

@@ -0,0 +1,28 @@
+module Pattern
+  extend self
+
+  def parse(formatString : String, metadata : JSON::Any)
+    formatted : String = formatString
+
+    date : Array(String) = (metadata["album"]? || JSON.parse("{}"))["release_date"]?.to_s.split('-')
+
+    keys : Hash(String, String) = {
+      "artist" => ((metadata.dig?("artists") || JSON.parse("{}"))[0]? || JSON.parse("{}"))["name"]?.to_s,
+      "title" => metadata["name"]?.to_s,
+      "album" => (metadata["album"]? || JSON.parse("{}"))["name"]?.to_s,
+      "track_number" => metadata["track_number"]?.to_s,
+      "disc_number" => metadata["disc_number"]?.to_s,
+      "total_tracks" => (metadata["album"]? || JSON.parse("{}"))["total_tracks"]?.to_s,
+      "year" => date[0]?.to_s,
+      "month" => date[1]?.to_s,
+      "day" => date[2]?.to_s,
+      "id" => metadata["id"]?.to_s
+    }
+
+    keys.each do |pair|
+      formatted = formatted.gsub("{#{pair[0]}}", pair[1] || "")
+    end
+
+    return formatted
+  end
+end

src/bottle/styles.cr

@@ -0,0 +1,23 @@
+require "colorize"
+
+class Style
+  def self.bold(txt)
+    txt.colorize.mode(:bold).to_s
+  end
+
+  def self.dim(txt)
+    txt.colorize.mode(:dim).to_s
+  end
+
+  def self.blue(txt)
+    txt.colorize(:light_blue).to_s
+  end
+
+  def self.green(txt)
+    txt.colorize(:light_green).to_s
+  end
+
+  def self.red(txt)
+    txt.colorize(:light_red).to_s
+  end
+end

src/bottle/version.cr

@@ -0,0 +1,3 @@
+module IRS
+  VERSION = "1.4.0"
+end

src/glue/album.cr

@@ -0,0 +1,47 @@
+require "../bottle/config"
+
+require "./mapper"
+require "./song"
+require "./list"
+
+class Album < SpotifyList
+  @home_music_directory = Config.music_directory
+
+  # Uses the `spotify_searcher` defined in parent `SpotifyList` to find the
+  # correct metadata of the list
+  def find_it : JSON::Any
+    album = @spotify_searcher.find_item("album", {
+      "name"   => @list_name.as(String),
+      "artist" => @list_author.as(String),
+    })
+    if album
+      return album.as(JSON::Any)
+    else
+      puts "No album was found by that name and artist."
+      exit 1
+    end
+  end
+
+  # Will define specific metadata that may not be included in the raw return
+  # of spotify's album json. Moves the title of the album and the album art
+  # to the json of the single song
+  def organize_song_metadata(list : JSON::Any, datum : JSON::Any) : JSON::Any
+    album_metadata = parse_to_json(%(
+      {
+        "name": "#{list["name"]}",
+        "images": [{"url": "#{list["images"][0]["url"]}"}]
+      }
+    ))
+
+    prepped_data = TrackMapper.from_json(datum.to_json)
+    prepped_data.album = album_metadata
+
+    data = parse_to_json(prepped_data.to_json)
+
+    return data
+  end
+
+  private def organize(song : Song)
+    song.organize_it()
+  end
+end

src/glue/list.cr

@@ -0,0 +1,107 @@
+require "json"
+
+require "../search/spotify"
+require "../search/youtube"
+
+require "../interact/ripper"
+require "../interact/tagger"
+
+require "./song"
+
+# A parent class for downloading albums and playlists from spotify
+abstract class SpotifyList
+  @spotify_searcher = SpotifySearcher.new
+  @file_names = [] of String
+
+  @outputs : Hash(String, Array(String)) = {
+    "searching" => [
+      Style.bold("Searching for %l by %a ... \r"),
+      Style.green("+ ") + Style.bold("%l by %a                                 \n")
+    ],
+    "url" => [
+      Style.bold("When prompted for a URL, provide a youtube URL or press enter to scrape for one\n")
+    ]
+  }
+
+  def initialize(@list_name : String, @list_author : String?)
+  end
+
+  # Finds the list, and downloads all of the songs using the `Song` class
+  def grab_it(flags = {} of String => String)
+    ask_url = flags["url"]?
+    ask_skip = flags["ask_skip"]?
+    is_playlist = flags["playlist"]?
+  
+    if !@spotify_searcher.authorized?
+      raise("Need to call provide_client_keys on Album or Playlist class.")
+    end
+
+    if ask_url
+      outputter("url", 0)
+    end
+
+    outputter("searching", 0)
+    list = find_it()
+    outputter("searching", 1)
+    contents = list["tracks"]["items"].as_a
+
+    i = 0
+    contents.each do |datum|
+      i += 1
+      if datum["track"]?
+        datum = datum["track"]
+      end
+
+      data = organize_song_metadata(list, datum)
+
+      s_name = data["name"].to_s
+      s_artist = data["artists"][0]["name"].to_s
+
+      song = Song.new(s_name, s_artist)
+      song.provide_spotify(@spotify_searcher)
+      song.provide_metadata(data)
+
+      puts Style.bold("[#{i}/#{contents.size}]")
+
+      unless ask_skip && skip?(s_name, s_artist, is_playlist)
+        song.grab_it(flags: flags)
+        organize(song)
+      else
+        puts "Skipping..."
+      end
+    end
+  end
+
+  # Will authorize the class associated `SpotifySearcher`
+  def provide_client_keys(client_key : String, client_secret : String)
+    @spotify_searcher.authorize(client_key, client_secret)
+  end
+
+  private def skip?(name, artist, is_playlist)
+    print "Skip #{Style.blue name}" +
+      (is_playlist ? " (by #{Style.green artist})": "") + "? "
+    response = gets
+    return response && response.lstrip.downcase.starts_with? "y"
+  end
+
+  private def outputter(key : String, index : Int32)
+    text = @outputs[key][index]
+      .gsub("%l", @list_name)
+      .gsub("%a", @list_author)
+    print text
+  end
+
+  # Defined in subclasses, will return the appropriate information or call an
+  # error if the info is not found and exit
+  abstract def find_it : JSON::Any
+
+  # If there's a need to organize the individual song data so that the `Song`
+  # class can better handle it, this function will be defined in the subclass
+  private abstract def organize_song_metadata(list : JSON::Any,
+                                              datum : JSON::Any) : JSON::Any
+
+  # Will define the specific type of organization for a list of songs.
+  # Needed because most people want albums sorted by artist, but playlists all
+  # in one folder
+  private abstract def organize(song : Song)
+end

src/glue/mapper.cr

@@ -0,0 +1,57 @@
+require "json"
+require "json_mapping"
+
+class PlaylistExtensionMapper
+  JSON.mapping(
+    tracks: {
+      type:   PlaylistTracksMapper,
+      setter: true,
+    },
+    id: String,
+    images: JSON::Any,
+    name: String,
+    owner: JSON::Any,
+    type: String
+  )
+end
+
+class PlaylistTracksMapper
+  JSON.mapping(
+    items: {
+      type:   Array(JSON::Any),
+      setter: true,
+    },
+    total: Int32
+  )
+end
+
+class TrackMapper
+  JSON.mapping(
+    album: {
+      type:    JSON::Any,
+      nilable: true,
+      setter:  true,
+    },
+    artists: {
+      type: Array(JSON::Any),
+      setter: true  
+    },
+    disc_number: {
+      type: Int32,
+      setter: true
+    },
+    id: String,
+    name: String,
+    track_number: {
+      type: Int32,
+      setter: true
+    },
+    duration_ms: Int32,
+    type: String,
+    uri: String
+  )
+end
+
+def parse_to_json(string_json : String) : JSON::Any
+  return JSON.parse(string_json)
+end

src/glue/playlist.cr

@@ -0,0 +1,76 @@
+require "json"
+
+require "../bottle/config"
+
+require "./song"
+require "./list"
+require "./mapper"
+
+class Playlist < SpotifyList
+  @song_index = 1
+  @home_music_directory = Config.music_directory
+  @playlist : JSON::Any?
+
+  # Uses the `spotify_searcher` defined in parent `SpotifyList` to find the
+  # correct metadata of the list
+  def find_it : JSON::Any
+    @playlist = @spotify_searcher.find_item("playlist", {
+      "name"     => @list_name.as(String),
+      "username" => @list_author.as(String),
+    })
+    if @playlist
+      return @playlist.as(JSON::Any)
+    else
+      puts "No playlists were found by that name and user."
+      exit 1
+    end
+  end
+
+  # Will define specific metadata that may not be included in the raw return
+  # of spotify's album json. Moves the title of the album and the album art
+  # to the json of the single song
+  def organize_song_metadata(list : JSON::Any, datum : JSON::Any) : JSON::Any
+    data = datum
+
+    if Config.retain_playlist_order?
+      track = TrackMapper.from_json(data.to_json)
+      track.track_number = @song_index
+      track.disc_number = 1
+      data = JSON.parse(track.to_json)
+    end
+
+    if Config.unify_into_album?
+      track = TrackMapper.from_json(data.to_json)
+      track.album = JSON.parse(%({
+        "name": "#{list["name"]}",
+        "images": [{"url": "#{list["images"][0]["url"]}"}]
+      }))
+      track.artists.push(JSON.parse(%({
+        "name": "#{list["owner"]["display_name"]}",
+        "owner": true
+      })))
+      data = JSON.parse(track.to_json)
+    end
+
+    @song_index += 1
+
+    return data
+  end
+
+  private def organize(song : Song)
+    if Config.single_folder_playlist?
+      path = Path[@home_music_directory].expand(home: true)
+      path = path / @playlist.as(JSON::Any)["name"].to_s
+        .gsub(/[\/]/, "").gsub("  ", " ")
+      strpath = path.to_s
+      if !File.directory?(strpath)
+        FileUtils.mkdir_p(strpath)
+      end
+      safe_filename = song.filename.gsub(/[\/]/, "").gsub("  ", " ")
+      FileUtils.cp("./" + song.filename, (path / safe_filename).to_s)
+      FileUtils.rm("./" + song.filename)
+    else
+      song.organize_it()
+    end
+  end
+end

src/glue/song.cr

@@ -0,0 +1,245 @@
+require "../search/spotify"
+require "../search/youtube"
+
+require "../interact/ripper"
+require "../interact/tagger"
+
+require "../bottle/config"
+require "../bottle/pattern"
+require "../bottle/styles"
+
+class Song
+  @spotify_searcher = SpotifySearcher.new
+  @client_id = ""
+  @client_secret = ""
+
+  @metadata : JSON::Any?
+  getter filename = ""
+  @artist = ""
+  @album = ""
+
+  @outputs : Hash(String, Array(String)) = {
+    "intro" => [Style.bold("[%s by %a]\n")],
+    "metadata" => [
+      "  Searching for metadata ...\r",
+      Style.green("  + ") + Style.dim("Metadata found                  \n")
+    ],
+    "url" => [
+      "  Searching for URL ...\r",
+      Style.green("  + ") + Style.dim("URL found                       \n"),
+      "  Validating URL ...\r",
+      Style.green("  + ") + Style.dim("URL validated                   \n"),
+      "  URL?: "
+    ],
+    "download" => [
+      "  Downloading video:\n",
+      Style.green("\r  + ") + Style.dim("Converted to mp3              \n")
+    ],
+    "albumart" => [
+      "  Downloading album art ...\r",
+      Style.green("  + ") + Style.dim("Album art downloaded            \n")
+    ],
+    "tagging" => [
+      "  Attaching metadata ...\r",
+      Style.green("  + ") + Style.dim("Metadata attached               \n")
+    ],
+    "finished" => [
+      Style.green("  + ") + "Finished!\n"
+    ]
+  }
+
+  def initialize(@song_name : String, @artist_name : String)
+  end
+
+  # Find, downloads, and tags the mp3 song that this class represents.
+  # Optionally takes a youtube URL to download from
+  #
+  # ```
+  # Song.new("Bohemian Rhapsody", "Queen").grab_it
+  # ```
+  def grab_it(url : (String | Nil) = nil, flags = {} of String => String)
+    passed_url : (String | Nil) = flags["url"]?
+    passed_file : (String | Nil) = flags["apply_file"]?
+    select_link = flags["select"]?
+
+    outputter("intro", 0)
+
+    if !@spotify_searcher.authorized? && !@metadata
+      if @client_id != "" && @client_secret != ""
+        @spotify_searcher.authorize(@client_id, @client_secret)
+      else
+        raise("Need to call either `provide_metadata`, `provide_spotify`, " +
+              "or `provide_client_keys` so that Spotify can be interfaced with.")
+      end
+    end
+
+    if !@metadata
+      outputter("metadata", 0)
+      @metadata = @spotify_searcher.find_item("track", {
+        "name"   => @song_name,
+        "artist" => @artist_name,
+      })
+
+      if !@metadata
+        raise("There was no metadata found on Spotify for " +
+              %("#{@song_name}" by "#{@artist_name}". ) +
+              "Check your input and try again.")
+      end
+      outputter("metadata", 1)
+    end
+
+    data = @metadata.as(JSON::Any)
+    @song_name = data["name"].as_s
+    @artist_name = data["artists"][0]["name"].as_s
+    @filename = "#{Pattern.parse(Config.filename_pattern, data)}.mp3"
+
+    if passed_file
+      puts Style.green("  +") + Style.dim(" Moving file: ") + passed_file
+      File.rename(passed_file, @filename)
+    else
+      if passed_url
+        if passed_url.strip != ""
+          url = passed_url
+        else
+          outputter("url", 4)
+          url = gets
+          if !url.nil? && url.strip == ""
+            url = nil
+          end
+        end
+      end
+
+      if !url
+        outputter("url", 0)
+        url = Youtube.find_url(data, flags: flags)
+        if !url
+          raise("There was no url found on youtube for " +
+                %("#{@song_name}" by "#{@artist_name}. ) +
+                "Check your input and try again.")
+        end
+        outputter("url", 1)
+      else
+        outputter("url", 2)
+        url = Youtube.validate_url(url)
+        if !url
+          raise("The url is an invalid youtube URL " +
+                "Check the URL and try again")
+        end
+        outputter("url", 3)
+      end
+
+      outputter("download", 0)
+      Ripper.download_mp3(url.as(String), @filename)
+      outputter("download", 1)
+    end
+
+    outputter("albumart", 0)
+    temp_albumart_filename = ".tempalbumart.jpg"
+    HTTP::Client.get(data["album"]["images"][0]["url"].as_s) do |response|
+      File.write(temp_albumart_filename, response.body_io)
+    end
+    outputter("albumart", 0)
+
+    # check if song's metadata has been modded in playlist, update artist accordingly
+    if data["artists"][-1]["owner"]?
+      @artist = data["artists"][-1]["name"].as_s
+    else
+      @artist = data["artists"][0]["name"].as_s
+    end
+    @album = data["album"]["name"].as_s
+
+    tagger = Tags.new(@filename)
+    tagger.add_album_art(temp_albumart_filename)
+    tagger.add_text_tag("title", data["name"].as_s)
+    tagger.add_text_tag("artist", @artist)
+
+    if !@album.empty?
+      tagger.add_text_tag("album", @album)
+    end
+
+    if genre = @spotify_searcher.find_genre(data["artists"][0]["id"].as_s)
+      tagger.add_text_tag("genre", genre)
+    end
+
+    tagger.add_text_tag("track", data["track_number"].to_s)
+    tagger.add_text_tag("disc", data["disc_number"].to_s)
+
+    outputter("tagging", 0)
+    tagger.save
+    File.delete(temp_albumart_filename)
+    outputter("tagging", 1)
+
+    outputter("finished", 0)
+  end
+
+  # Will organize the song into the user's provided music directory
+  # in the user's provided structure
+  # Must be called AFTER the song has been downloaded.
+  #
+  # ```
+  # s = Song.new("Bohemian Rhapsody", "Queen").grab_it
+  # s.organize_it()
+  # # With
+  # # directory_pattern = "{artist}/{album}"
+  # # filename_pattern = "{track_number} - {title}"
+  # # Mp3 will be moved to
+  # # /home/cooper/Music/Queen/A Night At The Opera/1 - Bohemian Rhapsody.mp3
+  # ```
+  def organize_it()
+    path = Path[Config.music_directory].expand(home: true)
+    Pattern.parse(Config.directory_pattern, @metadata.as(JSON::Any)).split('/').each do |dir|
+      path = path / dir.gsub(/[\/]/, "").gsub("  ", " ")
+    end
+    strpath = path.to_s
+    if !File.directory?(strpath)
+      FileUtils.mkdir_p(strpath)
+    end
+    safe_filename = @filename.gsub(/[\/]/, "").gsub("  ", " ")
+    FileUtils.cp("./" + @filename, (path / safe_filename).to_s)
+    FileUtils.rm("./" + @filename)
+  end
+
+  # Provide metadata so that it doesn't have to find it. Useful for overwriting
+  # metadata. Must be called if provide_client_keys and provide_spotify are not
+  # called.
+  #
+  # ```
+  # Song.new(...).provide_metadata(...).grab_it
+  # ```
+  def provide_metadata(metadata : JSON::Any) : self
+    @metadata = metadata
+    return self
+  end
+
+  # Provide an already authenticated `SpotifySearcher` class. Useful to avoid
+  # authenticating over and over again. Must be called if provide_metadata and
+  # provide_client_keys are not called.
+  #
+  # ```
+  # Song.new(...).provide_spotify(SpotifySearcher.new
+  #   .authenticate("XXXXXXXXXX", "XXXXXXXXXXX")).grab_it
+  # ```
+  def provide_spotify(spotify : SpotifySearcher) : self
+    @spotify_searcher = spotify
+    return self
+  end
+
+  # Provide spotify client keys. Must be called if provide_metadata and
+  # provide_spotify are not called.
+  #
+  # ```
+  # Song.new(...).provide_client_keys("XXXXXXXXXX", "XXXXXXXXX").grab_it
+  # ```
+  def provide_client_keys(client_id : String, client_secret : String) : self
+    @client_id = client_id
+    @client_secret = client_secret
+    return self
+  end
+
+  private def outputter(key : String, index : Int32)
+    text = @outputs[key][index]
+      .gsub("%s", @song_name)
+      .gsub("%a", @artist_name)
+    print text
+  end
+end

src/interact/future.cr

@@ -0,0 +1,157 @@
+# copy and pasted from crystal 0.33.1
+# https://github.com/crystal-lang/crystal/blob/18e76172444c7bd07f58bf360bc21981b667668d/src/concurrent/future.cr#L138
+
+
+# :nodoc:
+class Concurrent::Future(R)
+  enum State
+    Idle
+    Delayed
+    Running
+    Completed
+    Canceled
+  end
+
+  @value : R?
+  @error : Exception?
+  @delay : Float64
+
+  def initialize(run_immediately = true, delay = 0.0, &@block : -> R)
+    @state = State::Idle
+    @value = nil
+    @error = nil
+    @channel = Channel(Nil).new
+    @delay = delay.to_f
+    @cancel_msg = nil
+
+    spawn_compute if run_immediately
+  end
+
+  def get
+    wait
+    value_or_raise
+  end
+
+  def success?
+    completed? && !@error
+  end
+
+  def failure?
+    completed? && @error
+  end
+
+  def canceled?
+    @state == State::Canceled
+  end
+
+  def completed?
+    @state == State::Completed
+  end
+
+  def running?
+    @state == State::Running
+  end
+
+  def delayed?
+    @state == State::Delayed
+  end
+
+  def idle?
+    @state == State::Idle
+  end
+
+  def cancel(msg = "Future canceled, you reached the [End of Time]")
+    return if @state >= State::Completed
+    @state = State::Canceled
+    @cancel_msg = msg
+    @channel.close
+    nil
+  end
+
+  private def compute
+    return if @state >= State::Delayed
+    run_compute
+  end
+
+  private def spawn_compute
+    return if @state >= State::Delayed
+
+    @state = @delay > 0 ? State::Delayed : State::Running
+
+    spawn { run_compute }
+  end
+
+  private def run_compute
+    delay = @delay
+
+    if delay > 0
+      sleep delay
+      return if @state >= State::Canceled
+      @state = State::Running
+    end
+
+    begin
+      @value = @block.call
+    rescue ex
+      @error = ex
+    ensure
+      @channel.close
+      @state = State::Completed
+    end
+  end
+
+  private def wait
+    return if @state >= State::Completed
+    compute
+    @channel.receive?
+  end
+
+  private def value_or_raise
+    raise Exception.new(@cancel_msg) if @state == State::Canceled
+
+    value = @value
+    if value.is_a?(R)
+      value
+    elsif error = @error
+      raise error
+    else
+      raise "compiler bug"
+    end
+  end
+end
+
+# Spawns a `Fiber` to compute *&block* in the background after *delay* has elapsed.
+# Access to get is synchronized between fibers.  *&block* is only called once.
+# May be canceled before *&block* is called by calling `cancel`.
+# ```
+# d = delay(1) { Process.kill(Process.pid) }
+# long_operation
+# d.cancel
+# ```
+def delay(delay, &block : -> _)
+  Concurrent::Future.new delay: delay, &block
+end
+
+# Spawns a `Fiber` to compute *&block* in the background.
+# Access to get is synchronized between fibers.  *&block* is only called once.
+# ```
+# f = future { http_request }
+# ... other actions ...
+# f.get #=> String
+# ```
+def future(&exp : -> _)
+  Concurrent::Future.new &exp
+end
+
+# Conditionally spawns a `Fiber` to run *&block* in the background.
+# Access to get is synchronized between fibers.  *&block* is only called once.
+# *&block* doesn't run by default, only when `get` is called.
+# ```
+# l = lazy { expensive_computation }
+# spawn { maybe_use_computation(l) }
+# spawn { maybe_use_computation(l) }
+# ```
+def lazy(&block : -> _)
+  Concurrent::Future.new run_immediately: false, &block
+end
+

src/interact/logger.cr

@@ -0,0 +1,90 @@
+require "./future"
+
+class Logger
+  @done_signal = "---DONE---"
+
+  @command : String
+
+  # *command* is the bash command that you want to run and capture the output
+  # of. *@log_name* is the name of the log file you want to temporarily create.
+  # *@sleept* is the time you want to wait before rechecking if the command has
+  # started yet, probably something you don't want to worry about
+  def initialize(command : String, @log_name : String, @sleept = 0.01)
+    # Have the command output its information to a log and after the command is
+    # finished, append an end signal to the document
+    @command = "#{command} > #{@log_name} "            # standard output to log
+    @command += "2> #{@log_name} && "                  # errors to log
+    @command += "echo #{@done_signal} >> #{@log_name}" #
+  end
+
+  # Run @command in the background and pipe its output to the log file, with
+  # something constantly monitoring the log file and yielding each new line to
+  # the block call. Useful for changing the output of binaries you don't have
+  # much control over.
+  # Note that the created temp log will be deleted unless the command fails
+  # its exit or .start is called with delete_file: false
+  #
+  # ```
+  # l = Logger.new(".temp.log", %(echo "CIA spying" && sleep 2 && echo "new veggie tales season"))
+  # l.start do |output, index|
+  #   case output
+  #   when "CIA spying"
+  #     puts "i sleep"
+  #   when .includes?("veggie tales")
+  #     puts "real shit"
+  #   end
+  # end
+  # ```
+  def start(delete_file = true, &block) : Bool
+    # Delete the log if it already exists
+    File.delete(@log_name) if File.exists?(@log_name)
+
+    # Run the command in the background
+    called = future {
+      system(@command)
+    }
+
+    # Wait for the log file to be written to
+    while !File.exists?(@log_name)
+      sleep @sleept
+    end
+
+    log = File.open(@log_name)
+    log_content = read_file(log)
+    index = 0
+
+    while true
+      temp_content = read_file(log)
+
+      # make sure that there is new data
+      if temp_content.size > 0 && log_content != temp_content
+        log_content = temp_content
+
+        # break the loop if the command has completed
+        break if log_content[0] == @done_signal
+
+        # give the line and index to the block
+        yield log_content[0], index
+        index += 1
+      end
+    end
+
+    status = called.get
+    if status == true && delete_file == true
+      log.delete
+    end
+
+    return called.get
+  end
+
+  # Reads each line of the file into an Array of Strings
+  private def read_file(file : IO) : Array(String)
+    content = [] of String
+
+    file.each_line do |line|
+      content.push(line)
+    end
+
+    return content
+  end
+end

src/interact/ripper.cr

@@ -0,0 +1,67 @@
+require "./logger"
+require "../bottle/config"
+require "../bottle/styles"
+
+module Ripper
+  extend self
+
+  BIN_LOC = Path[Config.binary_location]
+
+  # Downloads the video from the given *video_url* using the youtube-dl binary
+  # Will create any directories that don't exist specified in *output_filename*
+  #
+  # ```
+  # Ripper.download_mp3("https://youtube.com/watch?v=0xnciFWAqa0",
+  #   "Queen/A Night At The Opera/Bohemian Rhapsody.mp3")
+  # ```
+  def download_mp3(video_url : String, output_filename : String)
+    ydl_loc = BIN_LOC.join("youtube-dl")
+
+    # remove the extension that will be added on by ydl
+    output_filename = output_filename.split(".")[..-2].join(".")
+
+    options = {
+      "--output" => %("#{output_filename}.%(ext)s"), # auto-add correct ext
+      # "--quiet" => "",
+      "--verbose"         => "",
+      "--ffmpeg-location" => BIN_LOC,
+      "--extract-audio"   => "",
+      "--audio-format"    => "mp3",
+      "--audio-quality"   => "0",
+    }
+
+    command = ydl_loc.to_s + " " + video_url
+    options.keys.each do |option|
+      command += " #{option} #{options[option]}"
+    end
+
+    l = Logger.new(command, ".ripper.log")
+    o = RipperOutputCensor.new
+
+    return l.start do |line, index|
+      o.censor_output(line, index)
+    end
+  end
+
+  # An internal class that will keep track of what to output to the user or
+  # what should be hidden.
+  private class RipperOutputCensor
+    @dl_status_index = 0
+
+    def censor_output(line : String, index : Int32)
+      case line
+      when .includes? "[download]"
+        if @dl_status_index != 0
+          print "\e[1A"
+          print "\e[0K\r"
+        end
+        puts line.sub("[download]", "   ")
+        @dl_status_index += 1
+
+        if line.includes? "100%"
+          print "  Converting to mp3 ..."
+        end
+      end
+    end
+  end
+end

src/interact/tagger.cr

@@ -0,0 +1,62 @@
+require "../bottle/config"
+
+# Uses FFMPEG binary to add metadata to mp3 files
+# ```
+# t = Tags.new("bohem rap.mp3")
+# t.add_album_art("a night at the opera album cover.jpg")
+# t.add_text_tag("title", "Bohemian Rhapsody")
+# t.save
+# ```
+class Tags
+  # TODO: export this path to a config file
+  @BIN_LOC = Config.binary_location
+  @query_args = [] of String
+
+  # initialize the class with an already created MP3
+  def initialize(@filename : String)
+    if !File.exists?(@filename)
+      raise "MP3 not found at location: #{@filename}"
+    end
+
+    @query_args.push(%(-i "#{@filename}"))
+  end
+
+  # Add album art to the mp3. Album art must be added BEFORE text tags are.
+  # Check the usage above to see a working example.
+  def add_album_art(image_location : String) : Nil
+    if !File.exists?(image_location)
+      raise "Image file not found at location: #{image_location}"
+    end
+
+    @query_args.push(%(-i "#{image_location}"))
+    @query_args.push("-map 0:0 -map 1:0")
+    @query_args.push("-c copy")
+    @query_args.push("-id3v2_version 3")
+    @query_args.push(%(-metadata:s:v title="Album cover"))
+    @query_args.push(%(-metadata:s:v comment="Cover (front)"))
+    @query_args.push(%(-metadata:s:v title="Album cover"))
+  end
+
+  # Add a text tag to the mp3. If you want to see what text tags are supported,
+  # check out: https://wiki.multimedia.cx/index.php?title=FFmpeg_Metadata
+  def add_text_tag(key : String, value : String) : Nil
+    @query_args.push(%(-metadata #{key}="#{value}"))
+  end
+
+  # Run the necessary commands to attach album art to the mp3
+  def save : Nil
+    @query_args.push(%("_#{@filename}"))
+    command = @BIN_LOC + "/ffmpeg " + @query_args.join(" ")
+
+    l = Logger.new(command, ".tagger.log")
+    l.start { |line, start| }
+
+    File.delete(@filename)
+    File.rename("_" + @filename, @filename)
+  end
+end
+
+# a = Tags.new("test.mp3")
+# a.add_text_tag("title", "Warwick Avenue")
+# a.add_album_art("file.png")
+# a.save()

src/irs.cr

@@ -0,0 +1,8 @@
+require "./bottle/cli"
+
+def main
+  cli = CLI.new(ARGV)
+  cli.act_on_args
+end
+
+main()

src/search/ranking.cr

@@ -0,0 +1,144 @@
+alias VID_VALUE_CLASS = String
+alias VID_METADATA_CLASS = Hash(String, VID_VALUE_CLASS)
+alias YT_METADATA_CLASS = Array(VID_METADATA_CLASS)
+
+module Ranker
+  extend self
+
+  GARBAGE_PHRASES = [
+    "cover", "album", "live", "clean", "version", "full", "full album", "row",
+    "at", "@", "session", "how to", "npr music", "reimagined", "version",
+    "trailer"
+  ]
+
+  GOLDEN_PHRASES = [
+    "official video", "official music video",
+  ]
+
+  # Will rank videos according to their title and the user input, returns a sorted array of hashes
+  # of the points a song was assigned and its original index
+  # *spotify_metadata* is the metadate (from spotify) of the song that you want
+  # *yt_metadata* is an array of hashes with metadata scraped from the youtube search result page
+  # *query* is the query that you submitted to youtube for the results you now have
+  # ```
+  # Ranker.rank_videos(spotify_metadata, yt_metadata, query)
+  # => [
+  #      {"points" => x, "index" => x},
+  #      ...
+  #    ]
+  # ```
+  # "index" corresponds to the original index of the song in yt_metadata
+  def rank_videos(spotify_metadata : JSON::Any, yt_metadata : YT_METADATA_CLASS,
+                  query : String) : Array(Hash(String, Int32))
+    points = [] of Hash(String, Int32)
+    index = 0
+
+    actual_song_name = spotify_metadata["name"].as_s
+    actual_artist_name = spotify_metadata["artists"][0]["name"].as_s
+
+    yt_metadata.each do |vid|
+      pts = 0
+
+      pts += points_string_compare(actual_song_name, vid["title"])
+      pts += points_string_compare(actual_artist_name, vid["title"])
+      pts += count_buzzphrases(query, vid["title"])
+      pts += compare_timestamps(spotify_metadata, vid)
+
+      points.push({
+        "points" => pts,
+        "index"  => index,
+      })
+      index += 1
+    end
+
+    # Sort first by points and then by original index of the song
+    points.sort! { |a, b|
+      if b["points"] == a["points"]
+        a["index"] <=> b["index"]
+      else
+        b["points"] <=> a["points"]
+      end
+    }
+
+    return points
+  end
+
+  # SINGULAR COMPONENT OF RANKING ALGORITHM
+  private def compare_timestamps(spotify_metadata : JSON::Any, node : VID_METADATA_CLASS) : Int32
+    # puts spotify_metadata.to_pretty_json()
+    actual_time = spotify_metadata["duration_ms"].as_i
+    vid_time = node["duration_ms"].to_i
+
+    difference = (actual_time - vid_time).abs 
+
+    # puts "actual: #{actual_time}, vid: #{vid_time}"
+    # puts "\tdiff: #{difference}"
+    # puts "\ttitle: #{node["title"]}"
+
+    if difference <= 1000
+      return 3
+    elsif difference <= 2000
+      return 2
+    elsif difference <= 5000
+      return 1
+    else 
+      return 0
+    end
+  end
+
+  # SINGULAR COMPONENT OF RANKING ALGORITHM
+  # Returns an `Int` based off the number of points worth assigning to the
+  # matchiness of the string. First the strings are downcased and then all
+  # nonalphanumeric characters are stripped.
+  # If *item1* includes *item2*, return 3 pts.
+  # If after the items have been blanked, *item1* includes *item2*,
+  #   return 1 pts.
+  # Else, return 0 pts.
+  private def points_string_compare(item1 : String, item2 : String) : Int32
+    if item2.includes?(item1)
+      return 3
+    end
+
+    item1 = item1.downcase.gsub(/[^a-z0-9]/, "")
+    item2 = item2.downcase.gsub(/[^a-z0-9]/, "")
+
+    if item2.includes?(item1)
+      return 1
+    else
+      return 0
+    end
+  end
+
+  # SINGULAR COMPONENT OF RANKING ALGORITHM
+  # Checks if there are any phrases in the title of the video that would
+  # indicate audio having what we want.
+  # *video_name* is the title of the video, and *query* is what the user the
+  # program searched for. *query* is needed in order to make sure we're not
+  # subtracting points from something that's naturally in the title
+  private def count_buzzphrases(query : String, video_name : String) : Int32
+    good_phrases = 0
+    bad_phrases = 0
+
+    GOLDEN_PHRASES.each do |gold_phrase|
+      gold_phrase = gold_phrase.downcase.gsub(/[^a-z0-9]/, "")
+
+      if query.downcase.gsub(/[^a-z0-9]/, "").includes?(gold_phrase)
+        next
+      elsif video_name.downcase.gsub(/[^a-z0-9]/, "").includes?(gold_phrase)
+        good_phrases += 1
+      end
+    end
+
+    GARBAGE_PHRASES.each do |garbage_phrase|
+      garbage_phrase = garbage_phrase.downcase.gsub(/[^a-z0-9]/, "")
+
+      if query.downcase.gsub(/[^a-z0-9]/, "").includes?(garbage_phrase)
+        next
+      elsif video_name.downcase.gsub(/[^a-z0-9]/, "").includes?(garbage_phrase)
+        bad_phrases += 1
+      end
+    end
+
+    return good_phrases - bad_phrases
+  end
+end

src/search/spotify.cr

@@ -0,0 +1,349 @@
+require "http"
+require "json"
+require "base64"
+
+require "../glue/mapper"
+
+class SpotifySearcher
+  @root_url = Path["https://api.spotify.com/v1/"]
+
+  @access_header : (HTTP::Headers | Nil) = nil
+  @authorized = false
+
+  # Saves an access token for future program use with spotify using client IDs.
+  # Specs defined on spotify's developer api:
+  # https://developer.spotify.com/documentation/general/guides/authorization-guide/#client-credentials-flow
+  #
+  # ```
+  # SpotifySearcher.new.authorize("XXXXXXXXXX", "XXXXXXXXXX")
+  # ```
+  def authorize(client_id : String, client_secret : String) : self
+    auth_url = "https://accounts.spotify.com/api/token"
+
+    headers = HTTP::Headers{
+      "Authorization" => "Basic " +
+                         Base64.strict_encode "#{client_id}:#{client_secret}",
+    }
+
+    payload = "grant_type=client_credentials"
+
+    response = HTTP::Client.post(auth_url, headers: headers, form: payload)
+    if response.status_code != 200
+      @authorized = false
+      return self
+    end
+
+    access_token = JSON.parse(response.body)["access_token"]
+
+    @access_header = HTTP::Headers{
+      "Authorization" => "Bearer #{access_token}",
+    }
+
+    @authorized = true
+
+    return self
+  end
+
+  # Check if the class is authorized or not
+  def authorized? : Bool
+    return @authorized
+  end
+
+  # Searches spotify with the specified parameters for the specified items
+  #
+  # ```
+  # spotify_searcher.find_item("track", {
+  #   "artist" => "Queen",
+  #   "track" => "Bohemian Rhapsody"
+  # })
+  # => {track metadata}
+  # ```
+  def find_item(item_type : String, item_parameters : Hash, offset = 0,
+                limit = 20) : JSON::Any?
+    query = generate_query(item_type, item_parameters)
+
+    url = "search?q=#{query}&type=#{item_type}&limit=#{limit}&offset=#{offset}"
+    url = @root_url.join(url).to_s
+
+    response = HTTP::Client.get(url, headers: @access_header)
+    error_check(response)
+
+    items = JSON.parse(response.body)[item_type + "s"]["items"].as_a
+
+    points = rank_items(items, item_parameters)
+
+    to_return = nil
+
+    begin
+      # this means no points were assigned so don't return the "best guess"
+      if points[0][0] <= 0
+        to_return = nil
+      else
+        to_return = get_item(item_type, items[points[0][1]]["id"].to_s)
+      end
+    rescue IndexError
+      to_return = nil
+    end
+
+    # if this triggers, it means that a playlist has failed to be found, so
+    # the search will be bootstrapped into find_user_playlist
+    if to_return == nil && item_type == "playlist"
+      return find_user_playlist(
+        item_parameters["username"],
+        item_parameters["name"]
+      )
+    end
+
+    return to_return
+  end
+
+  # Grabs a users playlists and searches through it for the specified playlist
+  #
+  # ```
+  # spotify_searcher.find_user_playlist("prakkillian", "the little man")
+  # => {playlist metadata}
+  # ```
+  def find_user_playlist(username : String, name : String, offset = 0,
+                         limit = 20) : JSON::Any?
+    url = "users/#{username}/playlists?limit=#{limit}&offset=#{offset}"
+    url = @root_url.join(url).to_s
+
+    response = HTTP::Client.get(url, headers: @access_header)
+    error_check(response)
+    body = JSON.parse(response.body)
+
+    items = body["items"]
+    points = [] of Array(Int32)
+
+    items.as_a.each_index do |i|
+      points.push([points_compare(items[i]["name"].to_s, name), i])
+    end
+    points.sort! { |a, b| b[0] <=> a[0] }
+
+    begin
+      if points[0][0] < 3
+        return find_user_playlist(username, name, offset + limit, limit)
+      else
+        return get_item("playlist", items[points[0][1]]["id"].to_s)
+      end
+    rescue IndexError
+      return nil
+    end
+  end
+
+  # Get the complete metadata of an item based off of its id
+  #
+  # ```
+  # SpotifySearcher.new.authorize(...).get_item("artist", "1dfeR4HaWDbWqFHLkxsg1d")
+  # ```
+  def get_item(item_type : String, id : String, offset = 0,
+               limit = 100) : JSON::Any
+    if item_type == "playlist"
+      return get_playlist(id, offset, limit)
+    end
+
+    url = "#{item_type}s/#{id}?limit=#{limit}&offset=#{offset}"
+    url = @root_url.join(url).to_s
+
+    response = HTTP::Client.get(url, headers: @access_header)
+    error_check(response)
+
+    body = JSON.parse(response.body)
+
+    return body
+  end
+
+  # The only way this method differs from `get_item` is that it makes sure to
+  # insert ALL tracks from the playlist into the `JSON::Any`
+  #
+  # ```
+  # SpotifySearcher.new.authorize(...).get_playlist("122Fc9gVuSZoksEjKEx7L0")
+  # ```
+  def get_playlist(id, offset = 0, limit = 100) : JSON::Any
+    url = "playlists/#{id}?limit=#{limit}&offset=#{offset}"
+    url = @root_url.join(url).to_s
+
+    response = HTTP::Client.get(url, headers: @access_header)
+    error_check(response)
+    body = JSON.parse(response.body)
+    parent = PlaylistExtensionMapper.from_json(response.body)
+
+    more_tracks = body["tracks"]["total"].as_i > offset + limit
+    if more_tracks
+      return playlist_extension(parent, id, offset = offset + limit)
+    end
+
+    return body
+  end
+
+  # This method exists to loop through spotify API requests and combine all
+  # tracks that may not be captured by the limit of 100.
+  private def playlist_extension(parent : PlaylistExtensionMapper,
+                                 id : String, offset = 0, limit = 100) : JSON::Any
+    url = "playlists/#{id}/tracks?limit=#{limit}&offset=#{offset}"
+    url = @root_url.join(url).to_s
+
+    response = HTTP::Client.get(url, headers: @access_header)
+    error_check(response)
+    body = JSON.parse(response.body)
+    new_tracks = PlaylistTracksMapper.from_json(response.body)
+
+    new_tracks.items.each do |track|
+      parent.tracks.items.push(track)
+    end
+
+    more_tracks = body["total"].as_i > offset + limit
+    if more_tracks
+      return playlist_extension(parent, id, offset = offset + limit)
+    end
+
+    return JSON.parse(parent.to_json)
+  end
+
+  # Find the genre of an artist based off of their id
+  #
+  # ```
+  # SpotifySearcher.new.authorize(...).find_genre("1dfeR4HaWDbWqFHLkxsg1d")
+  # ```
+  def find_genre(id : String) : String | Nil
+    genre = get_item("artist", id)["genres"]
+
+    if genre.as_a.empty?
+      return nil
+    end
+
+    genre = genre[0].to_s
+    genre = genre.split(" ").map { |x| x.capitalize }.join(" ")
+
+    return genre
+  end
+
+  # Checks for errors in HTTP requests and raises one if found
+  private def error_check(response : HTTP::Client::Response) : Nil
+    if response.status_code != 200
+      raise("There was an error with your request.\n" +
+            "Status code: #{response.status_code}\n" +
+            "Response: \n#{response.body}")
+    end
+  end
+
+  # Generates url to run a GET request against to the Spotify open API
+  # Returns a `String.`
+  private def generate_query(item_type : String, item_parameters : Hash) : String
+    query = ""
+
+    # parameter keys to exclude in the api request. These values will be put
+    # in, just not their keys.
+    query_exclude = ["username"]
+
+    item_parameters.keys.each do |k|
+      # This will map album and track names from the name key to the query
+      if k == "name"
+        # will remove the "name:<title>" param from the query
+        if item_type == "playlist"
+          query += item_parameters[k] + "+"
+        else
+          query += as_field(item_type, item_parameters[k])
+        end
+
+        # check if the key is to be excluded
+      elsif query_exclude.includes?(k)
+        next
+
+        # if it's none of the above, treat it normally
+        # NOTE: playlist names will be inserted into the query normally, without
+        # a parameter.
+      else
+        query += as_field(k, item_parameters[k])
+      end
+    end
+
+    return URI.encode(query.rchop("+"))
+  end
+
+  # Returns a `String` encoded for the spotify api
+  #
+  # ```
+  # query_encode("album", "A Night At The Opera")
+  # => "album:A Night At The Opera+"
+  # ```
+  private def as_field(key, value) : String
+    return "#{key}:#{value}+"
+  end
+
+  # Ranks the given items based off of the info from parameters.
+  # Meant to find the item that the user desires.
+  # Returns an `Array` of `Array(Int32)` or [[3, 1], [...], ...]
+  private def rank_items(items : Array,
+                         parameters : Hash) : Array(Array(Int32))
+    points = [] of Array(Int32)
+    index = 0
+
+    items.each do |item|
+      pts = 0
+
+      # Think about whether this following logic is worth having in one method.
+      # Is it nice to have a single method that handles it all or having a few
+      # methods for each of the item types? (track, album, playlist)
+      parameters.keys.each do |k|
+        val = parameters[k]
+
+        # The key to compare to for artist
+        if k == "artist"
+          pts += points_compare(item["artists"][0]["name"].to_s, val)
+        end
+
+        # The key to compare to for playlists
+        if k == "username"
+          pts_to_add = points_compare(item["owner"]["display_name"].to_s, val)
+          pts += pts_to_add
+          pts += -10 if pts_to_add == 0
+        end
+
+        # The key regardless of whether item is track, album,or playlist
+        if k == "name"
+          pts += points_compare(item["name"].to_s, val)
+        end
+      end
+
+      points.push([pts, index])
+      index += 1
+    end
+
+    points.sort! { |a, b| b[0] <=> a[0] }
+
+    return points
+  end
+
+  # Returns an `Int` based off the number of points worth assigning to the
+  # matchiness of the string. First the strings are downcased and then all
+  # nonalphanumeric characters are stripped.
+  # If the strings are the exact same, return 3 pts.
+  # If *item1* includes *item2*, return 1 pt.
+  # Else, return 0 pts.
+  private def points_compare(item1 : String, item2 : String) : Int32
+    item1 = item1.downcase.gsub(/[^a-z0-9]/, "")
+    item2 = item2.downcase.gsub(/[^a-z0-9]/, "")
+
+    if item1 == item2
+      return 3
+    elsif item1.includes?(item2)
+      return 1
+    else
+      return 0
+    end
+  end
+
+end
+
+# puts SpotifySearcher.new()
+#   .authorize("XXXXXXXXXXXXXXX",
+#              "XXXXXXXXXXXXXXX")
+#   .find_item("playlist", {
+#     "name" => "Brain Food",
+#     "username" => "spotify"
+#     # "name " => "A Night At The Opera",
+#     # "artist" => "Queen"
+#     # "track" => "Bohemian Rhapsody",
+#     # "artist" => "Queen"
+#   })

src/search/youtube.cr

@@ -0,0 +1,200 @@
+require "http"
+require "xml"
+require "json"
+require "uri"
+
+require "./ranking"
+
+require "../bottle/config"
+require "../bottle/styles"
+
+
+module Youtube
+  extend self
+
+  VALID_LINK_CLASSES = [
+    "yt-simple-endpoint style-scope ytd-video-renderer",
+    "yt-uix-tile-link yt-ui-ellipsis yt-ui-ellipsis-2 yt-uix-sessionlink      spf-link ",
+  ]
+
+  # Note that VID_VALUE_CLASS, VID_METADATA_CLASS, and YT_METADATA_CLASS are found in ranking.cr
+
+  # Finds a youtube url based off of the given information.
+  # The query to youtube is constructed like this:
+  #   "<song_name> <artist_name> <search terms>"
+  # If *download_first* is provided, the first link found will be downloaded.
+  # If *select_link* is provided, a menu of options will be shown for the user to choose their poison
+  #
+  # ```
+  # Youtube.find_url("Bohemian Rhapsody", "Queen")
+  # => "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
+  # ```
+  def find_url(spotify_metadata : JSON::Any,
+               flags = {} of String => String) : String?
+
+    search_terms = Config.search_terms
+
+    select_link = flags["select"]?
+
+    song_name = spotify_metadata["name"].as_s
+    artist_name = spotify_metadata["artists"][0]["name"].as_s
+
+    human_query = "#{song_name} #{artist_name} #{search_terms.strip}"
+    params = HTTP::Params.encode({"search_query" => human_query})
+
+    response = HTTP::Client.get("https://www.youtube.com/results?#{params}")
+
+    yt_metadata = get_yt_search_metadata(response.body)
+
+    if yt_metadata.size == 0
+      puts "There were no results for this query on youtube: \"#{human_query}\""
+      return nil
+    end
+
+    root = "https://youtube.com"
+    ranked = Ranker.rank_videos(spotify_metadata, yt_metadata, human_query)
+
+    if select_link
+      return root + select_link_menu(spotify_metadata, yt_metadata)
+    end
+
+    begin
+      puts Style.dim("  Video: ") + yt_metadata[ranked[0]["index"]]["title"]
+      return root + yt_metadata[ranked[0]["index"]]["href"]
+    rescue IndexError
+      return nil
+    end
+
+    exit 1
+  end
+
+  # Presents a menu with song info for the user to choose which url they want to download
+  private def select_link_menu(spotify_metadata : JSON::Any,
+                               yt_metadata : YT_METADATA_CLASS) : String
+    puts Style.dim("  Spotify info: ") +
+         Style.bold("\"" + spotify_metadata["name"].to_s) + "\" by \"" +
+         Style.bold(spotify_metadata["artists"][0]["name"].to_s + "\"") +
+         " @ " + Style.blue((spotify_metadata["duration_ms"].as_i / 1000).to_i.to_s) + "s"
+    puts "  Choose video to download:"
+    index = 1
+    yt_metadata.each do |vid|
+      print "    " + Style.bold(index.to_s + " ")
+      puts "\"" + vid["title"] + "\" @ " + Style.blue((vid["duration_ms"].to_i / 1000).to_i.to_s) + "s"
+      index += 1
+      if index > 5
+        break
+      end
+    end
+
+    input = 0
+    while true # not between 1 and 5
+      begin
+        print Style.bold("  > ")
+        input = gets.not_nil!.chomp.to_i
+        if input < 6 && input > 0
+          break
+        end
+      rescue
+        puts Style.red("  Invalid input, try again.")
+      end
+    end
+
+    return yt_metadata[input-1]["href"]
+
+  end
+
+  # Finds valid video links from a `HTTP::Client.get` request
+  # Returns an `Array` of `NODES_CLASS` containing additional metadata from Youtube
+  private def get_yt_search_metadata(response_body : String) : YT_METADATA_CLASS
+    yt_initial_data : JSON::Any = JSON.parse("{}")
+
+    response_body.each_line do |line|
+      # timestamp 11/8/2020:
+      # youtube's html page has a line previous to this literally with 'scraper_data_begin' as a comment
+      if line.includes?("var ytInitialData")
+        # Extract JSON data from line
+        data = line.split(" = ")[2].delete(';')
+        dataEnd = (data.index("</script>") || 0) - 1
+
+        begin
+          yt_initial_data = JSON.parse(data[0..dataEnd])
+        rescue
+          break
+        end
+      end
+    end
+
+    if yt_initial_data == JSON.parse("{}")
+      puts "Youtube has changed the way it organizes its webpage, submit a bug"
+      puts "saying it has done so on https://github.com/cooperhammond/irs"
+      exit(1)
+    end
+
+    # where the vid metadata lives
+    yt_initial_data = yt_initial_data["contents"]["twoColumnSearchResultsRenderer"]["primaryContents"]["sectionListRenderer"]["contents"]
+
+    video_metadata = [] of VID_METADATA_CLASS
+
+    i = 0
+    while true
+      begin
+        # video title
+        raw_metadata = yt_initial_data[0]["itemSectionRenderer"]["contents"][i]["videoRenderer"]
+
+        metadata = {} of String => VID_VALUE_CLASS
+
+        metadata["title"] = raw_metadata["title"]["runs"][0]["text"].as_s
+        metadata["href"] = raw_metadata["navigationEndpoint"]["commandMetadata"]["webCommandMetadata"]["url"].as_s
+        timestamp = raw_metadata["lengthText"]["simpleText"].as_s
+        metadata["timestamp"] = timestamp
+        metadata["duration_ms"] = ((timestamp.split(":")[0].to_i * 60 +
+                               timestamp.split(":")[1].to_i) * 1000).to_s
+
+
+        video_metadata.push(metadata)
+      rescue IndexError
+        break
+      rescue Exception
+      end
+      i += 1
+    end
+
+    return video_metadata
+  end
+
+  # Returns as a valid URL if possible
+  #
+  # ```
+  # Youtube.validate_url("https://www.youtube.com/watch?v=NOTANACTUALVIDEOID")
+  # => nil
+  # ```
+  def validate_url(url : String) : String | Nil
+    uri = URI.parse url
+    return nil if !uri
+
+    query = uri.query
+    return nil if !query
+
+    # find the video ID
+    vID = nil
+    query.split('&').each do |q|
+      if q.starts_with?("v=")
+        vID = q[2..-1]
+      end
+    end
+    return nil if !vID
+
+    url = "https://www.youtube.com/watch?v=#{vID}"
+
+    # this is an internal endpoint to validate the video ID
+    params = HTTP::Params.encode({"format" => "json", "url" => url})
+    response = HTTP::Client.get "https://www.youtube.com/oembed?#{params}"
+    return nil unless response.success?
+
+    res_json = JSON.parse(response.body)
+    title = res_json["title"].as_s
+    puts Style.dim("  Video: ") + title
+
+    return url
+  end
+end

tests/README.md

@@ -1,2 +0,0 @@
-# Travis CI tests are wierd
-Tests with `ffmpeg` are wierd on Travis. It's a fact that I've had to deal with for 25 commits in total. So, the only songs I've found *so far* that work with ffmpeg are from the album `Da Frame 2R / Matador` by `Arctic Monkeys`. It's really lame, but don't mess around with them. 

tests/album.py

@@ -1,5 +0,0 @@
-from irs.ripper import Ripper
-
-print ("[*] Testing `album.py`")
-Ripper().spotify_list("album", "Da Frame 2R / Matador")
-print ("[+] Passed!")

tests/playlist.py

@@ -1,5 +0,0 @@
-from irs.ripper import Ripper
-
-print ("[*] Testing `playlist.py`")
-Ripper().spotify_list("playlist", "IRS Testing", "prakkillian")
-print ("[+] Passed!")

tests/post_processors.py

@@ -1,22 +0,0 @@
-from irs.ripper import Ripper
-import os
-
-print ("[*] Testing `post_processors.py`")
-
-if not os.path.exists("test_dir"):
-    os.makedirs("test_dir")
-Ripper({
-    "post_processors": {
-        "custom_directory": "test_dir/",
-        "organize": True,
-    }
-}).album("Da Frame 2R / Matador")
-
-Ripper({
-    "post_processors": {
-        "custom_directory": "test_dir/",
-        "organize": True,
-    }
-}).playlist("IRS Testing", "prakkillian")
-
-print ("[+] Passed!")

tests/song.py

@@ -1,5 +0,0 @@
-from irs.ripper import Ripper
-
-print ("[*] Testing `song.py`")
-Ripper().song("Da Frame 2R", "Arctic Monkeys")
-print ("[+] Passed!")

tests/test_all.py

@@ -1,7 +0,0 @@
-from os import system, chdir
-chdir("tests/")
-
-system("python album.py")
-system("python playlist.py")
-system("python post_processors.py")
-system("python song.py")