i hate git its actual mold

.gitattributes

@@ -1,34 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+**/__pycache__/
+beat_manipulator/beatmaps/
+1/
+flagged/
+/*.mp3
+/*.wav
+/*.flac
+/*.png

LICENSE.md

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-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
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  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 <https://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:
-
-    <program>  Copyright (C) <year>  <name of author>
-    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
-<https://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
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,13 +1,193 @@
+# **stunlocked's beat manipulator**
+Advanced beat swapping powered by [madmom](https://github.com/CPJKU/madmom).
+### [Try on Hugging Face](https://huggingface.co/spaces/dpe1/BeatManipulator)
+### [Try on Google Colab](https://colab.research.google.com/drive/1gEsZCCh2zMKqLmaGH5BPPLrImhEGVhv3?usp=sharing)
+# Installation
+For most people I recommend using Hugging Face or Google Colab. However if you run it locally, you will have access to more advanced features that I haven't added to Hugging Face yet, like using samples, mixing multiple songs, presets.
+
+First I recommend creating a new environment to avoid dependency issues. With conda, you can do that by running `conda create --name beat_manipulator`.
+
+Then run those commands depending on what python you have:
+
+### conda 3.8, 3.9:
+```
+conda install pip cython mido numpy scipy pysoundfile librosa ffmpeg-python pytest pyaudio pyfftw
+
+pip install madmom pedalboard
+```
+### conda 3.10
+```
+conda install pip cython mido numpy scipy pysoundfile librosa ffmpeg-python pytest pyaudio pyfftw
+
+pip install pedalboard
+
+pip install git+https://github.com/CPJKU/madmom
+```
+### pip 3.8, 3.9
+```
+pip install numpy cython soundfile ffmpeg-python pedalboard librosa
+
+pip install madmom
+```
+### pip 3.10
+```
+pip install numpy cython soundfile ffmpeg-python pedalboard librosa
+
+pip install git+https://github.com/CPJKU/madmom
+```
+
 ---
-title: BeatManipulator
-emoji: 🥁
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 3.11.0
-app_file: app.py
-pinned: false
-license: cc-by-nc-sa-4.0
----
+After installing all necessary libraries, to download beat manipulator, download and extract this repo using green "Code" button > Download ZIP, or run `git clone https://github.com/stunlocked1/beat_manipulator`. You can now open examples.py, jupiter.ipynb, or app.py for gradio interface.
+# Usage
+First, import beat_manipulator and load a song
+```
+import beat_manipulator as bm
+your_song = bm.song(audio = 'path or numpy array')
+```
+It accepts absolute or relative path to audio file, or you can directly load audio array into it. If you are loading audio array directly, make sure to also add sr=sample_rate argument. Array should be in -1 to 1 format, which is how most libraries load audio.
+
+Now, generate the beatmap:
+```
+your_song.beatmap_generate()
+```
+Beatmap is generated using madmom library. When you generate it for the first time, it might take up to a minute. However all beatmaps are saved to `beat_manipulator/beatmaps`, so when you load the same file for the second time, it will be instant.
+
+You can access beatmap in `your_song.beatmap` variable. It is a list of values that represent position of each beat in samples.
+
+After generating the beatmap, you can do a bunch of stuff. 
+### slicing
+Song object supports slicing.
+
+- `your_song[5]` will return audio of the 5th beat, indexing starts from 1. 
+- `your_song[4:8.5]` returns audio starting from 4th beat, ending halfway between 8th and 9th beat. `your_song[0:1]` is equivalent to `your_song[1]`
+- `your_song['your_pattern']` returns a beatswapped audio using the pattern you provided. Beatswapping with patterns is the main feature if this app and you can do a whole bunch of stuff with them. There is a section below that explains how to write those patterns.
+### beatswapping
+Another way to beatswap is: 
+```
+your_song.beatswap(pattern = '1, 3, 2, 4', scale = 1, shift = 0, length = None)
+```
+This one doesn't return anything, instead it modifies the song in place.
+
+You can also beatwap and write audio in one line:
+```
+bm.beatswap(song = 'path or numpy array', pattern = '1, 3, 2, 4', scale = 1, shift = 0, output = '')
+```
+### scale
+`scale = 0.5` will insert a new beat position between every existing beat position in the beatmap. That allows you to make patterns on smaller intervals.
+
+`scale = 2`, on the other hand, will merge every two beat positions in the beatmap. Useful, for example, when beat map detection puts sees BPM as two times faster than it actually is, and puts beats in between every actual beat.
+
+To scale the beatmap, you can use `your_song.beatmap_scale(0.5)`, or specify scale directly in `your_song.beatswap(..., scale = float)`
+### shift
+Shifts the beatmap, in beats. For example, if you want to remove 4th beat every four beats, you can do it by writing `1, 2, 3, 4!`. 
+However sometimes it doesn't properly detect which beat is first, and for example remove 2nd beat every 4 beats instead. In that case, if you want 4th beat, use `shift = 2`. Also sometimes beats are detected right in between actual beats, so shift = 0.5 or -0.5 will fix it.
+
+To shift the beatmap, you can use `your_song.beatmap_shift(0.5)`, or specify shift directly in `your_song.beatswap(..., shift = float)`
+
+When you specify shift in a beatswap function, it applies before scale for consistency.
+### saving scale and shift
+If you run `your_song.beatmap_save_settings(scale: float, shift: float)`, it will save a file in `beat_manipulator/beatmaps` with your scale and shift. That way, next time you load that song, it will automatically apply those scale and shift values.
+### writing audio
+To write audio, use `my_song.write(output = '')`. If output is empty string, this will write the song next to your .py file, using the original filename.
+# pattern syntax
+The pattern syntax is quite powerful and you can do a whole bunch of stuff with it. Basic syntax is - `1, 3, 2, 4` means every 4 beats, swap 2nd and 3rd beats, but you can do much more, like applying audio effects, shuffling beats, slicing them, mixing two songs, adding samples, sidechain.
+
+You can use spaces freely in patterns for formatting. Most other symbols have some use though. Here is how to write patterns:
+#### beats
+- `1` - 1st beat;
+- `1>0.5` - first half of first beat
+- `1<0.5 - second half of first beat
+- `0:0.5` - range of beats, this also means first half of first beat, but with this you can do complex stuff like `1.25:1.5`. However this one is a bit more confusing because indexing starts from 0, so 1:2 is second beat, not first.
+- Also sometimes it is more convenient to use smaller `scale`, like 0.5 or 0.25, instead of slicing beats.
+#### basic patterns
+- `1, 3, 2, 4` means 3rd and 2nds beats will be swapped every 4 beats. Happens every 4 beats because 4 is the biggest number in the pattern.
+- `1, 2, 3, 4!` means every 4 beats, it will remove the 4th beat. `!` allows you to skip a beat but it still counts for pattern size.
+- Specifying pattern length: `pattern = '1,2,3', length = 4` is another way to remove 4th beat every 4 beats.
+- `1,4` skips 2nd and 3rd beat
+- `1; 2` plays 1st and 2nd beat same time. They will automatically be normalzied to avoid clipping. Length of the first beat will be preserved.
+#### joining operators
+`,` and `;` are beat joining operators, that join beats together. Here are all available joiners:
+  - `,` puts the beat next to previous beat
+  - `;` puts the beat on top of previous beat. Normalizes the volume to avoid clipping. If previous beat is shorter, your beat will be shortened to match it.
+  - `^` multiplies previous beat by your beat. This can be used for fake sidechain.
+  - `$` adds the beat on top of previous beat + sidechains previous beat by your beat.
+#### effects
+beats can be followed by effects. For example `1s0.75` means take first beat and play it at 0.75x speed. Here are all available effects:
+  - `s` - speed. `1s2` means first beat will be played at 2x speed.
+  - `r` - reverse. `1r` means first beat will have reversed audio.
+  - `v` - volume. `1v0.5` means 1st beat will have 50% volume
+  - `d` - downsample, or 8-bit sound. `1d10` will downsample the first beat so that it sounds 8-bit. Good values start above 7.
+  - `b` - bitcrush. `1b4` will bitcrush it.
+  - `g` - gradient, sounds like highpass. `1g1` is the recommended value
+  - `c` - channel. If not followed by number, swaps channels. If followed by 0, plays only left channel. If 1, only right channel
+  - mixing effects - `1s2rd8` - take first beat, play at 2x speed, reversed, and downsampled.
+You can also define your own effects. Check `BM_EFFECTS` dictionary from `beat_manipulator/effects.py`, this is where it reads effects from. You can add new stuff to that dictionary and use your own effects this way, or specify your own dictionary when using `your_song.beatswap(..., effects: dict)` with your `effects` argument. 
+By default that argument points to `BM_EFFECTS` dictionary.
+#### math
+mathematical expressions with `+`, `-`, `*`, `/`, and `**` are supported. For example, if you write `1/3` anywhere in the pattern, to slice beats or as effect value, it will be replaced by 0.3333...
+#### using samples
+To use samples, provide them in `samples` argument to `your_song.beatswap(..., samples: dict)`. The dictionary should look like this: 
+```
+{
+  'sample name' : 'path to your sample or numpy array of your sample or bm.song object', 
+  'sample name 2' : 'path or audio 2', 
+  ...
+}
+````
+It supports both loading audio files from a path, and directly loading arrays.
+
+Then in pattern, you can use quotes (`'`, `"`, or `` ` ``) to access samples. For example: `1; "sample_name"` will put that sample on top of 1st beat. Samples are treated just like beats, you can apply effects to them, use any joining operators.
+
+You can also slice samples: `"sample_name">0.5` means first half of the sample.
+
+You can use list with samples instead of a dictionary. In that case, you can access them by their index in the list, for example `"1"` is the 1st sample.
+#### mixing two songs
+Add the second song that you want to mix to the `samples` argument dictionary or list, as described above. It can load path to a file, directly load a numpy array, or a bm.song object.
+
+The difference is, instead of using quotes, for songs you use square brackets: `[song_name]`
+
+`[song_name]4` means fourth beat of that song. So you can do stuff like `1, [song_name]2`, which will alternate beats between your two songs.
+#### other stuff
+- `i` will be replaced by current position, e.g. `i, i, i, i+1` is equvalent to `1, 2, 3, 4 + 1`, or `1, 2, 3, 5`.
+- `#` will add shuffle all beats with the same number after it. `1#1, 2#2, 3#1, 4#2, 5#1, 6#2, 7#1, 8#2` will shuffle 1st, 3rd, 5th and 7th beats (the are in 1st group), and 2nd, 4th, 6th and 8th beats - from 2nd shuffle group.
+- `!` skips that beat. If you want to remove every 4th beat, you can't just do `1, 2, 3`, because that would simply play every 3 beats. So to play 3 beats every 4 beats, you can write `1, 2, 3, 4!`
+- `?` makes that beat not count for pattern size. For example, `1, 2, 3, 8` will normally repeat every 8 beats because 8 is the highest number, but `1, 2, 3, 8?` will repeat every 3 beats.
+- `@` allows you to take a random beat with the following syntax: @start_stop_step. For example, `@1_4_0.5` means it will take a random beat out of 1st, 1.5, 2nd, 2.5, 3rd, 3.5, and 4th. It will take whole beat, so you can also add `>0.5` to take only first half.
+- `%` - for very advanced patterns you can create variables from various metrics. For example, `%v` will create a variable with average volume of that beat, and all following `%` will be replaced by that variable until you create a new one. Useful for applying different effects based on different song metrics. All metrics are in `beat_manipulator/metrics.py`.
+#### special patterns
+You can write special commands into the `pattern` argument instead of actual patterns.
+- `reverse` - plays all beats in reverse chronological order
+- `shuffle` - shuffles all beats
+- `test` - puts different pitched cowbells on each beat, useful for testing beat detection and adjusting it using scale and shift. Each cowbell is 1 beat, highest pitched cowbell is the 1st beat, lowest pitched - 4th.
+#### complex patterns
+You should be able to use all of the above operators in any combination, as complex as you want. Very low scales should also be fine, up to 0.001.
+## creating images
+You can create cool images based on beat positions. Each song produces its own unique image. Write:
+```
+your_song.image_generate()
+```
+image will be saved as a numpy array to your_song.image variable. To export it to a file, use:
+```
+your_song.image_write()
+```
+The image will by default be resized to 4096x4096. It is also possible to export original image, which usually is too big for most image viewers to handle it. However the cool thing is that you can apply image effects to it, and then turn it back into audio. I will soon add info on how to do that.
+## quick functions
+```
+bm.beatswap(song = 'path or numpy array', pattern = '1,3,2,4', scale=1, shift=0, output='')
+```
+allows you to beatswap and write a song loaded from path or numpy array in one line. Returns path to the exported beatswapped song file.
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+```
+bm.image(song = 'path or numpy array', max_size = 4096, scale=1, shift=0, output='')
+```
+creates an image and writes it in one line, returns path to exported image.
+```
+bm.osu.generate(song='path or numpy array', difficulties = [0.2, 0.1, 0.05, 0.025, 0.01, 0.0075, 0.005, 0.0025, 0.0001])
+```
+generates an osu! beatmap (uses madmom beat processor and peak detection). Writes an .osz file that you can install by opening it with osu! and returns path to it.
+## presets
+there are some patterns in `beat_manipulator/presets.yaml` file. Those are supposed to be used on normalized beat maps, where kick + snare is two beats, so make sure to adjust beatmaps using `scale` and `shift`.
+To use one of the presets from that file, write: 
+```
+bm.presets.use(song = song, preset = 'preset name', scale = 1, shift = 0)
+```

app.py

@@ -2,63 +2,61 @@ import gradio as gr, numpy as np
 from gradio.components import Audio, Textbox, Checkbox, Image
 import beat_manipulator as bm
 import cv2
-def _safer_eval(string:str) -> float:
-    if isinstance(string, str): 
-        try:
-            string = eval(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-        except: string=1
-    return string
 
 def BeatSwap(audiofile, pattern: str = 'test', scale:float = 1, shift:float = 0, caching:bool = True, variableBPM:bool = False):
     print()
     print(f'path = {audiofile}, pattern = "{pattern}", scale = {scale}, shift = {shift}, caching = {caching}, variable BPM = {variableBPM}', end=',  ')
     if pattern == '' or pattern is None: pattern = 'test'
+    if caching is not False: caching == True
+    if variableBPM is not True: variableBPM == False
     try:
-        scale=_safer_eval(scale)
+        scale=bm.utils._safer_eval(scale)
     except: scale = 1
     try:
-        shift=_safer_eval(shift)
+        shift=bm.utils._safer_eval(shift)
     except: shift = 0
     if scale <0: scale = -scale
-    if scale < 0.02: scale = 0.02
+    if scale < 0.01: scale = 0.01
     if audiofile is not None:
         try:
-            song=bm.song(path=audiofile, filename=audiofile.split('.')[-2][:-8]+'.'+audiofile.split('.')[-1], caching=caching, log=False)
+            song=bm.song(audio=audiofile,log=False)
         except Exception as e:
             print(f'Failed to load audio, retrying: {e}')
-            song=bm.song(path=audiofile, caching=caching, log=False)
+            song=bm.song(audio=audiofile, log=False)
     else: 
         print(f'Audiofile is {audiofile}')
         return
     try:
-        print(scale, shift, len(song.audio[0])/song.samplerate)
-        if len(song.audio[0]) > (song.samplerate*1800):
-            song.audio = np.asarray(song.audio)
-            song.audio = song.audio[:,:song.samplerate*1800]
+        print(f'scale = {scale}, shift = {shift}, length = {len(song.audio[0])/song.sr}')
+        if len(song.audio[0]) > (song.sr*1800):
+            song.audio = np.array(song.audio, copy=False)
+            song.audio = song.audio[:,:song.sr*1800]
     except Exception as e: print(f'Reducing audio size failed, why? {e}')
     lib = 'madmom.BeatDetectionProcessor' if variableBPM is False else 'madmom.BeatTrackingProcessor'
-    song.beatmap.generate(lib=lib, caching=caching)
-    song.beatmap.shift(shift)
-    song.beatmap.scale(scale)
+    song.path = song.path.split('.')[-2][:-8]+'.'+song.path.split('.')[-1]
+    song.beatmap_generate(lib=lib, caching=caching)
+    song.beatmap_shift(shift)
+    song.beatmap_scale(scale)
     try:
-        song.beat_image.generate()
-        image = song.beat_image.combined
+        song.image_generate()
+        image = bm.image.bw_to_colored(song.image)
         y=min(len(image), len(image[0]), 2048)
         y=max(y, 2048)
-        image = np.clip(cv2.resize(image, (y,y), interpolation=cv2.INTER_NEAREST).T/255, -1, 1)
+        image = np.rot90(np.clip(cv2.resize(image, (y,y), interpolation=cv2.INTER_NEAREST), -1, 1))
+        print(image)
         #print(image)
     except Exception as e: 
         print(f'Image generation failed: {e}')
         image = np.asarray([[0.5,-0.5],[-0.5,0.5]])
-    song.quick_beatswap(output=None, pattern=pattern, scale=1, shift=0, lib=lib)
+    song.beatswap(pattern=pattern, scale=1, shift=0)
     song.audio = (np.clip(np.asarray(song.audio), -1, 1) * 32766).astype(np.int16).T
     #song.write_audio(output=bm.outputfilename('',song.filename, suffix=' (beatswap)'))
     print('___ SUCCESS ___')
-    return ((song.samplerate, song.audio), image)
+    return ((song.sr, song.audio), image)
 
 audiofile=Audio(source='upload', type='filepath')
-patternbox = Textbox(label="Pattern, comma separated:", placeholder="1, 3, 2, 4!", value="1, 2!", lines=1)
-scalebox = Textbox(value=1, label="Beatmap scale, beatmap's beats per minute will be multiplied by this:", placeholder=1, lines=1)
+patternbox = Textbox(label="Pattern:", placeholder="1, 3, 2, 4!", value="1, 2!", lines=1)
+scalebox = Textbox(value=1, label="Beatmap scale. At 2, every two beat positions will be merged, at 0.5 - a beat position added between every two existing ones.", placeholder=1, lines=1)
 shiftbox = Textbox(value=0, label="Beatmap shift, in beats (applies before scaling):", placeholder=0, lines=1)
 cachebox = Checkbox(value=True, label="Enable caching generated beatmaps for faster loading. Saves a file with beat positions and loads it when you open same audio again.")
 beatdetectionbox = Checkbox(value=False, label='Enable support for variable BPM, however this makes beat detection slightly less accurate')
@@ -74,45 +72,73 @@ Colab version - https://colab.research.google.com/drive/1gEsZCCh2zMKqLmaGH5BPPLr
 
 # Basic usage
 
-Upload your audio, enter the beat swapping pattern, change scale and shift if needed, and run the app.
-
-It can be useful to test where each beat is by writing `test` into the `pattern` field, which will put cowbells on each beat. Highest cowbell should be the on first beat.
-
-Use scale and shift to adjust the beatmap, for example if it is shifted 0.5 beats forward, set shift to -0.5. If it is two times faster than you want, set scale to 0.5
-
-Feel free to use complex patterns and very low scales - most of the computation time is in detecting beats, not swapping them.
-
-# Pattern syntax
-
-Patterns are sequences of expressions, separated by `,` - for example, `1>3/8,   1>3/8,   1>0.25,   2,   3>0.75s2,   3>3/8,   3>0.25,   4d9`. Spaces can be freely used for formatting as they will be ignored. Any other character that isnt used in the syntax can also be used for formatting but only between beats, not inside them.
-- `1, 3, 2, 4` - every 4 beats, swap 2nd and 3rd beat. This pattern loops every 4 beats, because 4 is the biggest number in it.
-- `1, 3, 4` - every 4 beats, skip 2nd beat.
-- `1, 2, 2, 4` - every 4 beats, repeat 2nd beat.
-- `1, 2!` - skip every second beat. `!` after a number sets length of the pattern (beat isnt played). `1, 2, 3, 4!` - skip every 4th beat.
-- `2>0.5` - play only first half of the second beat. `>` after a beat allows you to take first `i` of that beat.
-- `2<0.5` - play only second half of the second beat. `<` after a beat takes last `i` of that beat.
-- `1.5:4.5` - play a range of beats from 1.5 to 4.5. `0:0.5` means first half of 1st beat. Keep that in mind, to play first half of 5th beat, you do `4:4.5`, not `5:5.5`. `1` is equivalent to `0:1`. `1.5` is equivalent to `0.5:1.5`. `1,2,3,4` is `0:4`.
-
-**Tip: instead of slicing beats, sometimes it is easier to make scale smaller, like 0.5 or 0.25.**
-- `1, 1>1/3, 1>1/3, 1<1/3` - you can use math expressions with `+`, `-`, `*`, `/` in place of numbers.
-- `1, 2, 3, 4!, 8?` - every 4 beats, 4th beat is replaced with 8th beat. `?` after a beat makes that number not count for looping. 
-- `v` + number - controls volume of that beat. `1v2` means 200% volume, `1v1/3` means 33.33% volume, etc.
-- `r` after a beat reverses that beat. `1r, 2` - every two beats, first beat will be reversed
-- another way to reverse - `4:0` is reversed `0:4`.
-- `s` + number - changes speed and pitch of that beat. 2 will be 2 times faster, 1/2 will be 2 times slower. Note: Only integers or 1/integer numbers are supported, everything else will be rounded.
-- `c` - if not followed by a number, swaps left and right channels of the beat. If followed by 0, mutes left channel, 1 - right channel.
-- `b` + number - bitcrush. The higher the number, the stronger the effect. Barely noticeable at values less then 1
-- `d` + number - downsample (8-bit sound). The higher the number, the stronger the effect. Starts being noticeable at 3, good 8-bit sounding values are around 8+.
-- `t` + number - saturation
-- you can combine stuff like `0:1/3d8v2cr` - that line means 0:1/3 beat will be downsampled, 200% volume, swapped channels, and reversed
-
-there are certain commands you can write in pattern instead of the actual pattern:
-- `random` - each beat will be randomly selected from all beats, basically similar to shuffling all beats
-- `reverse` - reverses the order of all beats
-- `test` - test beat detection by putting cowbells on each beat. The highest pitched cowbell should be on the first beat; next cowbell should be on the snare. If it is not, use scale and shift.
-
-There are also some interesting patterns there: https://github.com/stunlocked1/BeatManipulator/blob/main/presets.json. Those are meant to be used with properly adjusted shift and scale, where 1st beat is 1st kick, 2nd beat is the snare after it, etc.
-
-Check my soundcloud https://soundcloud.com/stunlocked
+Upload your audio, enter the beat swapping pattern, change scale and shift if needed, and run it.
+
+# pattern syntax
+The pattern syntax is quite powerful and you can do a whole bunch of stuff with it. 
+
+Basic syntax is - `1, 3, 2, 4` means every 4 beats, swap 2nd and 3rd beats, but you can do much more, like applying audio effects, shuffling beats, slicing them, mixing two songs, adding samples, sidechain.
+
+You can use spaces freely in patterns for formatting. Most other symbols have some use though. Here is the full syntax:
+#### beats
+* `1` - 1st beat;
+* `1>0.5` - first half of first beat
+* `1<0.5` - second half of first beat
+* `0:0.5` - range of beats, this also means first half of first beat, but with this you can do complex stuff like `1.25:1.5`. However this one is a bit more confusing because indexing starts from 0, so 1:2 is second beat, not first.
+* Also sometimes it is more convenient to use smaller `scale`, like 0.5 or 0.25, instead of slicing beats.
+#### basic patterns
+- `1, 3, 2, 4` - 3rd and 2nd beats will be swapped every 4 beats. Happens every 4 beats because 4 is the biggest number in the pattern.
+- `1, 2, 3, 4!` - every 4 beats, it will remove the 4th beat. `!` allows you to skip a beat but it still counts for pattern size.
+- Specifying pattern length: `pattern = '1, 2, 3', length = 4` is another way to remove 4th beat every 4 beats.
+- `1, 4` skips 2nd and 3rd beat
+- `1; 2` plays 1st and second beat at the same time.
+#### joining operators
+`,` and `;` are beat joining operators. Here are all available joiners:
+  - `,` puts the beat next to previous beat.
+  - `;` puts the beat on top of previous beat. Normalizes the volume to avoid clipping. If previous beat is shorter, your beat will be shortened to match it.
+  - `^` multiplies previous beat by your beat. This can be used for fake sidechain.
+  - `$` adds the beat on top of previous beat + sidechains previous beat by your beat (I haven't tested this one)
+#### effects
+beats can be followed by effects. For example `1s0.75` means take first beat and play it at 0.75x speed. Here are all available effects:
+  - `s` - speed. `1s2` means first beat will be played at 2x speed.
+  - `r` - reverse. `1r` means first beat will have reversed audio.
+  - `v` - volume. `1v0.5` means 1st beat will have 50% volume
+  - `d` - downsample, or 8-bit sound. `1d10` will downsample the first beat so that it sounds 8-bit. Good values start above 7.
+  - `b` - bitcrush. `1b4` will bitcrush it.
+  - `g` - gradient, sounds like highpass. `1g1` is the recommended value
+  - `c` - channel. If not followed by number, swaps channels. If followed by 0, plays only left channel. If 1, only right channel
+  - mixing effects - `1s2rd8` - take first beat, play at 2x speed, reversed, and downsampled.
+#### math
+mathematical expressions with `+`, `-`, `*`, `/`, and `**` are supported. For example, if you write `1/3` anywhere in the pattern, to slice beats or as effect value, it will be replaced by `0.33333333`
+#### using samples, mixing two songs
+- WIP (you can do that if you run locally, I am just figuring out gradio UI because that requires a bunch of new input interface)
+#### other stuff
+- `i` will be replaced by current position, e.g. `i, i, i, i+1` is equvalent to `1, 2, 3, 4 + 1`, or `1, 2, 3, 5`.
+- `#` will add shuffle all beats with the same number after it. `1#1, 2#2, 3#1, 4#2, 5#1, 6#2, 7#1, 8#2` will shuffle 1st, 3rd, 5th and 7th beats (the are in 1st group), and 2nd, 4th, 6th and 8th beats - from 2nd shuffle group.
+- `!` skips that beat. If you want to remove every 4th beat, you can't just do `1, 2, 3`, because that would simply play every 3 beats. So to play 3 beats every 4 beats, you can write `1, 2, 3, 4!`
+- `?` makes that beat not count for pattern size. For example, `1, 2, 3, 8` will normally repeat every 8 beats because 8 is the highest number, but `1, 2, 3, 8?` will repeat every 3 beats.
+- `@` allows you to take a random beat with the following syntax: @start_stop_step. For example, `@1_4_0.5` means it will take a random beat out of 1st, 1.5, 2nd, 2.5, 3rd, 3.5, and 4th. It will take whole beat, so you can also add `>0.5` to take only first half.
+- `%` - for very advanced patterns you can create variables from various metrics. For example, `%v` will create a variable with average volume of that beat, and all following `%` will be replaced by that variable until you create a new one. Useful for applying different effects based on different song metrics. All metrics are in `beat_manipulator/metrics.py`.
+#### special patterns
+You can write special commands into the `pattern` argument instead of actual patterns.
+- `reverse` - plays all beats in reverse chronological order
+- `shuffle` - shuffles all beats
+- `test` - puts different pitched cowbells on each beat, useful for testing beat detection and adjusting it using scale and shift. Each cowbell is 1 beat, highest pitched cowbell is the 1st beat, lowest pitched - 4th.
+#### complex patterns
+You should be able to use all of the above operators in any combination, as complex as you want. Very low scales should also be fine, up to 0.01.
+### scale
+`scale = 0.5` will insert a new beat position between every existing beat position in the beatmap. That allows you to make patterns on smaller intervals.
+
+`scale = 2`, on the other hand, will merge every two beat positions in the beatmap. Useful, for example, when beat map detection puts sees BPM as two times faster than it actually is, and puts beats in between every actual beat.
+### shift
+Shifts the beatmap, in beats. For example, if you want to remove 4th beat every four beats, you can do it by writing `1, 2, 3, 4!`. However sometimes it doesn't properly detect which beat is first, and for example remove 2nd beat every 4 beats instead. In that case, if you want 4th beat, use `shift = 2`. Also sometimes beats are detected right in between actual beats, so shift = 0.5 or -0.5 will fix it.
+## creating images
+You can create cool images based on beat positions. Each song produces its own unique image. This gradio app creates a 2048x2048 image from each song.
+## presets
+A bunch of example patterns: https://github.com/stunlocked1/beat_manipulator/blob/main/beat_manipulator/presets.yaml
+
+Those are supposed to be used on normalized beat maps, where kick + snare is two beats, so make sure to adjust beatmaps using `scale` and `shift`.
+
+# My soundcloud https://soundcloud.com/stunlocked
 """
  ).launch(share=False)

beat_manipulator/__init__.py

@@ -1,2 +1,2 @@
 from .main import *
-from . import analyze, effect, generate, image, mix, wrapper
+from . import beatmap, effects, image, io, metrics, presets, osu, utils

beat_manipulator/analyze.py

@@ -1,62 +0,0 @@
-import numpy
-#@njit SLOWER
-def detect_bpm(audio, samplerate, bpm_low=40, bpm_high=300, bpm_step=0.1, mode=1, shift_step=10):
-    """A very slow and inefficient algorithm!"""
-    audio = numpy.asarray(audio)
-    audio = (audio[0] + audio[1]).astype(numpy.float32)
-    length=len(audio)
-    mlength=length- int( 1 / ((bpm_low / 60) / samplerate) )  # to make sure those parts do not affect the calculation as they will be cut sometimes
-    #audio[:int(spb_low)]=0 # to make sure those parts do not affect the calculation as they will be cut sometimes
-    bpmdiffs=[]
-    bpmdiffsi=[]
-    minimum=100000000
-    for i in range(int((bpm_high-bpm_low)/bpm_step)):
-        spb=int(round(1/(((bpm_low + i*bpm_step) / 60) / samplerate)))
-        # audio is reshaped into a 2d array with bpm
-        end=-int(length % spb)
-        if end == 0: end = length
-        image = audio[:end].reshape(-1, spb)
-        if mode == 1: image=image.T
-        # diff21, diff22, diff41, diff42 = image[:-2].flatten(), image[2:].flatten(), image[:-4].flatten(), image[4:].flatten()
-        # difference=abs( numpy.dot(diff21, diff22)/(numpy.linalg.norm(diff21)*numpy.linalg.norm(diff22)) + numpy.dot(diff41, diff42)/(numpy.linalg.norm(diff41)*numpy.linalg.norm(diff42)) )
-        diff2=numpy.abs ( (image[:-2] - image[2:]).flatten()[:mlength] )
-        diff4=numpy.abs ( (image[:-4] - image[4:]).flatten()[:mlength] )
-        difference=numpy.sum(diff2*diff2*diff2*diff2) + numpy.sum(diff4*diff4*diff4*diff4)
-        # for i in range(len(image)-1):
-        #     difference.append(numpy.sum(image[i]-image[i]+1))
-        if mode == 3: 
-            image=image.T
-            diff2=numpy.abs ( (image[:-2] - image[2:]).flatten()[:mlength] )
-            diff4=numpy.abs ( (image[:-4] - image[4:]).flatten()[:mlength] )
-            difference=numpy.sum(diff2*diff2*diff2*diff2) + numpy.sum(diff4*diff4*diff4*diff4)
-        bpmdiffs.append(spb)
-        bpmdiffsi.append(difference)
-        if difference<minimum: 
-            #print(f'{spb}: testing BPM = {(1/spb)*60*samplerate}; value = {difference}')
-            print(i)
-            minimum=difference
-    spb = bpmdiffs[numpy.argmin(numpy.asarray(bpmdiffsi))]
-    #print(f'BPM = {(1/spb)*60*samplerate}')
-    bpmdiffs=[]
-    bpmdiffsi=[]
-    #audio[int(spb):]=0
-    print(spb)
-    for shift in range(0, spb, shift_step):
-        #print(shift)
-        end=-int(length % spb)
-        if end == 0: end = length+shift
-        image = audio[shift:end].reshape(-1, spb)
-        length-=shift_step
-        if mode == 1: image=image.T
-        diff =  numpy.abs ( (image[:-1] - image[1:]).flatten()[:mlength] )
-        difference=numpy.sum(diff*diff)
-        if mode == 3: 
-            image=image.T
-            diff =  numpy.abs ( (image[:-1] - image[1:]).flatten()[:mlength] )
-            difference += numpy.sum(diff*diff)
-        bpmdiffs.append(shift)
-        bpmdiffsi.append(difference)
-        #if shift%1000==0: print(f'testing shift = {shift}; value = {difference}')
-    shift = bpmdiffs[numpy.argmin(numpy.asarray(bpmdiffsi))]
-    #print(f'BPM = {(1/spb)*60*samplerate}; shift = {shift/samplerate} sec.')
-    return numpy.arange(shift, length, spb)

beat_manipulator/beatmap.py

@@ -1,103 +1,128 @@
-import numpy
-def _safer_eval(string:str) -> float:
-    #print(string, end='  ')
-    if isinstance(string, str): 
-        #print(string, end='     ')
-        #print(''.join([i for i in string if i.isdecimal() or i in '.+-*/']), end = '     ')
-        string = eval(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-    #print(string)
-    return string
+import numpy as np
+from . import utils
 
-class beatmap:
-    def __init__(self, beatmap:list = None, audio = None, samplerate = None, caching = True, log = True, path=None, artist=None, title=None, filename = None):
-        self.beatmap = beatmap
-        self.audio = audio
-        self.samplerate = samplerate
-        self.caching = caching
-        self.log = log
-        self.path = path
-        self.artist = artist
-        self.title = title
-        self.filename = filename
 
-    def __getitem__(self, var):
-        return self.beatmap[var]
-    
-    def __len__(self):
-        return len(self.beatmap)
-    
-    def _toarray(self):
-        if isinstance(self.beatmap, list): self.beatmap=numpy.asarray(self.beatmap, dtype=int)
+def scale(beatmap:np.ndarray, scale:float, log = True, integer = True) -> np.ndarray:
+    if isinstance(scale, str): scale = utils._safer_eval(scale)
+    assert scale>0, f"scale should be > 0, your scale is {scale}"
+    if scale == 1: return beatmap
+    else:
+        import math
+        if log is True: print(f'scale={scale}; ')
+        a = 0
+        b = np.array([], dtype=int)
+        if scale%1==0:
+            while a < len(beatmap):
+                b = np.append(b, beatmap[int(a)])
+                a += scale
+        else:
+            if integer is True:
+                while a + 1 < len(beatmap):
+                    b = np.append(b, int((1 - (a % 1)) * beatmap[math.floor(a)] + (a % 1) * beatmap[math.ceil(a)]))
+                    a += scale
+            else:
+                while a + 1 < len(beatmap):
+                    b = np.append(b, (1 - (a % 1)) * beatmap[math.floor(a)] + (a % 1) * beatmap[math.ceil(a)])
+                    a += scale
+        return b
     
-    def _add_beat_to_end(self):
-        self.beatmap=numpy.abs(numpy.append(self.beatmap, len(self.audio[0])))
-        self.beatmap=self.beatmap.astype(int)
-
-    def generate(self, lib='madmom.BeatDetectionProcessor', caching=True, split=None):
-        """Creates self.beatmap attribute with a list of positions of beats in samples."""
-        if self.log is True: print(f'analyzing beats using {lib}; ', end='')
-        #if audio is None and filename is None: (audio, samplerate) = open_audio()
-        if caching is True and self.caching is True:
-            audio_id=hex(len(self.audio[0]))
-            import os
-            if not os.path.exists('SavedBeatmaps'):
-                os.mkdir('SavedBeatmaps')
-            cacheDir="SavedBeatmaps/" + ''.join(self.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
-            try: 
-                self.beatmap=numpy.loadtxt(cacheDir, dtype=int)
-                self.bpm=numpy.average(self.beatmap)/self.samplerate
-                if self.log is True: print('loaded cached beatmap.')
-                return
-            except OSError: 
-                if self.log is True:print("beatmap hasn't been generated yet. Generating...")
-
-        if lib.split('.')[0]=='madmom':
+def shift(beatmap:np.ndarray, shift:float, log = True, mode = 1) -> np.ndarray:
+    if isinstance(shift, str): shift = utils._safer_eval(shift)
+    if shift == 0: return beatmap
+    # positive shift
+    elif shift > 0:
+        # full value of beats is removed from the beginning
+        if shift >= 1: beatmap = beatmap[int(shift//1):]
+        # shift beatmap by the decimal value
+        if shift%1 != 0:
+            shift = shift%1
+            for i in range(len(beatmap) - int(shift) - 1):
+                beatmap[i] = int(beatmap[i] + shift * (beatmap[i + 1] - beatmap[i]))
+
+    # negative shift
+    else:
+        shift = -shift
+        # full values are inserted in between first beats
+        if shift >= 1:
+            if mode == 1:
+                    step = int((beatmap[1] - beatmap[0]) / (int(shift//1) + 1))
+                    beatmap = np.insert(arr = beatmap, obj = 1, values = np.linspace(start = beatmap[0] + step - 1, stop = 1 + beatmap[1] - step, num = int(shift//1)))
+            elif mode == 2:
+                for i in range(int(shift//1)):
+                    beatmap = np.insert(arr = beatmap, obj = (i*2)+1, values = int((beatmap[i*2] + beatmap[(i*2)+1])/2))
+        # shift beatmap by the decimal value
+        if shift%1 != 0:
+            shift = shift%1
+            for i in reversed(range(len(beatmap))):
+                if i==0: continue
+                beatmap[i] = int(beatmap[i] - shift * (beatmap[i] - beatmap[i-1]))
+    return beatmap
+
+def generate(audio: np.ndarray, sr: int, lib='madmom.BeatDetectionProcessor', caching=True, filename: str = None, log = True, load_settings = True, split=None):
+    """Creates beatmap attribute with a list of positions of beats in samples."""
+    if log is True: print(f'Analyzing beats using {lib}; ', end='')
+
+    # load a beatmap if it is cached:
+    if caching is True and filename is not None:
+        audio_id=hex(len(audio[0]))
+        import os
+        if not os.path.exists('beat_manipulator/beatmaps'):
+            os.mkdir('beat_manipulator/beatmaps')
+        cacheDir="beat_manipulator/beatmaps/" + ''.join(filename.replace('\\', '/').split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
+        try: 
+            beatmap=np.loadtxt(cacheDir, dtype=int)
+            if log is True: print('loaded cached beatmap.')
+        except OSError: 
+            if log is True:print("beatmap hasn't been generated yet. Generating...")
+            beatmap = None
+
+    #generate the beatmap
+    if beatmap is None:
+        if 'madmom' in lib.lower():
             from collections.abc import MutableMapping, MutableSequence
             import madmom
+            assert len(audio[0])>sr*2, f'Audio file is too short, len={len(audio[0])} samples, or {len(audio[0])/sr} seconds. Minimum length is 2 seconds, audio below that breaks madmom processors.'
         if lib=='madmom.BeatTrackingProcessor':
             proc = madmom.features.beats.BeatTrackingProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            assert len(act)>200, f'Audio file is too short, len={len(act)}'
-            self.beatmap= proc(act)*self.samplerate
-        if lib=='madmom.BeatTrackingProcessor.constant':
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
+        elif lib=='madmom.BeatTrackingProcessor.constant':
             proc = madmom.features.beats.BeatTrackingProcessor(fps=100, look_ahead=None)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        if lib=='madmom.BeatTrackingProcessor.consistent':
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
+        elif lib=='madmom.BeatTrackingProcessor.consistent':
             proc = madmom.features.beats.BeatTrackingProcessor(fps=100, look_ahead=None, look_aside=0)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.BeatDetectionProcessor':
             proc = madmom.features.beats.BeatDetectionProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            #print(proc, act)
-            assert len(act)>200, f'Audio file is too short, len={len(act)}'
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.BeatDetectionProcessor.consistent':
             proc = madmom.features.beats.BeatDetectionProcessor(fps=100, look_aside=0)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.CRFBeatDetectionProcessor':
             proc = madmom.features.beats.CRFBeatDetectionProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.CRFBeatDetectionProcessor.constant':
             proc = madmom.features.beats.CRFBeatDetectionProcessor(fps=100, use_factors=True, factors=[0.5, 1, 2])
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.DBNBeatTrackingProcessor':
             proc = madmom.features.beats.DBNBeatTrackingProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.DBNBeatTrackingProcessor.1000':
             proc = madmom.features.beats.DBNBeatTrackingProcessor(fps=100, transition_lambda=1000)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
         elif lib=='madmom.DBNDownBeatTrackingProcessor':
             proc = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[4], fps=100)
-            act = madmom.features.downbeats.RNNDownBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-            self.beatmap=self.beatmap[:,0]
+            act = madmom.features.downbeats.RNNDownBeatProcessor()(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
+            beatmap=beatmap[:,0]
         elif lib=='madmom.PatternTrackingProcessor': #broken
             from madmom.models import PATTERNS_BALLROOM
             proc = madmom.features.downbeats.PatternTrackingProcessor(PATTERNS_BALLROOM, fps=50)
@@ -107,306 +132,64 @@ class beatmap:
             diff = SpectrogramDifferenceProcessor(positive_diffs=True)
             mb = MultiBandSpectrogramProcessor(crossover_frequencies=[270])
             pre_proc = SequentialProcessor([log, diff, mb])
-            act = pre_proc(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-            self.beatmap=self.beatmap[:,0]
+            act = pre_proc(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
+            beatmap=beatmap[:,0]
         elif lib=='madmom.DBNBarTrackingProcessor': #broken
-            beats = self.generate(audio=self.audio, samplerate=self.samplerate, filename=self.filename, lib='madmom.DBNBeatTrackingProcessor', caching = caching)
+            beats = generate(audio=audio, sr=sr, filename=filename, lib='madmom.DBNBeatTrackingProcessor', caching = caching)
             proc = madmom.features.downbeats.DBNBarTrackingProcessor(beats_per_bar=[4], fps=100)
-            act = madmom.features.downbeats.RNNBarProcessor()(((madmom.audio.signal.Signal(self.audio.T, self.samplerate)), beats))
-            self.beatmap= proc(act)*self.samplerate
+            act = madmom.features.downbeats.RNNBarProcessor()(((madmom.audio.signal.Signal(audio.T, sr)), beats))
+            beatmap= proc(act)*sr
         elif lib=='librosa': #broken in 3.9, works in 3.8
             import librosa
-            beat_frames = librosa.beat.beat_track(y=self.audio[0], sr=self.samplerate, hop_length=512)
-            self.beatmap = librosa.frames_to_samples(beat_frames[1])
-        # elif lib=='BeatNet':
-        #     from BeatNet.BeatNet import BeatNet # doesn't seem to work well for some reason
-        #     estimator = BeatNet(1, mode='offline', inference_model='DBN', plot=[], thread=False)
-        #     beatmap = estimator.process(filename)
-        #     beatmap=beatmap[:,0]*self.samplerate
-        # elif lib=='jump-reward-inference': # doesn't seem to work well for some reason
-        #     from jump_reward_inference.joint_tracker import joint_inference
-        #     estimator = joint_inference(1, plot=False)
-        #     beatmap = estimator.process(filename)
-        #     beatmap=beatmap[:,0]*self.samplerate
-
-        elif lib=='split':
-            self.beatmap= list(range(0, len(self.audio[0]), len(self.audio[0])//split))
-        elif lib=='stunlocked':
-            from . import analyze
-            self.beatmap = analyze.detect_bpm(self.audio, self.samplerate)
-        if lib.split('.')[0]=='madmom':
-            self.beatmap=numpy.absolute(self.beatmap-500)
-        if caching is True and self.caching is True: numpy.savetxt(cacheDir, self.beatmap.astype(int), fmt='%d')
-        self.bpm=numpy.average(self.beatmap)/self.samplerate
-        if isinstance(self.beatmap, list): self.beatmap=numpy.asarray(self.beatmap, dtype=int)
-        self.beatmap=self.beatmap.astype(int)
-
-    def scale(self, scale:float):
-        if isinstance(scale, str): scale = _safer_eval(scale)
-        #print(scale)
-        assert scale>0, f"scale should be > 0, your scale is {scale}"
-        #print(self.beatmap)
-        import math
-        if scale!=1:
-            if self.log is True: print(f'scale={scale}; ')
-            a=0
-            b=numpy.array([], dtype=int)
-            if scale%1==0:
-                while a <len( self.beatmap):
-                    #print(a, self.beatmap[int(a)], end=',       ')
-                    b=numpy.append(b,self.beatmap[int(a)])
-                    a+=scale
-                    #print(self.beatmap[int(a)])
-            else:
-                while a+1 <len( self.beatmap):
-                    #print(a,b)
-                    b=numpy.append(b, int((1-(a%1))*self.beatmap[math.floor(a)]+(a%1)*self.beatmap[math.ceil(a)]))
-                    a+=scale
-            self.beatmap=b
-
-    def autoscale(self):
-        if self.log is True: print(f'autoscaling; ')
-        bpm=(self.beatmap[-1]-self.beatmap[0])/(len(self.beatmap)-1)
-        #print('BPM =', (bpm/self.samplerate) * 240, bpm)
-        if bpm>=160000: scale=1/8
-        elif (bpm)>=80000: scale=1/4
-        elif (bpm)>=40000: scale=1/2
-        elif (bpm)<=20000: scale=2
-        elif (bpm)<=10000: scale=4
-        elif (bpm)<=5000: scale=8
-        self.scale(scale)    
-
-    def autoinsert(self):
-        if self.log is True: print(f'autoinserting; ')
-        diff=(self.beatmap[1]-self.beatmap[0])
-        a=0
-        while diff<self.beatmap[0] and a<100:
-            self.beatmap=numpy.insert(self.beatmap, 0, self.beatmap[0]-diff)
-            a+=1
-
-    def shift(self, shift: float):
-        if isinstance(shift, str): shift = _safer_eval(shift)
-        if shift!=0 and self.log is True: print(f'shift={shift}; ')
-        elif shift==0: return
-        if shift<0:
-            shift=-shift # so that floor division works correctly
-            # add integer number of beats to the start
-            if shift >= 1: self.beatmap=numpy.insert(self.beatmap, 0, list(i+1 for i in range(int(shift//1))))
-            if shift%1!=0:
-                # shift by modulus from the end
-                shift=shift%1
-                for i in reversed(range(len(self.beatmap))):
-                    if i==0: continue
-                    #print(i, ', ',self.beatmap[i], '-', shift, '* (', self.beatmap[i], '-', self.beatmap[i-1],') =', self.beatmap[i] - shift * (self.beatmap[i] - self.beatmap[i-1]))
-                    self.beatmap[i] = int(self.beatmap[i] - shift * (self.beatmap[i] - self.beatmap[i-1]))
-        
-        elif shift>0:
-            # remove integer number of beats from the start
-            if shift >= 1: self.beatmap=self.beatmap[int(shift//1):]
-            if shift%1!=0:
-                # shift by modulus
-                shift=shift%1
-                for i in range(len(self.beatmap)-int(shift)-1):
-                    #print(self.beatmap[i], '+', shift, '* (', self.beatmap[i+1], '-', self.beatmap[i],') =', self.beatmap[i] + shift * (self.beatmap[i+1] - self.beatmap[i]))
-                    self.beatmap[i] = int(self.beatmap[i] + shift * (self.beatmap[i+1] - self.beatmap[i]))
+            beat_frames = librosa.beat.beat_track(y=audio[0], sr=sr, hop_length=512)
+            beatmap = librosa.frames_to_samples(beat_frames[1])
         
-        self.beatmap=sorted(list(self.beatmap))
-        while True:
-            n,done=0,[]
-            for i in range(len(self.beatmap)):
-                if self.beatmap.count(self.beatmap[i])>1 and i not in done:
-                    self.beatmap[i]+=1
-                    n+=1
-                    done.append(i)
-            if n==0: break
-        self.beatmap=sorted(list(self.beatmap))
-
-    def cut(self, start=0, end=None):
-        if start!=0 or end is not None and self.log is True: print(f'start={start}; end={end}; ')
-        start*=self.samplerate
-        self.beatmap=self.beatmap[self.beatmap>=start].astype(int)
-        if end is not None: self.beatmap=self.beatmap[self.beatmap<=end].astype(int)
-
-class hitmap(beatmap):
-    def generate(self, lib='madmom.MultiModelSelectionProcessor', caching=True):
-        if self.log is True: print(f'analyzing hits using {lib}; ')
-        self.hitlib=lib
-        """Finds positions of actual instrument/drum hits."""
-        if caching is True and self.caching is True:
-            audio_id=hex(len(self.audio[0]))
-            import os
-            if not os.path.exists('SavedBeatmaps'):
-                os.mkdir('SavedBeatmaps')
-            cacheDir="SavedBeatmaps/" + ''.join(self.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
-            try: 
-                cached=False
-                self.beatmap=numpy.loadtxt(cacheDir)
-                cached=True
-            except OSError: cached=False
-        if cached is False:
-            if lib=='madmom.RNNBeatProcessor': #broken
-                import madmom
-                proc = madmom.features.beats.RNNBeatProcessor()
-                self.beatmap = proc(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            elif lib=='madmom.MultiModelSelectionProcessor':
-                import madmom
-                proc = madmom.features.beats.RNNBeatProcessor(post_processor=None)
-                predictions = proc(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-                mm_proc = madmom.features.beats.MultiModelSelectionProcessor(num_ref_predictions=None)
-                self.beatmap= mm_proc(predictions)*self.samplerate
-                self.beatmap/= numpy.max(self.beatmap)
-            if caching is True and self.caching is True: numpy.savetxt(cacheDir, self.beatmap)
+        # save the beatmap and return
+        if caching is True: np.savetxt(cacheDir, beatmap.astype(int), fmt='%d')
+        if not isinstance(beatmap, np.ndarray): beatmap=np.asarray(beatmap, dtype=int)
+        else: beatmap=beatmap.astype(int)
+
+    if load_settings is True:
+        settingsDir="beat_manipulator/beatmaps/" + ''.join(filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'_settings.txt'
+        if os.path.exists(settingsDir):
+            with open(settingsDir, 'r') as f:
+                settings = f.read().split(',')
+            if settings[0] != 'None': beatmap = scale(beatmap, settings[0], log = False)
+            if settings[1] != 'None': beatmap = shift(beatmap, settings[1], log = False)
+            if settings[2] != 'None': beatmap = np.sort(np.absolute(beatmap - int(settings[2])))
+
+    return beatmap
+
+
+
+def save_settings(audio: np.ndarray, filename: str = None, lib: str = 'madmom.BeatDetectionProcessor', scale: float = None, shift: float = None, adjust: int = None, normalized: str = None, log = True, overwrite = 'ask'):
+    if isinstance(overwrite, str): overwrite = overwrite.lower()
+    audio_id=hex(len(audio[0]))
+    cacheDir="beat_manipulator/beatmaps/" + ''.join(filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
+    import os
+    assert os.path.exists(cacheDir), f"Beatmap `{cacheDir}` doesn't exist"
+    settingsDir="beat_manipulator/beatmaps/" + ''.join(filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'_settings.txt'
+
+    try: 
+        a = utils._safer_eval_strict(scale)
+        if a == 1: scale = None
+    except Exception as e: assert scale is None, f'scale = `{scale}` - Not a valid scale, should be either a number, a math expression, or None: {e}'
+    try: 
+        a = utils._safer_eval_strict(shift)
+        if a == 0: shift = None
+    except Exception as e: assert shift is None, f'shift = `{shift}` - Not a valid shift: {e}'
+    assert isinstance(adjust, int) or adjust is None, f'adjust = `{adjust}` should be int, but it is `{type(adjust)}`'
     
-    def osu(self, difficulties = [0.2, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01, 0.005]):
-        if self.log is True: print(f'generating osu file')
-        def _process(self, threshold):
-            hitmap=[]
-            actual_samplerate=int(self.samplerate/100)
-            beat_middle=int(actual_samplerate/2)
-            for i in range(len(self.beatmap)):
-                if self.beatmap[i]>threshold: hitmap.append(i*actual_samplerate + beat_middle)
-            hitmap=numpy.asarray(hitmap)
-            clump=[]
-            for i in range(len(hitmap)-1):
-                #print(i, abs(self.beatmap[i]-self.beatmap[i+1]), clump)
-                if abs(hitmap[i] - hitmap[i+1]) < self.samplerate/16: clump.append(i)
-                elif clump!=[]: 
-                    clump.append(i)
-                    actual_time=hitmap[clump[0]]
-                    hitmap[numpy.array(clump)]=0
-                    #print(self.beatmap)
-                    hitmap[clump[0]]=actual_time
-                    clump=[]
-            
-            hitmap=hitmap[hitmap!=0]
-            return hitmap
-        
-        osufile=lambda title,artist,version: ("osu file format v14\n"
-        "\n"
-        "[General]\n"
-        f"AudioFilename: {self.path.split('/')[-1]}\n"
-        "AudioLeadIn: 0\n"
-        "PreviewTime: -1\n"
-        "Countdown: 0\n"
-        "SampleSet: Normal\n"
-        "StackLeniency: 0.5\n"
-        "Mode: 0\n"
-        "LetterboxInBreaks: 0\n"
-        "WidescreenStoryboard: 0\n"
-        "\n"
-        "[Editor]\n"
-        "DistanceSpacing: 1.1\n"
-        "BeatDivisor: 4\n"
-        "GridSize: 8\n"
-        "TimelineZoom: 1.6\n"
-        "\n"
-        "[Metadata]\n"
-        f"Title:{title}\n"
-        f"TitleUnicode:{title}\n"
-        f"Artist:{artist}\n"
-        f"ArtistUnicode:{artist}\n"
-        f'Creator:{self.hitlib} + BeatManipulator\n'
-        f'Version:{version} {self.hitlib}\n'
-        'Source:\n'
-        'Tags:BeatManipulator\n'
-        'BeatmapID:0\n'
-        'BeatmapSetID:-1\n'
-        '\n'
-        '[Difficulty]\n'
-        'HPDrainRate:4\n'
-        'CircleSize:4\n'
-        'OverallDifficulty:7.5\n'
-        'ApproachRate:10\n'
-        'SliderMultiplier:3.3\n'
-        'SliderTickRate:1\n'
-        '\n'
-        '[Events]\n'
-        '//Background and Video events\n'
-        '//Break Periods\n'
-        '//Storyboard Layer 0 (Background)\n'
-        '//Storyboard Layer 1 (Fail)\n'
-        '//Storyboard Layer 2 (Pass)\n'
-        '//Storyboard Layer 3 (Foreground)\n'
-        '//Storyboard Layer 4 (Overlay)\n'
-        '//Storyboard Sound Samples\n'
-        '\n'
-        '[TimingPoints]\n'
-        '0,140.0,4,1,0,100,1,0\n'
-        '\n'
-        '\n'
-        '[HitObjects]\n')
-        # remove the clumps
-        #print(self.beatmap)
+    if adjust == 0: adjust = None
 
-        #print(self.beatmap)
-
-        
-        #print(len(osumap))
-        #input('banana')
-        import shutil, os
-        if os.path.exists('BeatManipulator_TEMP'): shutil.rmtree('BeatManipulator_TEMP')
-        os.mkdir('BeatManipulator_TEMP')
-        hitmap=[]
-        import random
-        for difficulty in difficulties:
-            for i in range(4):
-                #print(i)
-                this_difficulty=_process(self, difficulty)
-            hitmap.append(this_difficulty)
-        for k in range(len(hitmap)):
-            osumap=numpy.vstack((hitmap[k],numpy.zeros(len(hitmap[k])),numpy.zeros(len(hitmap[k])))).T
-            difficulty= difficulties[k]
-            for i in range(len(osumap)-1):
-                if i==0:continue
-                dist=(osumap[i,0]-osumap[i-1,0])*(1-(difficulty**0.3))
-                if dist<1000: dist=0.005
-                elif dist<2000: dist=0.01
-                elif dist<3000: dist=0.015
-                elif dist<4000: dist=0.02
-                elif dist<5000: dist=0.25
-                elif dist<6000: dist=0.35
-                elif dist<7000: dist=0.45
-                elif dist<8000: dist=0.55
-                elif dist<9000: dist=0.65
-                elif dist<10000: dist=0.75
-                elif dist<12500: dist=0.85
-                elif dist<15000: dist=0.95
-                elif dist<20000: dist=1
-                #elif dist<30000: dist=0.8
-                prev_x=osumap[i-1,1]
-                prev_y=osumap[i-1,2]
-                if prev_x>0: prev_x=prev_x-dist*0.1
-                elif prev_x<0: prev_x=prev_x+dist*0.1
-                if prev_y>0: prev_y=prev_y-dist*0.1
-                elif prev_y<0: prev_y=prev_y+dist*0.1
-                dirx=random.uniform(-dist,dist)
-                diry=dist-abs(dirx)*random.choice([-1, 1])
-                if abs(prev_x+dirx)>1: dirx=-dirx
-                if abs(prev_y+diry)>1: diry=-diry
-                x=prev_x+dirx
-                y=prev_y+diry
-                #print(dirx,diry,x,y)
-                #print(x>1, x<1, y>1, y<1)
-                if x>1: x=0.8
-                if x<-1: x=-0.8
-                if y>1: y=0.8
-                if y<-1: y=-0.8
-                #print(dirx,diry,x,y)
-                osumap[i,1]=x
-                osumap[i,2]=y
-
-            osumap[:,1]*=300
-            osumap[:,1]+=300
-            osumap[:,2]*=180
-            osumap[:,2]+=220
-
-            file=osufile(self.artist, self.title, difficulty)
-            for j in osumap:
-                #print('285,70,'+str(int(int(i)*1000/self.samplerate))+',1,0')
-                file+=f'{int(j[1])},{int(j[2])},{str(int(int(j[0])*1000/self.samplerate))},1,0\n'
-            with open(f'BeatManipulator_TEMP/{self.artist} - {self.title} [BeatManipulator {difficulty} {self.hitlib}].osu', 'x', encoding="utf-8") as f:
-                f.write(file)
+    if os.path.exists(settingsDir):
+        if overwrite == 'ask' or overwrite =='a': 
+            what = input(f'`{settingsDir}` already exists. Overwrite (y/n)?: ')
+            if not (what.lower() == 'y' or what.lower() == 'yes'): return
+        elif not (overwrite == 'true' or overwrite =='y' or overwrite =='yes' or overwrite is True): return
+    
+    with open(settingsDir, 'w') as f:
+        f.write(f'{scale},{shift},{adjust},{normalized}')
+    if log is True: print(f"Saved scale = `{scale}`, shift = `{shift}`, adjust = `{adjust}` to `{settingsDir}`")
 
-    def autoinsert(): raise NotImplementedError("autoinserting won't work on hitmaps")
-    def autoscale(): raise NotImplementedError("autoscale won't work on hitmaps")

beat_manipulator/effect.py

@@ -1,106 +0,0 @@
-import numpy
-
-def normalize(audio):
-    audio=audio-(numpy.min(audio)+numpy.max(audio))/2
-    return audio*(1-(max(numpy.max(audio), abs(numpy.min(audio)))))
-
-def pitch(audio, pitch, grain):
-    grain=int(grain)
-    if len(audio)>10: audio=[audio]
-    if type(audio) is not list: audio=audio.tolist()
-    length=len(audio[0])
-    if pitch<1:
-        pitch=int(1//pitch)
-        if grain%2!=0: grain+=1
-        for i in range(len(audio)):
-            n=0
-            while n+grain<length:
-                #print(len(audio[i]))
-                #print(n)
-                audio[i][n:n+grain]=numpy.repeat(audio[i][n:n+int(grain/2)], 2)
-                #print(len(audio[i]))
-                n+=grain
-    elif pitch>1:
-        pitch=int(pitch)
-        for i in range(len(audio)):
-            n=0
-            while n+grain<length:
-                audio[i][n:n+grain]=audio[i][n:n+grain:pitch]*pitch
-                n+=grain
-    return audio
-
-def pitchB(audio, pitch, grain):
-    grain=int(grain)
-    if len(audio)>10: audio=[audio]
-    if type(audio) is not list: audio=audio.tolist()
-    length=len(audio[0])
-    if pitch<1:
-        pitch=int(1//pitch)
-        if grain%2!=0: grain+=1
-        for i in range(len(audio)):
-            n=0
-            while n+grain<length:
-                #print(len(audio[i]))
-                #print(n)
-                audio[i][n:n+grain]=numpy.repeat(audio[i][n:n+int(grain/2)], 2)
-                #print(len(audio[i]))
-                n+=grain
-
-    elif pitch>1:
-        pitch=int(pitch)
-        for i in range(len(audio)):
-            n=0
-            while n+grain<length:
-                audio2=audio[i][n:n+grain:pitch]
-                for j in range(pitch-1):
-                    #print(j)
-                    audio2.extend(audio2[::1] if j%2==1 else audio2[::-1])
-                audio[i][n:n+grain]=audio2
-                n+=grain
-    return audio
-
-def grain(audio, grain):
-    grain=int(grain)
-    if len(audio)>10: audio=[audio]
-    if type(audio) is not list: audio=audio.tolist()
-    length=len(audio[0])
-    n=0
-    for i in range(len(audio)):
-        while n+2*grain<length:
-            audio[i][n+grain:n+2*grain]=audio[i][n:n+grain]
-            n+=grain*2
-    return audio
-
-def ftt(audio, inverse=True):
-    """headphone warning: cursed effect"""
-    import scipy.fft
-    audio=numpy.asarray(audio).copy()
-    for i in range(len(audio)):
-        if inverse is False:
-            audio[i]= scipy.fft.fft(audio[i], axis=0)
-        else: 
-            audio[i]= scipy.fft.ifft(audio[i], axis=0)
-    audio=(audio*(2/numpy.max(audio)))-1
-    return normalize(audio)
-    
-def fourier_shift(audio, value=5):
-    """modulates volume for some reason"""
-    import scipy.ndimage
-    audio=numpy.asarray(audio).copy()
-    audio= numpy.asarray(list(scipy.ndimage.fourier_shift(i, value, axis=-1) for i in audio)).astype(float)
-    return normalize(audio)
-
-def gradient(audio):
-    """acts as an interesting high pass filter that removes drums"""
-    audio=numpy.asarray(audio).copy()
-    return numpy.gradient(audio, axis=0)
-
-def gradient_inverse(audio):
-    """supposed to be inverse of a gradient, but it just completely destroys the audio into a distorted mess"""
-    audio=numpy.asarray(audio).copy()
-    for i in range(len(audio)):
-        a = audio[i]
-        audio[i] = a[0] + 2 * numpy.c_[numpy.r_[0, a[1:-1:2].cumsum()], a[::2].cumsum() - a[0] / 2].ravel()[:len(a)]
-    audio=normalize(audio)
-    return numpy.gradient(audio, axis=0)
-

beat_manipulator/effects.py

@@ -0,0 +1,84 @@
+import numpy as np
+from . import io
+
+def deco_abs(effect):
+    def stuff(*args, **kwargs):
+        if len(args)>0: audio = args[0]
+        else: audio = kwargs['audio']
+        if not isinstance(audio, np.ndarray): audio = io._load(audio)
+        audio_signs = np.sign(audio)
+        audio = np.abs(audio)
+        if len(args)>0: args[0] = audio
+        else: kwargs['audio'] = audio
+        audio = effect(*args, **kwargs)
+        audio *= audio_signs
+    return stuff
+
+
+
+def volume(audio: np.ndarray, v: float):
+    return audio*v
+
+def speed(audio: np.ndarray, s: float = 2, precision:int = 24):
+    if s%1 != 0 and (1/s)%1 != 0:
+        import fractions
+        s = fractions.Fraction(s).limit_denominator(precision)
+        audio = np.repeat(audio, s.denominator, axis=1)
+        return audio[:,::s.numerator]
+    elif s%1 == 0:
+        return audio[:,::int(s)]
+    else:
+        return np.repeat(audio, int(1/s), axis=1)
+
+def channel(audio: np.ndarray, c:int = None):
+    if c is None:
+        audio[0], audio[1] = audio[1], audio[0]
+        return audio
+    elif c == 0:
+        audio[0] = 0
+        return audio
+    else:
+        audio[1] = 0
+        return audio
+    
+def downsample(audio: np.ndarray, d:int = 10):
+    return np.repeat(audio[:,::d], d, axis=1)
+
+def gradient(audio: np.ndarray, number: int = 1):
+    for _ in range(number):
+        audio = np.gradient(audio, axis=1)
+    return audio
+
+def bitcrush(audio: np.ndarray, b:float = 4):
+    if 1/b > 1:
+        return np.around(audio, decimals=int(1/b))
+    else: 
+        return np.around(audio*b, decimals = 1)
+
+def reverse(audio: np.ndarray):
+    return audio[:,::-1]
+
+def normalize(audio: np.ndarray):
+    return audio*(1/np.max(np.abs(audio)))
+
+def clip(audio: np.ndarray):
+    return np.clip(audio, -1, 1)
+
+def to_sidechain(audio: np.ndarray):
+    audio = np.clip(np.abs(audio), -1, 1)
+    for channel in range(len(audio)):
+        audio[channel] = np.abs(1 - np.convolve(audio[channel], np.ones(shape=(1000)), mode = 'same'))
+    return audio
+
+
+
+# some stuff is defined in main.py to reduce function calls for 1 line stuff
+BM_EFFECTS = {
+    "v": "volume",
+    "s": speed,
+    "c": channel,
+    "d": "downsample",
+    "g": "gradient",
+    "b": bitcrush,
+    "r": "reverse",
+}

beat_manipulator/generate.py

@@ -1,22 +0,0 @@
-import numpy
-def sidechain(samplerate:int = 44100, 
-                       length: float = 0.5, 
-                       curve: float = 2, 
-                       vol0: float = 0, 
-                       vol1: float = 1, 
-                       smoothing: int = 40,
-                       channels:int = 2) -> tuple:
-    
-    x = numpy.linspace(vol0,vol1,int(length*samplerate))**curve
-    if smoothing is not None:
-        x = numpy.concatenate(numpy.linspace(1,0,smoothing),x)
-    return tuple(x for _ in range(channels)) if channels>1 else x
-    
-def sine(len, freq, samplerate, volume=1):
-    return numpy.sin(numpy.linspace(0, freq*3.1415926*2*len, int(len*samplerate)))*volume
-
-def saw(len, freq, samplerate, volume=1):
-    return (numpy.linspace(0, freq*2*len, int(len*samplerate))%2 - 1)*volume
-
-def square(len, freq, samplerate, volume=1):
-    return ((numpy.linspace(0, freq*2*len, int(len*samplerate)))//1%2 * 2 - 1)*volume

beat_manipulator/google colab.ipynb

@@ -0,0 +1,176 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ldVF6dMTbqB7"
+      },
+      "source": [
+        "#Beat Manipulator"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title 1. Run this cell to install all necessary libraries. This only needs to be done once each time you open this collab.\n",
+        "import shutil, os\n",
+        "try:\n",
+        "  if os.path.exists('BeatManipulator'): shutil.rmtree('BeatManipulator', ignore_errors=True)\n",
+        "except: pass\n",
+        "!pip install numpy cython soundfile ffmpeg-python pedalboard librosa\n",
+        "!pip install madmom\n",
+        "!git clone https://github.com/stunlocked1/BeatManipulator\n",
+        "%cd BeatManipulator\n",
+        "import beat_manipulator as bm"
+      ],
+      "metadata": {
+        "id": "E-gDjnzBby5-",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FYVs2fGzbqB9"
+      },
+      "source": [
+        "***\n",
+        "Use cells below as many times as you wish. Pattern syntax, scale and shift are explained here https://github.com/stunlocked1/BeatManipulator\n",
+        "\n",
+        "Enter pattern, scale and shift, run the cell, and it will let you upload your audio file.\n",
+        "\n",
+        "Analyzing beats for the first time will take some time, but if you open the same file for the second time, it will load a saved beat map."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "TFOLf-vrbqB-",
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "#@title 2. Beatswapping. Enter pattern, scale and shift, run the cell, and it will let you upload your audio file.\n",
+        "pattern = \"1, 3, 2, 4\" #@param {type:\"string\"}\n",
+        "scale = 1 #@param {type:\"number\"}\n",
+        "shift = 0 #@param {type:\"number\"}\n",
+        "\n",
+        "pattern_length = None # Length of the pattern. If None, this will be inferred from the highest number in the pattern\n",
+        "\n",
+        "\n",
+        "import beat_manipulator as bm, IPython\n",
+        "from google.colab import files\n",
+        "uploaded = list(files.upload().keys())[0]\n",
+        "path = bm.beatswap(audio=uploaded, pattern = pattern, scale = scale, shift = shift, length = pattern_length)\n",
+        "IPython.display.Audio(path)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "***\n",
+        "## Other stuff\n",
+        "Those operate the same as the above cell"
+      ],
+      "metadata": {
+        "id": "fQVrYbQ_rQzm"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Song to image**\n",
+        "\n",
+        "creates an image based on beat positions. Each song will generate a unique image. The image will be a square, you can specify maximum size.` "
+      ],
+      "metadata": {
+        "id": "7gc2jbelrTMb"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Song to image\n",
+        "image_size = 512 #@param {type:\"integer\"}\n",
+        "\n",
+        "\n",
+        "import beat_manipulator as bm, IPython\n",
+        "from google.colab import files\n",
+        "uploaded = list(files.upload().keys())[0]\n",
+        "path = bm.image(audio=uploaded, max_size = image_size)\n",
+        "IPython.display.Image(path)"
+      ],
+      "metadata": {
+        "id": "M2ufXQaxrWZT",
+        "cellView": "form"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "***\n",
+        "**osu! beatmap generator**\n",
+        "\n",
+        "generates an osu! beatmap from your song. This generates a hitmap, probabilities of hits at each sample, picks all ones above a threshold, and turns them into osu circles, trying to emulate actual osu beatmap. This doesn't generate sliders, however, because no known science has been able to comprehend the complexity of those.\n",
+        "\n",
+        "The .osz file will be downloaded automatically, open with osu! to install like any other beatmap."
+      ],
+      "metadata": {
+        "id": "bqOYyiCisAjM"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "difficulties = [0.2, 0.1, 0.05, 0.025, 0.01, 0.0075, 0.005, 0.0025, 0.0001] # all difficulties will be embedded in one beatmap, Lower is typically harder, but not always.\n",
+        "\n",
+        "\n",
+        "import beat_manipulator.osu\n",
+        "from google.colab import files\n",
+        "uploaded = list(files.upload().keys())[0]\n",
+        "path = beat_manipulator.osu.generate(song=uploaded, difficulties = difficulties)\n",
+        "files.download(f'/content/BeatManipulator/{path}')"
+      ],
+      "metadata": {
+        "id": "T1wLIS1_sB_K"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "audio310",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.9"
+    },
+    "orig_nbformat": 4,
+    "vscode": {
+      "interpreter": {
+        "hash": "f56da36b984886453ea677d340712034d0bd218b2dc7a53ab7c38da0c6f67f35"
+      }
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

beat_manipulator/image.py

@@ -1,179 +1,70 @@
-import numpy
-
-class image:
-    def __init__(self, image=None, audio=None, samplerate=None, beatmap=None, log=None):
-        self.image=image
-        self.audio = audio
-        self.samplerate=samplerate
-        self.beatmap=beatmap
-        self.log=log
-
-    def __getitem__(self, var):
-        return self.beatmap[var]
-
-    def _printlog(self, string, end=None, force = False, forcei = False):
-        if (self.log is True or force is True) and forcei is False:
-            if end is None: print(string)
-            else:print(string,end=end)
-
-    def _toshape(self):
-        if self.image.ndim == 2: 
-            self.image = [self.image]
-        if self.image.ndim == 3:
-            if len(self.image[0][0]) == 3:
-                self.image = [self.image]
-
-    def _channel(self):
-        if self.image.ndim == 2: yield self.image
-        if self.image.ndim == 3:
-            if len(self.image[0][0]) == 3:
-                yield self.image
-        if self.image.ndim > 3 or len(self.image[0][0] != 3):
-            for i in self.image:
-                yield i
-
-    @property
-    def combined(self):
-        for i, channel in enumerate(self._channel()):
-            if i==0: combined = channel.copy()
-            else: combined += channel
-        return combined
-
-    def open(self, path):
-        import cv2
-        self.image = cv2.imread(path)
-    
-    def display(self):
-        import cv2
-        cv2.imshow('image', self.combined)
-
-    def write(self, output, rotate = True, mode = 'square', maximum = 4096):
-        import cv2
-        mode = mode.lower()
-        image = self.combined
-        if mode=='square':
-            y=min(len(image), len(image[0]), maximum)
-            y=max(y, maximum)
-            image = cv2.resize(image, (y,y), interpolation=cv2.INTER_NEAREST)
-        elif mode=='tosmallest':
-            y=min(len(image), len(image[0]))
-            image = cv2.resize(image, (x,x), interpolation=cv2.INTER_NEAREST)
-        elif mode=='maximum':
-            x = min(len(image), maximum)
-            y = min(len(image[0]), maximum)
-            image = cv2.resize(image, (x,y), interpolation=cv2.INTER_NEAREST)
-        if rotate is True: image=image.T
-        cv2.imwrite(output, image)
-
-
-    def effect_blur(self, value=(5,5)):
-        """similar to echo"""
-        import cv2
-        if isinstance(value, int) or isinstance(value, float): value = (value, value)
-        for i in range(len(self.image)):
-            self.image[i]=cv2.blur(self.image[i], value)
-
-    def effect_median(self, value=5):
-        """similar to echo"""
-        import scipy.signal
-        for i in range(len(self.image)):
-            self.image[i]=scipy.signal.medfilt2d(self.image[i], value)
-
-    def effect_uniform(self, value=5):
-        """similar to echo"""
-        import scipy.ndimage
-        for i in range(len(self.image)):
-            self.image[i]= scipy.ndimage.uniform_filter(self.image[i], value)
-
-    def effect_shift2d(self, value=5):
-        """very weird effect, mostly produces silence"""
-        import scipy.ndimage
-        self.image= scipy.ndimage.fourier_gaussian(self.image, value)
-        self.image=self.image*(255/numpy.max(self.image))
-
-    def effect_spline(self, value=3):
-        """barely noticeable echo"""
-        import scipy.ndimage
-        for i in range(len(self.image)):
-            self.image[i]= scipy.ndimage.spline_filter(self.image[i], value)
-
-    def effect_rotate(self, value=0.1):
-        """rotates self.image in degrees"""
-        import scipy.ndimage
-        image = [0 for _ in range(len(self.image))]
-        for i in range(len(image)):
-            image[i] = scipy.ndimage.rotate(self.image[i], value)
-        self.image = numpy.asarray(image)
-
-    def effect_gradient(self):
-        self.image=numpy.asarray(numpy.gradient(self.image)[0])
-
-class spectogram(image):
-    def generate(self, hop_length:int = 512):
-        self.hop_length=hop_length
-        import librosa
-        self.image=librosa.feature.melspectrogram(y=self.audio, sr=self.samplerate, hop_length=hop_length)
-        self.mask = numpy.full(self.image.shape, True)
-        self._toshape()
-
-    def toaudio(self):
-        import librosa
-        self.audio=librosa.feature.inverse.mel_to_audio(M=numpy.swapaxes(numpy.swapaxes(numpy.dstack(( self.image[0,:,:],  self.image[1,:,:])), 0, 2), 1,2), sr=self.samplerate, hop_length=self.hop_length)
-        return self.audio
-    
-
-class beat_image(image):
-    def generate(self, mode='median'):
-        """Turns song into an image based on beat positions."""
-        assert self.beatmap is not None, 'Please run song.beatmap.generate() first. beat_image.generate needs beatmap to work.'
-        self._printlog('generating beat-image; ')
-        mode=mode.lower()
-        if isinstance(self.audio,numpy.ndarray): self.audio=numpy.ndarray.tolist(self.audio)
-        # add the bits before first beat
-        self.image=([self.audio[0][0:self.beatmap[0]],], [self.audio[1][0:self.beatmap[0]],])
-        # maximum is needed to make the array homogeneous
-        maximum=self.beatmap[0]
-        values=[]
-        #print(self.beatmap)
-        values.append(self.beatmap[0])
-        for i in range(len(self.beatmap)-1):
-            self.image[0].append(self.audio[0][self.beatmap[i]:self.beatmap[i+1]])
-            self.image[1].append(self.audio[1][self.beatmap[i]:self.beatmap[i+1]])
-            maximum = max(self.beatmap[i+1]-self.beatmap[i], maximum)
-            values.append(self.beatmap[i+1]-self.beatmap[i])
-        if 'max' in mode: norm=int(maximum)
-        elif 'med' in mode: norm=int(numpy.median(values))
-        elif 'av' in mode: norm=int(numpy.average(values))
-        for i in range(len(self.image[0])):
-            beat_diff=norm-len(self.image[0][i])
-            if beat_diff>0:
-                self.image[0][i].extend([numpy.nan]*beat_diff)
-                self.image[1][i].extend([numpy.nan]*beat_diff)
-                #print(0, len(self.image[0][i]), len(self.image[1][i]))
-            elif beat_diff<0:
-                self.image[0][i]=self.image[0][i][:beat_diff]
-                self.image[1][i]=self.image[1][i][:beat_diff]
-                #print(1, len(self.image[0][i]), len(self.image[1][i]))
-        self.image=numpy.asarray(self.image)*255
-        self.mask = self.image == numpy.nan
-        self.image=numpy.nan_to_num(self.image)
-        self._toshape()
-
-    def toaudio(self):
-        self._printlog('converting beat-image to audio; ')
-        image=numpy.asarray(self.image)/255
-        try: image[self.mask]=numpy.nan
-        except IndexError: pass
-        audio=list([] for _ in range(len(image)))
-        #print(audio)
-        #print(len(image), len(image[0]), len(image[1]), len(image[0][0]), len(image[1][0]), len(image[0][1]), len(image[1][1]))
-        for j in range(len(image)):
-            for i in range(len(image[j])):
-                beat=image[j][i]
-                #print(i,j, len(image[0][j]), len(image[1][j]), len(beat), end='     ')
-                beat=beat[~numpy.isnan(beat)]
-                #print(len(beat), end='     ')
-                audio[j].extend(beat)
-                #print(len(audio[0]), len(audio[1]))
-        self.audio=numpy.asarray(audio)
-        return self.audio
+from . import io, main
+import numpy as np
+def generate(song, beatmap = None, mode='median', sr = None, log = True):
+    if log is True: print(f'Generating an image from beats...', end = ' ')
+    song = main.song(song, sr=sr)
+    if song.beatmap is None: song.beatmap = beatmap
+    if song.beatmap is None: song.beatmap_generate()
+    if isinstance(song.audio, np.ndarray): song.audio = song.audio.tolist()
+    # create the image
+    image = [[],[]]
+    for i in range(1, len(song.beatmap)):
+        beat = song[i]
+        image[0].append(beat[0])
+        image[1].append(beat[1])
+
+    # find image width
+    lengths = [len(i) for i in image[0]]
+    mode = mode.lower()
+    if 'max' in mode:
+        width = max(lengths)
+    elif 'med' in mode:
+        width = int(np.median(lengths))
+    elif 'av' in mode:
+        width = int(np.average(lengths))
+
+    # fill or crop rows:
+    for i in range(len(image[0])):
+        difference = lengths[i] - width
+        if difference<0:
+            image[0][i].extend([np.nan]*(-difference))
+            image[1][i].extend([np.nan]*(-difference))
+        elif difference>0:
+            image[0][i] = image[0][i][:-difference]
+            image[1][i] = image[1][i][:-difference]
+
+    song.audio = np.array(song.audio, copy=False)
+    if log is True: print('Done!')
+    return np.array(image, copy=False)
+
+def bw_to_colored(image, channel = 2, fill = True):
+    if fill is True:
+        combined = image[0] * image[1]
+        combined = (np.abs(combined)**0.5)*np.sign(combined)
+    else: channel = np.zeros(shape = image[0].shape)
+    image = image.tolist()
+    if channel == 2: image.append(combined)
+    else: image.insert(channel, combined)
+    return np.rot90(np.array(image, copy=False).T)
+
+def colored_to_bw(image, l=0, r=1):
+    image = np.array(image, copy=False)
+    return np.array([image[:,:,l],image[:,:,r]])
+
+def write(image, output, mode = 'r', max_size = 4096, rotate = True, contrast=1):
+    import cv2
+    if max_size is not None:
+        w = max_size
+        h = min(len(image[0][0]), max_size)
+    if mode == 'color':
+        image = bw_to_colored(image)
+    elif mode == 'r':
+        image = image[0]
+    elif mode == 'l':
+        image = image[1]
+    elif mode == 'combine':
+        image = image[0] + image[1]
+    image = image*(255*contrast)
+    image = cv2.resize(src=image, dsize=(w, h), interpolation = cv2.INTER_NEAREST)
+    if rotate is True: image = np.rot90(image)
+    cv2.imwrite(output, image)

beat_manipulator/io.py

@@ -0,0 +1,178 @@
+
+import numpy as np
+from . import main
+
+def open_audio(path:str = None, lib:str = 'auto', normalize = True) -> tuple:
+    """Opens audio from path, returns (audio, samplerate) tuple.
+    
+    Audio is returned as an array with normal volume range between -1, 1.
+    
+    Example of returned audio: 
+    
+    [
+        [0.35, -0.25, ... -0.15, -0.15], 
+    
+        [0.31, -0.21, ... -0.11, -0.07]
+    ]"""
+
+    if path is None:
+        from tkinter.filedialog import askopenfilename
+        path = askopenfilename(title='select song', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
+    
+    path=path.replace('\\', '/')
+
+    if lib=='pedalboard.io':
+        import pedalboard.io
+        with pedalboard.io.AudioFile(path) as f:
+            audio = f.read(f.frames)
+            sr = f.samplerate
+    
+    elif lib=='librosa':
+        import librosa
+        audio, sr = librosa.load(path, sr=None, mono=False)
+    
+    elif lib=='soundfile':
+        import soundfile
+        audio, sr = soundfile.read(path)
+        audio=audio.T
+    
+    elif lib=='madmom':
+        import madmom
+        audio, sr = madmom.io.audio.load_audio_file(path, dtype=float)
+        audio=audio.T
+    
+    # elif lib=='pydub':
+    #     from pydub import AudioSegment
+    #     song=AudioSegment.from_file(filename)
+    #     audio = song.get_array_of_samples()
+    #     samplerate=song.frame_rate
+    #     print(audio)
+    #     print(filename)
+
+    elif lib=='auto':
+        for i in ('madmom', 'soundfile', 'librosa', 'pedalboard.io'):
+            try: 
+                audio,sr=open_audio(path, i)
+                break
+            except Exception as e:
+                print(f'open_audio with {i}: {e}')
+    
+    if len(audio)>16: audio=np.array([audio, audio], copy=False)
+    if normalize is True: 
+        audio = np.clip(audio, -1, 1)
+        audio = audio*(1/np.max(np.abs(audio)))
+    return audio.astype(np.float32),sr
+    
+def _sr(sr):
+    try: return int(sr)
+    except (ValueError, TypeError): assert False, f"Audio is an array, but `sr` argument is not valid. If audio is an array, you have to provide samplerate as an integer in the `sr` argument. Currently sr = {sr} of type {type(sr)}"
+
+def write_audio(audio:np.ndarray, sr:int, output:str, lib:str='auto', libs=('pedalboard.io', 'soundfile'), log = True):
+        """"writes audio to path specified by output. Path should end with file extension, for example `folder/audio.mp3`"""
+        if log is True: print(f'Writing {output}...', end=' ')
+        assert _iterable(audio), f"audio should be an array/iterable object, but it is {type(audio)}"
+        sr = _sr(sr)
+        if not isinstance(audio, np.ndarray): audio = np.array(audio, copy=False)
+        if lib=='pedalboard.io':
+            #print(audio)
+            import pedalboard.io
+            with pedalboard.io.AudioFile(output, 'w', sr, audio.shape[0]) as f:
+                f.write(audio)
+        elif lib=='soundfile':
+            audio=audio.T
+            import soundfile
+            soundfile.write(output, audio, sr)
+            del audio
+        elif lib=='auto':
+            for i in libs:
+                try: 
+                    write_audio(audio=audio, sr=sr, output=output, lib=i, log = False)
+                    break
+                except Exception as e:
+                    print(e)
+            else: assert False, 'Failed to write audio, chances are there is something wrong with it...'
+        if log is True: print(f'Done!')
+
+def _iterable(a):
+    try:
+        _ = iter(a)
+        return True
+    except TypeError: return False
+
+def _load(audio, sr:int = None, lib:str = 'auto', channels:int = 2, transpose3D:bool = False) -> tuple:
+    """Automatically converts audio from path or any format to [[...],[...]] array. Returns (audio, samplerate) tuple."""
+    # path
+    if isinstance(audio, str): return(open_audio(path=audio, lib=lib))
+    # array
+    if _iterable(audio):
+        if isinstance(audio, main.song):
+            if sr is None: sr = audio.sr
+            audio = audio.audio
+        # sr is provided in a tuple
+        if sr is None and len(audio) == 2:
+            if not _iterable(audio[0]):
+                sr = audio[0]
+                audio = audio[1]
+            elif not _iterable(audio[1]):
+                sr = audio[1]
+                audio = audio[0]
+        if not isinstance(audio, np.ndarray): audio = np.array(audio, copy=False)
+        sr = _sr(sr)
+        if _iterable(audio[0]):
+            # image
+            if _iterable(audio[0][0]):
+                audio2 = []
+                if transpose3D is True: audio = audio.T
+                for i in audio:
+                    audio2.extend(_load(audio=i, sr=sr, lib=lib, channels=channels, transpose3D=transpose3D)[0])
+                return audio2, sr
+            # transposed
+            if len(audio) > 16:
+                audio = audio.T
+                return _load(audio=audio, sr=sr, lib=lib, channels=channels, transpose3D=transpose3D)
+            # multi channel
+            elif isinstance(channels, int):
+                if len(audio) >= channels:
+                    return audio[:channels], sr
+                # masked mono
+                else: return np.array([audio[0] for _ in range(channels)], copy=False), sr
+            else: return audio, sr
+        else: 
+            # mono
+            return (np.array([audio for _ in range(channels)], copy=False) if channels is not None else audio), sr
+    # unknown
+    else: assert False, f"Audio should be either a string with path, an array/iterable object, or a song object, but it is {type(audio)}"
+
+def _tosong(audio, sr=None):
+    if isinstance(audio, main.song): return audio
+    else: 
+        audio, sr = _load(audio = audio, sr = sr)
+        return main.song(audio=audio, sr = sr)
+
+def _outputfilename(path:str = None, filename:str = None, suffix:str = None, ext:str = None):
+    """If path has file extension, returns `path + suffix + ext`. Else returns `path + filename + suffix + .ext`. If nothing is specified, returns `output.mp3`"""
+    if ext is not None:
+        if not ext.startswith('.'): ext = '.'+ext
+    if path is None: path = ''
+    if path.endswith('/') or path.endswith('\\'): path=path[:-1]
+    if '.' in path:
+        path = path.split('.')
+        if path[-1].lower() in ['mp3', 'wav', 'flac', 'ogg', 'wma', 'aac', 'ac3', 'aiff']:
+            if ext is not None:
+                path[-1] = ext
+            if suffix is not None: path[len(path)-2]+=suffix
+            return ''.join(path)
+        else: path = ''.join(path)
+    if filename is not None:
+        filename = filename.replace('\\','/').split('/')[-1]
+        if '.' in filename:
+            filename = filename.split('.')
+            if filename[-1].lower() in ['mp3', 'wav', 'flac', 'ogg', 'wma', 'aac', 'ac3', 'aiff']:
+                if ext is not None:
+                    filename[-1] = ext
+                if suffix is not None: filename.insert(len(filename)-1, suffix)
+            else: filename += [ext]
+            filename = ''.join(filename)
+            return f'{path}/{filename}' if path != '' else filename
+        return f'{(path + "/") * (path != "")}{filename}{suffix if suffix is not None else ""}.{ext if ext is not None else "mp3"}'
+    else: return f'{path}/output.mp3'

beat_manipulator/main.py

@@ -1,846 +1,516 @@
-import numpy
-numpy.set_printoptions(suppress=True)
-from .beatmap import beatmap, hitmap
-from .image import spectogram, beat_image
-
-def _safer_eval(string:str) -> float:
-    if isinstance(string, str): 
-        #print(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-        string = eval(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-    return string
-
-def open_audio(filename=None, lib='auto') -> numpy.ndarray:
-    """Opens audio from path, returns (audio, samplerate) tuple.
-    
-    Audio is returned as an array with normal volume range between -1, 1.
-    
-    Example of returned audio: 
-    
-    [
-        [0.35, -0.25, ... -0.15, -0.15], 
-    
-        [0.31, -0.21, ... -0.11, -0.07]
-    ]"""
-    if filename is None:
-        from tkinter.filedialog import askopenfilename
-        filename = askopenfilename(title='select song', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
-    filename=filename.replace('\\', '/')
-    if lib=='pedalboard.io':
-        import pedalboard.io
-        with pedalboard.io.AudioFile(filename) as f:
-            audio = f.read(f.frames)
-            samplerate = f.samplerate
-    elif lib=='librosa':
-        import librosa
-        audio, samplerate = librosa.load(filename, sr=None, mono=False)
-    elif lib=='soundfile':
-        import soundfile
-        audio, samplerate = soundfile.read(filename)
-        audio=audio.T
-    elif lib=='madmom':
-        import madmom
-        audio, samplerate = madmom.io.audio.load_audio_file(filename, dtype=float)
-        audio=audio.T
-    # elif lib=='pydub':
-    #     from pydub import AudioSegment
-    #     song=AudioSegment.from_file(filename)
-    #     audio = song.get_array_of_samples()
-    #     samplerate=song.frame_rate
-    #     print(audio)
-    #     print(filename)
-    elif lib=='auto':
-        for i in ('madmom', 'soundfile', 'librosa', 'pedalboard.io'):
-            try: 
-                audio,samplerate=open_audio(filename, i)
-                break
-            except Exception as e:
-                print(f'open_audio with {i}: {e}')
-    if len(audio)<2: audio=[audio]
-    return audio,samplerate
-
-
-def _outputfilename(output, filename, suffix=' (beatswap)', ext='mp3'):
-    if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
-            output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                return output+'.'.join(''.join(filename.split('/')[-1]).split('.')[:-1])+suffix+'.'+ext
-    
-class song:
-    def __init__(self, path:str=None, audio:numpy.array=None, samplerate:int=None, bmap:list=None, caching=True, filename=None, copied=False, log=True):
-        """song can be loaded from path to an audio file, or from a list/numpy array and samplerate. Audio array should have values from -1 to 1, multiple channels should be stacked vertically. Optionally you can provide your own beat map.
-        
-        Song object has the following attributes:
+import numpy as np, scipy.interpolate
+from . import io, utils
+from .effects import BM_EFFECTS
+from .metrics import BM_METRICS
+from .presets import BM_SAMPLES
 
-        path - file system path to load the audio file from. Can be absolute or relative.
-        
-        audio - either a numpy array with shape=(channels, values) or a list with two lists. Audio is converted to list for certain operations to improve performance.
-        
-        samplerate - integer, for example 44100. Determined automatically when audio is loaded from a path.
 
-        bmap - list of integers, with positions of each beat in samples.
+class song:
+    def __init__(self, audio = None, sr:int=None, log=True):
+        if audio is None: 
+            from tkinter import filedialog
+            audio = filedialog.askopenfilename()
+        
+        if isinstance(audio, song): self.path = audio.path
+        self.audio, self.sr = io._load(audio=audio, sr=sr)
+
+        # unique filename is needed to generate/compare filenames for cached beatmaps
+        if isinstance(audio, str):
+            self.path = audio
+        elif not isinstance(audio, song):
+            self.path = 'unknown_' + str(hex(int(np.sum(self.audio)*(10**18))))
+
+        self.log = log
+        self.beatmap = None
+        self.normalized = None
+
+    def _slice(self, a):
+        if a is None: return None
+        elif isinstance(a, float):
+            if (a_dec:=a%1) != 0:
+                a_int = int(int(a)//1)
+                start = self.beatmap[a_int]
+                return int(start + a_dec * (self.beatmap[a_int+1] - start))
+            else:
+                return self.beatmap[int(a)]
+        elif isinstance(a, int): return self.beatmap[a]
+        else: raise TypeError(f'slice indices must be int, float, or None, not {type(a)}. Indice is {a}')
+
+    def __getitem__(self, s):
+        if isinstance(s, slice): 
+            start = s.start
+            stop = s.stop
+            step = s.step
+            if start is not None and stop is not None:
+                if start > stop:
+                    is_reversed = -1
+                    start, stop = stop, start
+                else: is_reversed = None
+            if step is None or step == 1:
+                start = self._slice(start)
+                stop = self._slice(stop)
+                if isinstance(self.audio, list): return [self.audio[0][start:stop:is_reversed],self.audio[1][start:stop:is_reversed]]
+                else: return self.audio[:,start:stop:is_reversed]
+            else:
+                i = s.start if s.start is not None else 0
+                end = s.stop if s.stop is not None else len(self.beatmap)
+                if i > end: 
+                    step = -step
+                    if step > 0: i, end = end-2, i
+                elif step < 0: i, end = end-2, i
+                if step < 0: 
+                    is_reversed = True
+                    end -= 1
+                else: is_reversed = False
+                pattern = ''
+                while ((i > end) if is_reversed else (i < end)):
+                    pattern+=f'{i},'
+                    i+=step
+                song_copy = song(audio = self.audio, sr = self.sr, log = False)
+                song_copy.beatmap = self.beatmap.copy()
+                song_copy.beatmap = np.insert(song_copy.beatmap, 0, 0)
+                result = song_copy.beatswap(pattern = pattern, return_audio = True)
+                if isinstance(self.audio, np.ndarray): return result
+                else: return result.tolist()
+
+        elif isinstance(s, float):
+            start = self._slice(s-1)
+            stop = self._slice(s)
+            if isinstance(self.audio, list): return [self.audio[0][start:stop],self.audio[1][start:stop]]
+            else: return self.audio[:,start:stop]
+        elif isinstance(s, int):
+            start = self.beatmap[s-1]
+            stop = self.beatmap[s]
+            if isinstance(self.audio, list): return [self.audio[0][start:stop],self.audio[1][start:stop]]
+            else: return self.audio[:,start:stop]
+        elif isinstance(s, tuple):
+            start = self._slice(s[0])
+            stop = self._slice(s[0] + s[1])
+            if stop<0:
+                start -= stop
+                stop = -stop
+                step = -1
+            else: step = None
+            if isinstance(self.audio, list): return [self.audio[0][start:stop:step],self.audio[1][start:stop:step]]
+            else: return self.audio[:,start:stop:step]
+        elif isinstance(s, list):
+            start = s[0]
+            stop = s[1] if len(s) > 1 else None
+            if start > stop:
+                step = -1
+                start, stop = stop, start
+            else: step = None
+            start = self._slice(start)
+            stop = self._slice(stop)
+            if step is not None and stop is None: stop = self._slice(start + s.step)
+            if isinstance(self.audio, list): return [self.audio[0][start:stop:step],self.audio[1][start:stop:step]]
+            else: return self.audio[:,start:stop:step]
+        elif isinstance(s, str):
+            return self.beatswap(pattern = s, return_audio = True)
+
+        
+        else: raise TypeError(f'list indices must be int/float/slice/tuple, not {type(s)}; perhaps you missed a comma? Slice is `{s}`')
+
+
+    def _print(self, *args, end=None, sep=None):
+        if self.log: print(*args, end=end, sep=sep)
+
+
+    def write(self, output='', ext='mp3', suffix=' (beatswap)', literal_output=False):
+        """writes"""
+        if literal_output is False: output = io._outputfilename(output, filename=self.path, suffix=suffix, ext=ext)
+        io.write_audio(audio=self.audio, sr=self.sr, output=output, log=self.log)
+        return output
+
+
+    def beatmap_generate(self, lib='madmom.BeatDetectionProcessor', caching = True, load_settings = True):
+        """Find beat positions"""
+        from . import beatmap
+        self.beatmap = beatmap.generate(audio = self.audio, sr = self.sr, lib=lib, caching=caching, filename = self.path, log = self.log, load_settings = load_settings)
+        if load_settings is True:
+            audio_id=hex(len(self.audio[0]))
+            settingsDir="beat_manipulator/beatmaps/" + ''.join(self.path.split('/')[-1]) + "_"+lib+"_"+audio_id+'_settings.txt'
+            import os
+            if os.path.exists(settingsDir):
+                with open(settingsDir, 'r') as f:
+                    settings = f.read().split(',')
+                if settings[3] != None: self.normalized = settings[3]
+        self.beatmap_default = self.beatmap.copy()
+        self.lib = lib
+
+    def beatmap_scale(self, scale:float):
+        from . import beatmap
+        self.beatmap = beatmap.scale(beatmap = self.beatmap, scale = scale, log = self.log)
+
+    def beatmap_shift(self, shift:float, mode = 1):
+        from . import beatmap
+        self.beatmap = beatmap.shift(beatmap = self.beatmap, shift = shift, log = self.log, mode = mode)
+
+    def beatmap_reset(self):
+        self.beatmap = self.beatmap_default.copy()
+
+    def beatmap_adjust(self, adjust = 500):
+        self.beatmap = np.append(np.sort(np.absolute(self.beatmap - adjust)), len(self.audio[0]))
+
+    def beatmap_save_settings(self, scale: float = None, shift: float = None, adjust: int = None, normalized = None, overwrite = 'ask'):
+        from . import beatmap
+        if self.beatmap is None: self.beatmap_generate()
+        beatmap.save_settings(audio = self.audio, filename = self.path, scale = scale, shift = shift,adjust = adjust, normalized = normalized, log=self.log, overwrite=overwrite, lib = self.lib)
+
+    def beatswap(self, pattern = '1;"cowbell"s3v2, 2;"cowbell"s2, 3;"cowbell", 4;"cowbell"s0.5, 5;"cowbell"s0.25, 6;"cowbell"s0.4, 7;"cowbell"s0.8, 8;"cowbell"s1.6', 
+        scale:float = 1, shift:float = 0, length = None, samples:dict = BM_SAMPLES, effects:dict = BM_EFFECTS, metrics:dict = BM_METRICS, smoothing: int = 100, adjust=500, return_audio = False, normalize = False):
+        
+        if normalize is True:
+            self.normalize_beats()
+        if self.beatmap is None: self.beatmap_generate()
+        beatmap_default = self.beatmap.copy()
+        self.beatmap = np.append(np.sort(np.absolute(self.beatmap - adjust)), len(self.audio[0]))
+        self.beatmap_shift(shift)
+        self.beatmap_scale(scale)
+
+        # baked in presets
+        #reverse
+        if pattern.lower() == 'reverse':
+            if return_audio is False:
+                self.audio = self[::-1]
+                self.beatmap = beatmap_default.copy()
+                return
+            else:
+                result = self[::-1]
+                self.beatmap = beatmap_default.copy()
+                return result
+        # shuffle
+        elif pattern.lower() == 'shuffle':
+            import random
+            beats = list(range(len(self.beatmap)))
+            random.shuffle(beats)
+            beats = ','.join(list(str(i) for i in beats))
+            if return_audio is False:
+                self.beatswap(beats)
+                self.beatmap = beatmap_default.copy()
+                return
+            else:
+                result = self.beatswap(beats, return_audio = True)
+                self.beatmap = beatmap_default.copy()
+                return result
+        # test
+        elif pattern.lower() == 'test':
+            if return_audio is False:
+                self.beatswap('1;"cowbell"s3v2, 2;"cowbell"s2, 3;"cowbell", 4;"cowbell"s0.5, 5;"cowbell"s0.25, 6;"cowbell"s0.4, 7;"cowbell"s0.8, 8;"cowbell"s1.6')
+                self.beatmap = beatmap_default.copy()
+                return
+            else:
+                result = self.beatswap('1;"cowbell"s3v2, 2;"cowbell"s2, 3;"cowbell", 4;"cowbell"s0.5, 5;"cowbell"s0.25, 6;"cowbell"s0.4, 7;"cowbell"s0.8, 8;"cowbell"s1.6', return_audio = True)
+                self.beatmap = beatmap_default.copy()
+                return result
+        # random
+        elif pattern.lower() == 'random':
+            import random,math
+            pattern = ''
+            rand_length=0
+            while True:
+                rand_num = int(math.floor(random.triangular(1, 16, rand_length-1)))
+                if random.uniform(0, rand_num)>rand_length: rand_num = rand_length+1
+                rand_slice = random.choices(['','>0.5','>0.25', '<0.5', '<0.25', '<1/3', '<2/3', '>1/3', '>2/3', '<0.75', '>0.75', 
+                                             f'>{random.uniform(0.01,2)}', f'<{random.uniform(0.01,2)}'], weights = [13,1,1,1,1,1,1,1,1,1,1,1,1], k=1)[0]
+                
+                rand_effect = random.choices(['', 's0.5', 's2', f's{random.triangular(0.1,1,4)}', 'r','v0.5', 'v2', 'v0', 
+                                              f'd{int(random.triangular(1,8,16))}', 'g', 'c', 'c0', 'c1', f'b{int(random.triangular(1,8,4))}'], 
+                                              weights=[30, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 1], k=1)[0]
+                
+                rand_join = random.choices([', ', ';'], weights = [5, 1], k=1)[0]
+                pattern += f'{rand_num}{rand_slice}{rand_effect}{rand_join}'
+                if rand_join == ',': rand_length+=1
+                if rand_length in [4, 8, 16]: 
+                    if random.uniform(rand_num,16)>14: break
+                else: 
+                    if random.uniform(rand_num,16)>15.5: break
+            pattern_length = 4
+            if rand_length > 6: pattern_length = 8
+            if rand_length > 12: pattern_length = 16
+            if rand_length > 24: pattern_length = 32
+
+
+        
+        from . import parse
+        pattern, operators, pattern_length, shuffle_groups, shuffle_beats, c_slice, c_misc, c_join = parse.parse(pattern = pattern, samples = samples, pattern_length = length, log = self.log)
+        
+        #print(f'pattern length = {pattern_length}')
+
+        # beatswap
+        n=-1
+        tries = 0
+        metric = None
+        result=[self.audio[:,:self.beatmap[0]]]
+        #for i in pattern: print(i)
 
-        caching = True - if True, generated beatmaps will be saved to SavedBeatmaps folder and loaded when the same audio file is opened again, instead of generating beatmap each time.
 
-        log = True - if True, minimal info about all operations will be printed.
-        """
-        assert not (audio is not None and samplerate is None), 'If audio is provided, samplerate should be provided as well, for example samplerate=44100'
-        
-        self.audio=audio
-        self.samplerate=samplerate
-        
-        # ask for a path if audio isn't specified
-        if path is None and filename is None:
-            if audio is None:
-                from tkinter.filedialog import askopenfilename
-                self.path = askopenfilename(title='select song')
-            else:
-                # generate unique identifier for storing beatmap cache
-                audio_id = numpy.sum(audio[0][1000:2000]) if len(audio<2000) else numpy.sum(audio[1000:2000])
-                self.filename = 'unknown ' + str(hex(int(audio_id))) + ' ' + str(hex(int((audio_id%1)*(10**18))))
-                self.path = self.filename
-                print(self.filename)
-        else: 
-            if path is None: self.path=filename
-            else: self.path=path
-
-        # load from zip
-        if self.path.lower().endswith('.zip'): 
-            import shutil,os
-            if os.path.exists('BeatManipulator_TEMP'): shutil.rmtree('BeatManipulator_TEMP')
-            os.mkdir('BeatManipulator_TEMP')
-            shutil.unpack_archive(self.path, 'BeatManipulator_TEMP')
-            for root,dirs,files in os.walk('BeatManipulator_TEMP'):
-                for fname in files:
-                    if fname.lower().endswith('.mp3') or fname.lower().endswith('.wav') or fname.lower().endswith('.ogg') or fname.lower().endswith('.flac'):
-                        self.audio, self.samplerate=open_audio(root.replace('\\','/')+'/'+fname)
-                        stop=True
-                        break
-                if stop is True: break
-            shutil.rmtree('BeatManipulator_TEMP')
-    
-        # open audio from path
-        if self.audio is None or self.samplerate is None:
-            self.audio, self.samplerate=open_audio(self.path)
-
-        # mono to stereo
-        if len(self.audio)>16:
-            self.audio=numpy.asarray((self.audio,self.audio))
-
-        # stuff
-        self.path=self.path.replace('\\', '/')
-        if filename is None: self.filename=self.path.split('/')[-1]
-        else: self.filename=filename.replace('\\', '/').split('/')[-1]
-        self.samplerate=int(self.samplerate)
-
-        # artist,  title
-        if ' - ' in self.path.split('/')[-1]:
-            self.artist = self.path.split('/')[-1].split(' - ')[0]
-            self.title= '.'.join(self.path.split('/')[-1].split(' - ')[1].split('.')[:-1])
-        elif path is not None or filename is not None:
-            self.title=''.join(self.path.split('/')[-1].split('.')[:-1])
-            self.artist=None
-        else:
-            self.title = None
-            self.artist = None
-        self.caching=caching
-        self.log=log
-        if copied is False and self.log is True: 
-            if self.artist is not None or self.title is not None: print(f'Loaded {self.artist} - {self.title}; ')
-            elif filename is not None: print(f'Loaded {self.filename}; ')
-            elif path is not None: print(f'Loaded {self.path}; ')
-            else: print(f'Loaded audio file; ')
-        self.audio_isarray = True
-        
-        if isinstance(bmap, beatmap): self.beatmap=bmap
-        else: self.beatmap = beatmap(beatmap = bmap, audio= self.audio, samplerate=self.samplerate, filename=self.filename, caching = caching, log=log, path=self.path, artist=self.artist, title=self.title)
-        self.hitmap = hitmap(audio= self.audio, samplerate=self.samplerate, filename=self.filename, caching = caching, log=log, path=self.path, artist=self.artist, title=self.title)
-        self.spectogram = spectogram(audio=self.audio, samplerate=self.samplerate, beatmap=self.beatmap, log=self.log)
-        self.beat_image = beat_image(audio=self.audio, samplerate=self.samplerate, beatmap=self.beatmap, log=self.log)
-    
-    @property
-    def bm(self):
-        return self.beatmap.beatmap
-    
-    @property
-    def hm(self):
-        return self.hitmap.beatmap
-    
-    def _printlog(self, string, end=None, force = False, forcei = False):
-        if (self.log is True or force is True) and forcei is False:
-            if end is None: print(string)
-            else:print(string,end=end)
-    
-    def _audio_tolist(self, force = True):
-        if self.audio_isarray:
-            self.audio = self.audio.tolist()
-            self.audio_isarray = False
-        elif force is True: 
-            self.audio = self.audio.tolist()
-            self.audio_isarray = False
-
-    def _audio_toarray(self, force = True):
-        if not self.audio_isarray:
-            self.audio = numpy.asarray(self.audio)
-            self.audio_isarray = True
-        elif force is True: 
-            self.audio = numpy.asarray(self.audio)
-            self.audio_isarray = True
             
-    def _update(self):
-        self.beatmap.audio = self.audio
-        self.hitmap.audio = self.audio
-        self.spectogram.audio = self.audio
-        self.beat_image.audio = self.audio
-        self.beat_image.beatmap = self.bm
-
-    def write(self, output:str, lib:str='auto', libs=('pedalboard.io', 'soundfile')):
-        """"writes audio to path specified by output. Path should end with file extension, for example `folder/audio.mp3`"""
-        self._audio_toarray()
-        if lib!='auto': self._printlog(f'writing {output} with {lib}')
-        if lib=='pedalboard.io':
-            #print(audio)
-            import pedalboard.io
-            with pedalboard.io.AudioFile(output, 'w', self.samplerate, self.audio.shape[0]) as f:
-                f.write(self.audio)
-        elif lib=='soundfile':
-            audio=self.audio.T
-            import soundfile
-            soundfile.write(output, audio, self.samplerate)
-            del audio
-        elif lib=='auto':
-            for i in libs:
-                try: 
-                    self.write(output, i)
-                    break
-                except Exception as e:
-                    print(e)
-
-        # elif lib=='pydub':
-        #     from pydub import AudioSegment
-        #     song = AudioSegment(self.audio.tobytes(), frame_rate=self.samplerate, sample_width=2, channels=2)
-        #     format = output.split('.')[-1]
-        #     if len(format) > 4: 
-        #         format='mp3' 
-        #         output = output + '.' + format
-        #     song.export(output, format=format)
-
-    # def generate_beatmap(self, lib='madmom.BeatDetectionProcessor', split=None):
-    #     self.beatmap = beatmap(beatmap=None, samplerate=self.samplerate, length=len(self.audio[0]),caching=self.caching,log=self.log)
-    #     self.beatmap.generate(audio=self.audio, samplerate=self.samplerate, lib=lib, caching=self.caching, split=split, filename=self.filename)
-
-    # def generate_hitmap(self, lib='madmom.BeatDetectionProcessor'):
-    #     self.hitmap=hitmap(beatmap=None, samplerate=self.samplerate, length = len(self.audio), caching=self.caching, log=self.log)
-    #     self.hitmap.generate(audio=self.audio, samplerate=self.samplerate, lib=lib, caching=self.caching, filename=self.filename)
-
-    def generate_osu_beatmap(self, difficulties = [0.2, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01, 0.005]):
-        self.hitmap.osu(difficulties = difficulties)
-        import shutil, os
-        if self.path is not None: 
-            shutil.copyfile(self.path, 'BeatManipulator_TEMP/'+self.path.split('/')[-1])
-        else: self.write('BeatManipulator_TEMP/audio.mp3')
-        shutil.make_archive('BeatManipulator_TEMP', 'zip', 'BeatManipulator_TEMP')
-        outputname = _outputfilename('', self.path, '_'+self.hitmap.hitlib, 'osz')
-        if not os.path.exists(outputname):
-            os.rename('BeatManipulator_TEMP.zip', outputname)
-        else: print(f'{outputname} already exists!')
-        shutil.rmtree('BeatManipulator_TEMP')
-        self._printlog(f'Wrote {outputname}')
-
-    def autotrim(self):
-        self._printlog(f'autotrimming; ')
-        n=0
-        for i in self.audio[0]:
-            if i>=0.0001:break
-            n+=1
-        if type(self.audio) is tuple or list: self.audio = numpy.asarray(self.audio)
-        self.audio = numpy.asarray([self.audio[0,n:], self.audio[1,n:]])
-        self.beatmap._toarray()
-        if self.bm is not None: 
-            self.beatmap.beatmap=numpy.absolute(self.beatmap.beatmap-n)
-        if self.hm is not None: 
-            print(self.hm)
-            self.hitmap.beatmap=numpy.absolute(self.hitmap.beatmap-n)
-        self._update()
-
-    def beatswap(self, pattern: str, sep=',', smoothing=40, smoothing_mode='replace'):
-        import math, numpy
-        # get pattern size
-        size=0    
-        #cut processing??? not worth it, it is really fast anyways
-        if sep != ' ':
-            if sep not in pattern: pattern=pattern.replace(' ', sep) # separator not in patterm, e.g. forgot commas
-            while f'{sep}{sep}' in pattern: pattern = pattern.replace(f'{sep}{sep}', sep) # double separator
-            pattern=pattern.replace(' ', '').split(sep)
-        else: 
-            while '  ' in pattern: pattern = pattern.relace('  ', ' ')
-            pattern=pattern.split(sep)
-        self._printlog(f"beatswapping with {' '.join(pattern)}; ")
-        prev,prevb = None,None
-        for j in pattern:
-            s=''
-            if '?' not in j:
-                for i in j:
-                    #get the math expression
-                    #print(f'j = {j}, s = {s}, i = {i}, size = {size}, prev = {prev}, prevb = {prevb}')
-                    if i.isdecimal() or i=='.' or i=='-' or i=='/' or i=='+' or i=='%': s=str(s)+str(i)
-                    #if got :, write it to size
-                    elif i==':':
-                        if s=='': s='0'
-                        size=max(math.ceil(float(_safer_eval(s))), size)
-                        s=''
-                    #if got ;, save the number and then add it
-                    elif i=='>':
-                        if s=='': s='0'
-                        size=max(math.ceil(float(_safer_eval(s))), size)
-                        prev = _safer_eval(s)-1
-                        s=''
-                    elif i=='<':
-                        if s=='': s='0'
-                        size=max(math.ceil(float(_safer_eval(s))), size)
-                        prevb = _safer_eval(s)
-                        s=''
-                    # if prev is defined, add it to s (a>b to a+b)
-                    elif prev is not None:
-                        if s=='': s='0'
-                        #print(1, _safer_eval(s), prev, float(_safer_eval(s))+float(prev))
-                        size=max(math.ceil(float(_safer_eval(s))+float(prev)), size)
-                        prev=None
-                        break
-                    #prevb : a<b to a-b
-                    elif prevb is not None:
-                        if s=='': s='0'
-                        #print(2, _safer_eval(s), prevb, float(_safer_eval(s))+float(prevb))
-                        size=max(math.ceil(float(_safer_eval(s))-float(prevb)), size)
-                        prevb=None
-                        break
-                    # i isn't digit or any of the symbols, so stop parsing
-                    elif s!='': break
-                #print(f'end: j = {j}, s = {s}, i = {i}, size = {size}, prev = {prev}, prevb = {prevb}')
-                if s=='': s='0'
-            if s=='': s='0'
-            size=max(math.ceil(float(_safer_eval(s))), size)
-            if prev is not None: 
-                size=max(math.ceil(float(_safer_eval(s))+float(prev)), size)
-                prev=None
-            if prevb is not None: 
-                size=max(math.ceil(float(_safer_eval(s))-float(prevb)), size)
-                prev=None
-
-        self._audio_tolist()
-        self.beatmap._toarray()
-        # turns audio into a tuple with L and R channels
-        self.audio=(self.audio[0], self.audio[1])
-
-        # adds the part before the first beat
-        result=(self.audio[0][:self.beatmap[0]],self.audio[1][:self.beatmap[0]])
-        beat=numpy.asarray([[],[]])
-
-        # size, iterations are integers
-        size=int(max(size//1, 1))
-    
-        self.beatmap._add_beat_to_end()
-
-        iterations=int(len(self.beatmap)//size)
         
-        if 'random' in pattern[0].lower():
-            import random
-            for i in range(len(self.beatmap)):
+        # loop over pattern until it reaches the last beat
+        while n*pattern_length <= len(self.beatmap):
+            n+=1
 
-                choice=random.randint(1,len(self.beatmap)-1)
-                for a in range(len(self.audio)): 
-                    try:
-                        beat=self.audio[a][self.beatmap[choice-1]:self.beatmap[choice]-smoothing]
-                        if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
-                        result[a].extend(beat)
-                    except IndexError: pass
-            self.audio = result
-            return
-        
-        if 'reverse' in pattern[0].lower():
-            for a in range(len(self.audio)): 
-                for i in list(reversed(range(len(self.beatmap))))[:-1]:
+            # Every time pattern loops, shuffles beats with #
+            if len(shuffle_beats) > 0:
+                pattern = parse._shuffle(pattern, shuffle_beats, shuffle_groups)
+
+            # Loops over all beats in pattern
+            for num, b in enumerate(pattern):
+                if len(b) == 4: beat = b[3] # Sample has length 4
+                else: beat = b[0] # Else take the beat
+
+                if beat is not None:
+                    beat_as_string = ''.join(beat) if isinstance(beat, list) else beat
+                    # Skips `!` beats
+                    if c_misc[9] in beat_as_string: continue
+
+                # Audio is a sample or a song
+                if len(b) == 4: 
+                    audio = b[0]
+
+                    # Audio is a song
+                    if b[2] == c_misc[10]:
+                        try:
+
+                            # Song slice is a single beat, takes it
+                            if isinstance(beat, str):
+                                # random beat if `@` in beat (`_` is separator)
+                                if c_misc[4] in beat: beat = parse._random(beat, rchar = c_misc[4], schar = c_misc[5], length = pattern_length)
+                                beat = utils._safer_eval(beat) + pattern_length*n
+                                while beat > len(audio.beatmap)-1: beat = 1 + beat - len(audio.beatmap)
+                                beat = audio[beat]
+
+                            # Song slice is a range of beats, takes the beats
+                            elif isinstance(beat, list):
+                                beat = beat.copy()
+                                for i in range(len(beat)-1): # no separator
+                                    if c_misc[4] in beat[i]: beat[i] = parse._random(beat[i], rchar = c_misc[4], schar = c_misc[5], length = pattern_length)
+                                    beat[i] = utils._safer_eval(beat[i])
+                                    while beat[i] + pattern_length*n > len(audio.beatmap)-1: beat[i] = 1 + beat[i] - len(audio.beatmap)
+                                if beat[2] == c_slice[0]: beat = audio[beat[0] + pattern_length*n : beat[1] + pattern_length*n]
+                                elif beat[2] == c_slice[1]: beat = audio[beat[0] - 1 + pattern_length*n: beat[0] - 1 + beat[1] + pattern_length*n]
+                                elif beat[2] == c_slice[2]: beat = audio[beat[0] - beat[1] + pattern_length*n : beat[0] + pattern_length*n]
+
+                            # No Song slice, take whole song
+                            elif beat is None: beat = audio.audio
+
+                        except IndexError as e:
+                            print(e) 
+                            tries += 1
+                            if tries > 30: break
+                            continue
+                    
+                    # Audio is an audio file
+                    else:
+                        # No audio slice, takes whole audio
+                        if beat is None: beat = audio
+
+                        # Audio slice, takes part of the audio
+                        elif isinstance(beat, list):
+                            audio_length = len(audio[0])
+                            beat = [min(int(utils._safer_eval(beat[0])*audio_length), audio_length-1), min(int(utils._safer_eval(beat[1])*audio_length), audio_length-1)]
+                            if beat[0] > beat[1]: 
+                                beat[0], beat[1] = beat[1], beat[0]
+                                step = -1
+                            else: step = None
+                            beat = audio[:, beat[0] : beat[1] : step]
+                
+                # Audio is a beat
+                else:
                     try:
-                        beat=self.audio[a][self.beatmap[i-1]:self.beatmap[i]-smoothing]
-                        #print(self.beatmap[i-1],self.beatmap[i])
-                        #print(result[a][-1], beat[0])
-                        if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
-                        result[a].extend(beat)
-                    except IndexError: pass
-
-            self.audio = result
-            return
+                        beat_str = beat if isinstance(beat, str) else ''.join(beat)
+                        # Takes a single beat
+                        if isinstance(beat, str):
+                            if c_misc[4] in beat: beat = parse._random(beat, rchar = c_misc[4], schar = c_misc[5], length = pattern_length)
+                            beat = self[utils._safer_eval(beat) + pattern_length*n]
+
+                        # Takes a range of beats
+                        elif isinstance(beat, list):
+                            beat = beat.copy()
+                            for i in range(len(beat)-1): # no separator
+                                if c_misc[4] in beat[i]: beat[i] = parse._random(beat[i], rchar = c_misc[4], schar = c_misc[5], length = pattern_length)
+                                beat[i] = utils._safer_eval(beat[i])
+                            if beat[2] == c_slice[0]: beat = self[beat[0] + pattern_length*n : beat[1] + pattern_length*n]
+                            elif beat[2] == c_slice[1]: beat = self[beat[0] - 1 + pattern_length*n: beat[0] - 1 + beat[1] + pattern_length*n]
+                            elif beat[2] == c_slice[2]: beat = self[beat[0] - beat[1] + pattern_length*n : beat[0] + pattern_length*n]
+
+                        # create a variable if `%` in beat
+                        if c_misc[7] in beat_str: metric = parse._metric_get(beat_str, beat, metrics, c_misc[7])
+
+                    except IndexError: 
+                        tries += 1
+                        if tries > 30: break
+                        continue
+
+                if len(beat[0])<1: continue #Ignores empty beats
+                
+                # Applies effects
+                effect = b[1]
+                for e in effect:
+                    if e[0] in effects:
+                        v = e[1]
+                        e = effects[e[0]]
+                        # parse effect value
+                        if isinstance(v, str):
+                            if metric is not None: v = parse._metric_replace(v, metric, c_misc[7])
+                            v = utils._safer_eval(v)
+
+                        # effects
+                        if e == 'volume':
+                            if v is None: v = 0
+                            beat = beat * v
+                        elif e == 'downsample':
+                            if v is None: v = 8
+                            beat = np.repeat(beat[:,::v], v, axis=1)
+                        elif e == 'gradient':
+                            beat = np.gradient(beat, axis=1)
+                        elif e == 'reverse':
+                            beat = beat[:,::-1]
+                        else:
+                            beat = e(beat, v)
+
+                beat = np.clip(beat, -1, 1)
+                
+                # Adds the processed beat to list of beats.
+                # Separator is `,`
+                if operators[num] == c_join[0]:
+                    result.append(beat)
+                
+                # Makes sure beat doesn't get added on top of previous beat multiple times when pattern is out of range of song beats, to avoid distorted end.
+                elif tries<2:
+
+                    # Separator is `;` - always use first beat length, normalizes volume to 1.5
+                    if operators[num] == c_join[1]:
+                        length = len(beat[0])
+                        prev_length = len(result[-1][0])
+                        if length > prev_length: 
+                            result[-1] += beat[:,:prev_length]
+                        else:
+                            result[-1][:,:length] += beat
+                        limit = np.max(result[-1])
+                        if limit > 1.5:
+                            result[-1] /= limit*0.75
                     
-        #print(len(result[0]))
-        def beatswap_getnum(i: str, c: str):
-            if c in i:
-                try: 
-                    x=i.index(c)+1
-                    z=''
+                    # Separator is `~` - cuts to shortest
+                    elif operators[num] == c_join[2]:
+                        minimum = min(len(beat[0]), len(result[-1][0]))
+                        result[-1] = beat[:,:minimum-1] + result[-1][:,:minimum-1]
+
+                    # Separator is `&` - extends to longest
+                    elif operators[num] == c_join[3]:
+                        length = len(beat[0])
+                        prev_length = len(result[-1][0])
+                        if length > prev_length: 
+                            beat[:,:prev_length] += result[-1]
+                            result[-1] = beat
+                        else:
+                            result[-1][:,:length] += beat
+
+                    # Separator is `^` - uses first beat length and multiplies beats, used for sidechain
+                    elif operators[num] == c_join[4]:
+                        length = len(beat[0])
+                        prev_length = len(result[-1][0])
+                        if length > prev_length: 
+                            result[-1] *= beat[:,:prev_length]
+                        else:
+                            result[-1][:,:length] *= beat
+
+
+                    # Separator is `$` - always use first beat length, additionally sidechains first beat by second
+                    elif operators[num] == c_join[5]:
+                        from . import effects
+                        length = len(beat[0])
+                        prev_length = len(result[-1][0])
+                        if length > prev_length: 
+                            result[-1] *= effects.to_sidechain(beat[:,:prev_length])
+                            result[-1] += beat[:,:prev_length]
+                        else:
+                            result[-1][:,:length] *= effects.to_sidechain(beat)
+                            result[-1][:,:length] += beat
+
+                    # Separator is `}` - always use first beat length
+                    elif operators[num] == c_join[6]:
+                        length = len(beat[0])
+                        prev_length = len(result[-1][0])
+                        if length > prev_length: 
+                            result[-1] += beat[:,:prev_length]
+                        else:
+                            result[-1][:,:length] += beat
+
+
+        # smoothing
+        for i in range(len(result)-1):
+            current1 = result[i][0][-2]
+            current2 = result[i][0][-1]
+            following1 = result[i+1][0][0]
+            following2 = result[i+1][0][1]
+            num = (abs(following1 - (current2 + (current2 - current1))) + abs(current2 - (following1 + (following1 - following2))))/2
+            if num > 0.0: 
+                num = int(smoothing*num)
+                if num>3:
                     try:
-                        while i[x].isdecimal() or i[x]=='.' or i[x]=='-' or i[x]=='/' or i[x]=='+' or i[x]=='%': 
-                            z+=i[x]
-                            x+=1
-                        return z
-                    except IndexError:
-                        return z
-                except ValueError: return None
-
-        #print(len(self.beatmap), size, iterations)
-        # processing
-        for j in range(iterations+1):
-            for i in pattern:
-                if '!' not in i:
-                    n,s,st,reverse,z, is_c, is_cr=0,'',None,False,None,False,False
-                    for c in i:
-                        n+=1
-                        #print('c =', s, ',  st =', st, ',   s =', s, ',   n =,',n)
-
-                        # Get the character
-                        if c.isdecimal() or c=='.' or c=='-' or c=='/' or c=='+' or c=='%': 
-                            s=str(s)+str(c)
-                        
-                        # If character is : - get start
-                        elif s!='' and (c==':' or c=='>' or c=='<'):
-                            #print ('Beat start:',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size, ',   mod=',_safer_eval(s)%1)
-                            try: 
-                                sti = _safer_eval(s)
-                                if c=='>': sti-=1
-                                st=self.beatmap[int(sti//1)+j*size ] + sti%1* (self.beatmap[int(sti//1)+j*size +1] - self.beatmap[int(sti//1)+j*size])
-                                if c == '>': is_c = True
-                                elif c=='<': is_cr = True
-                                else: 
-                                    is_c = False                     
-                                    is_cr = False                     
-                            except IndexError: break
-                            s=''
-                        
-                        # create a beat
-                        if s!='' and (n==len(i) or not(c.isdecimal() or c=='.' or c=='-' or c=='/' or c=='+' or c=='%')):
-
-                            # start already exists, e.g. : or >
-                            if st is not None:
-                                #print ('Beat end:  ',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size, ',   mod=',_safer_eval(s)%1)
-                                try:
-                                    #print(1, is_c, s, st)
-                                    if is_c is False and is_cr is False:
-                                        si = _safer_eval(s)
-                                        s=self.beatmap[int(si//1)+j*size ] + si%1* (self.beatmap[int(si//1)+j*size +1] - self.beatmap[int(si//1)+j*size])
-                                    elif is_c is True:
-                                        si=sti+_safer_eval(s)
-                                        s=(self.beatmap[int(si//1)+j*size ] + si%1* (self.beatmap[int(si//1)+j*size +1] - self.beatmap[int(si//1)+j*size]))
-                                        is_c = False
-                                    elif is_cr is True:
-                                        si=sti-_safer_eval(s)
-                                        s=(self.beatmap[int(si//1)+j*size ] + si%1* (self.beatmap[int(si//1)+j*size +1] - self.beatmap[int(si//1)+j*size]))
-                                        #print(si, sti, st, s)
-                                        st, s = s, st
-                                        is_cr = False
-                                    #print(2, is_c, s, st)
-                                except IndexError: break
-                            else:
-                                # start doesn't exist
-                                #print ('Beat start:',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'- 1 =',int(_safer_eval(s)//1)+j*size,   ',   mod=',_safer_eval(s)%1)
-                                #print ('Beat end:  ',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size+1, ',   mod=',_safer_eval(s)%1)
-                                try:
-                                    si = _safer_eval(s)
-                                    st=self.beatmap[int(si//1)+j*size-1 ] + si%1* (self.beatmap[int(si//1)+j*size +1] - self.beatmap[int(si//1)+j*size])
-                                    s=self.beatmap[int(si//1)+j*size ] + si%1* (self.beatmap[int(si//1)+j*size +1] - self.beatmap[int(si//1)+j*size])
-                                except IndexError: break
-                            
-                            if st>s: 
-                                s, st=st, s
-                                reverse=True
-                            if st<0: st=0
-                            if s<0 or st==s: continue
-
-                            # create the beat
-                            if len(self.audio)>1: 
-                                if smoothing_mode=='add': beat=numpy.asarray([self.audio[0][int(st):int(s)],self.audio[1][int(st):int(s)]])
-                                else: beat=numpy.asarray([self.audio[0][int(st):int(s)-smoothing],self.audio[1][int(st):int(s)-smoothing]])
-                            else:
-                                if smoothing_mode=='add': beat=numpy.asarray([self.audio[0][int(st):int(s)]])
-                                else: beat=numpy.asarray([self.audio[0][int(st):int(s)-smoothing]])
-
-                            # process the beat
-                            # channels
-                            z=beatswap_getnum(i,'c')
-                            if z is not None:
-                                if z=='': beat[0],beat[1]=beat[1],beat[0]
-                                elif _safer_eval(z)==0:beat[0]*=0
-                                else:beat[1]*=0
-
-                            # volume
-                            z=beatswap_getnum(i,'v')
-                            if z is not None:
-                                if z=='': z='0'
-                                beat*=_safer_eval(z)
-
-                            z=beatswap_getnum(i,'t')
-                            if z is not None:
-                                if z=='': z='2'
-                                beat**=1/_safer_eval(z)
-
-                            # speed
-                            z=beatswap_getnum(i,'s')
-                            if z is not None:
-                                if z=='': z='2'
-                                z=_safer_eval(z)
-                                if z<1: 
-                                    beat=numpy.asarray((numpy.repeat(beat[0],int(1//z)),numpy.repeat(beat[1],int(1//z))))
-                                else:
-                                    beat=numpy.asarray((beat[0,::int(z)],beat[1,::int(z)]))
-                            
-                            # bitcrush
-                            z=beatswap_getnum(i,'b')
-                            if z is not None:
-                                if z=='': z='3'
-                                z=1/_safer_eval(z)
-                                if z<1: beat=beat*z
-                                beat=numpy.around(beat, max(int(z), 1))
-                                if z<1: beat=beat/z
-
-                            # downsample
-                            z=beatswap_getnum(i,'d')
-                            if z is not None:
-                                if z=='': z='3'
-                                z=int(_safer_eval(z))
-                                beat=numpy.asarray((numpy.repeat(beat[0,::z],z),numpy.repeat(beat[1,::z],z)))
-
-                            # convert to list
-                            beat=beat.tolist()
-
-                            # effects with list
-                            # reverse
-                            if ('r' in i and reverse is False) or (reverse is True and 'r' not in i):
-                                beat=(beat[0][::-1],beat[1][::-1] )
-
-                            # add beat to the result
-                            for a in range(len(self.audio)): 
-                                #print('Adding beat... a, s, st:', a, s, st, sep=',  ')
-                                #print(result[a][-1])
-                                #print(beat[a][0])
-                                try:
-                                    if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[a][0],smoothing))
-                                    result[a].extend(beat[a])
-                                except IndexError: pass
-                                #print(len(result[0]))
-
-                            #   
-                            break
-
-        self.audio = result
-        self._update()
-
-    def beatsample(self, audio2, shift=0):
-        self._printlog(f'beatsample; ')
-        try: l=len(audio2[0])
-        except (TypeError, IndexError): 
-            l=len(audio2)
-            audio2=numpy.vstack((audio2,audio2))
-        for i in range(len(self.beatmap)):
-            #print(self.beatmap[i])
-            try: self.audio[:,int(self.beatmap[i]) + int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i]))) : int(self.beatmap[i])+int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i])))+int(l)]+=audio2
-            except (IndexError, ValueError): pass
-        self._update()
-
-    def hitsample(self, audio2=None):
-        self._printlog(f'hitsample; ')
-        from . import generate
-        if audio2 is None:audio2=generate.saw(0.05, 1000, self.samplerate)
-        try: l=len(audio2[0])
-        except (TypeError, IndexError): 
-            l=len(audio2)
-            audio2=numpy.vstack((audio2,audio2))
-        #print(self.audio)
-        self.audio=numpy.array(self.audio).copy()
-        #print(self.audio)
-        for i in range(len(self.hitmap)):
-            try: 
-                #print('before', self.audio[:,int(self.hitmap[i])])
-                self.audio[:,int(self.hitmap[i]) : int(self.hitmap[i]+l)]+=audio2
-                #print('after ', self.audio[:,int(self.hitmap[i])])
-                #print(self.hitmap[i])
-            except (IndexError, ValueError): pass
-        self._update()
-
-    def sidechain(self, audio2, shift=0, smoothing=40):
-        self._printlog(f'sidechain; ')
-        try: l=len(audio2[0])
-        except (TypeError, IndexError): 
-            l=len(audio2)
-            audio2=numpy.vstack((audio2,audio2))
-        for i in range(len(self.beatmap)):
-            try: self.audio[:,int(self.beatmap[i])-smoothing + int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i]))) : int(self.beatmap[i])-smoothing+int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i])))+int(l)]*=audio2
-            except (IndexError, ValueError): break
-        self._update()
-
-    def quick_beatswap(self, output:str='', pattern:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, suffix:str=' (beatswap)', lib:str='madmom.BeatDetectionProcessor', log = True):
-        """Generates beatmap if it isn't generated, applies beatswapping to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
-        
-        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
-        
-        pattern: the beatswapping pattern.
-        
-        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
-        
-        shift: shifts the beatmap by this amount of unscaled beats
-        
-        start: position in seconds, beats before the position will not be manipulated
-        
-        end: position in seconds, same. Set to None by default.
-        
-        autotrim: trims silence in the beginning for better beat detection, True by default
-        
-        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
-        
-        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
-        
-        suffix: suffix that will be appended to the filename
-        
-        lib: beat detection library"""
-        if log is False and self.log is True: 
-            self.log = False
-            self.beatmap.log=False
-            log_disabled = True
-        else: log_disabled = False
-        self._printlog('___')
-        scale = _safer_eval(scale)
-        shift = _safer_eval(shift)
-        if self.bm is None: self.beatmap.generate(lib=lib)
-        if autotrim is True: self.autotrim()
-        save=self.beatmap.beatmap.copy()
-        if autoscale is True: self.beatmap.autoscale()
-        if shift!=0: self.beatmap.shift(shift)
-        if scale!=1: self.beatmap.scale(scale)
-        if autoinsert is True: self.beatmap.autoinsert()
-        if start!=0 or end is not None: self.beatmap.cut(start, end)
-        self._printlog(f'pattern = {pattern}')
-        if 'test' in pattern.lower():
-            self.audio*=0.7
-            self.beatmap.beatmap=save.copy()
-            if autoinsert is True: self.beatmap.autoinsert()
-            if start!=0 or end is not None: self.beatmap.cut(start, end)
-            audio2, samplerate2=open_audio('samples/cowbell.flac')
-            song.quick_beatsample(self, output=None, audio2=list(i[::3] for i in audio2), scale=8*scale, shift=0+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=list(i[::2] for i in audio2), scale=8*scale, shift=1*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=audio2, scale=8*scale, shift=2*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,2,axis=1), scale=8*scale, shift=3*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,3,axis=1), scale=8*scale, shift=4*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,2,axis=1), scale=8*scale, shift=5*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=audio2, scale=8*scale, shift=6*scale+shift, log=log)
-            song.quick_beatsample(self, output=None, audio2=list(i[::2] for i in audio2), scale=8*scale, shift=7*scale+shift, log=log)
-
-        else: self.beatswap(pattern)
-
-        if output is not None:
-            if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
-            output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
-            self.write(output)
-
-        self.beatmap.beatmap=save.copy()
-        if log_disabled is True: 
-            self.log = True
-            self.beatmap.log=True
-
-
-    def quick_sidechain(self, output:str='', audio2:numpy.array=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, filename2:str=None, suffix:str=' (sidechain)', lib:str='madmom.BeatDetectionProcessor', log=True):
-        """Generates beatmap if it isn't generated, applies fake sidechain on each beat to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
-        
-        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
-        
-        audio2: sidechain impulse, basically a curve that the volume will be multiplied by. By default one will be generated with generate_sidechain()
-        
-        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
-        
-        shift: shifts the beatmap by this amount of unscaled beats
-        
-        start: position in seconds, beats before the position will not be manipulated
-        
-        end: position in seconds, same. Set to None by default.
-        
-        autotrim: trims silence in the beginning for better beat detection, True by default
-        
-        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
-        
-        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
-        
-        filename2: loads sidechain impulse from the file if audio2 if not specified
-
-        suffix: suffix that will be appended to the filename
-        
-        lib: beat detection library"""
-        if log is False and self.log is True: 
-            self.log = False
-            log_disabled = True
-        else: log_disabled = False
-        self._printlog('___')
-        scale = _safer_eval(scale)
-        shift = _safer_eval(shift)
-        if filename2 is None and audio2 is None:
-            from . import generate
-            audio2=generate.sidechain()
-
-        if audio2 is None:
-            audio2, samplerate2=open_audio(filename2)
-
-        if self.bm is None: self.beatmap.generate(lib=lib)
-        if autotrim is True: self.autotrim()
-        save=self.beatmap.beatmap.copy()
-        if autoscale is True: self.beatmap.autoscale()
-        if shift!=0: self.beatmap.shift(shift)
-        if scale!=1: self.beatmap.scale(scale)
-        if autoinsert is True: self.beatmap.autoinsert()
-        if start!=0 or end is not None: self.beatmap.cut(start, end)
-        self.sidechain(audio2)
-
-        if output is not None:
-            if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
-            output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
-            self.write(output)
-        
-        self.beatmap.beatmap=save.copy()
-        if log_disabled is True: self.log = True
-
-    def quick_beatsample(self, output:str='', filename2:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, audio2:numpy.array=None, suffix:str=' (BeatSample)', lib:str='madmom.BeatDetectionProcessor', log=True):
-        """Generates beatmap if it isn't generated, adds chosen sample to each beat of the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
-        
-        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
-        
-        filename2: path to the sample.
-        
-        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
-        
-        shift: shifts the beatmap by this amount of unscaled beats
-        
-        start: position in seconds, beats before the position will not be manipulated
-        
-        end: position in seconds, same. Set to None by default.
-        
-        autotrim: trims silence in the beginning for better beat detection, True by default
-        
-        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
-        
-        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
-        
-        suffix: suffix that will be appended to the filename
-        
-        lib: beat detection library"""
-        if log is False and self.log is True: 
-            self.log = False
-            log_disabled = True
-        else: log_disabled = False
-        self._printlog('___')
-        scale = _safer_eval(scale)
-        shift = _safer_eval(shift)
-        if filename2 is None and audio2 is None:
-            from tkinter.filedialog import askopenfilename
-            filename2 = askopenfilename(title='select sidechain impulse', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
-
-        if audio2 is None:
-            audio2, samplerate2=open_audio(filename2)
-
-        if self.bm is None: self.beatmap.generate(lib=lib)
-        if autotrim is True: self.autotrim()
-        save=self.beatmap.beatmap.copy()
-        if autoscale is True: self.beatmap.autoscale()
-        if shift!=0: self.beatmap.shift(shift)
-        if scale!=1: self.beatmap.scale(scale)
-        if autoinsert is True: self.beatmap.autoinsert()
-        if start!=0 or end is not None: self.beatmap.cut(start, end)
-        self.beatsample(audio2)
-
-        if output is not None:
-            if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
-            output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
-            self.write(output)
-        self.beatmap.beatmap=save.copy()
-        if log_disabled is True: self.log = True
-
-    def spectogram_to_audio(self):
-        self.audio = self.spectogram.toaudio()
-
-    def beat_image_to_audio(self):
-        self.audio = self.beat_image.toaudio()
-
-
-def fix_beatmap(filename, lib='madmom.BeatDetectionProcessor', scale=1, shift=0):
-    if scale==1 and shift==0:
-        print('scale = 1, shift = 0: no changes have been made.')
-        return
-    track=song(filename)
-    audio_id=hex(len(track.audio[0]))
-    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
-    import os
-    if not os.path.exists(cacheDir):
-        print(f"beatmap isn't generated: {filename}")
-        return
-    track.beatmap.generate(lib=lib)
-    track.beatmap.shift(shift)
-    track.beatmap.scale(scale)
-    if not os.path.exists('SavedBeatmaps'):
-        os.mkdir('SavedBeatmaps')
-    a=input(f'Are you sure you want to overwrite {cacheDir} using scale = {scale}; shift = {shift}? ("y" to continue): ')
-    if 'n' in a.lower() or not 'y' in a.lower():
-        print('Operation canceled.') 
-        return
-    else: 
-        track.beatmap._toarray()
-        numpy.savetxt(cacheDir, track.bm.astype(int), fmt='%d')
-        print('Beatmap overwritten.')
-
-def delete_beatmap(filename, lib='madmom.BeatDetectionProcessor'):
-    track=song(filename)
-    audio_id=hex(len(track.audio[0]))
-    import os
-    if not os.path.exists('SavedBeatmaps'):
-        os.mkdir('SavedBeatmaps')
-    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
-    if not os.path.exists(cacheDir):
-        print(f"beatmap doesn't exist: {filename}")
-        return
-    a=input(f'Are you sure you want to delete {cacheDir}? ("y" to continue): ')
-    if 'n' in a.lower() or not 'y' in a.lower():
-        print('Operation canceled.') 
-        return
-    else: 
-        os.remove(cacheDir)
-        print('Beatmap deleted.')
-
-
-def _tosong(audio=None, bmap=None, samplerate=None, log=True):
-    from .wrapper import _song_copy
-    if isinstance(audio, str) or audio is None: audio = song(audio, bmap=bmap, log = log)
-    elif isinstance(audio, list) or isinstance(audio, numpy.ndarray) or isinstance(audio, tuple):
-        assert samplerate is not None, "If audio is an array, samplerate must be provided"
-        if len(audio)>16 and isinstance(audio[0], list) or isinstance(audio[0], numpy.ndarray) or isinstance(audio[0], tuple):
-            audio = numpy.asarray(audio).T
-        audio = song(audio=audio, samplerate=samplerate, bmap=bmap, log = log)
-    elif isinstance(audio, song): 
-        audio = _song_copy(audio)
-        audio.log, audio.beatmap.log, audio.beat_image.log = log, log, log
-    else: assert False, f"Audio should be either a path to a file, a list/array/tuple, a beat_manipulator.song object, or None for a pick file dialogue, but it is {type(audio)}"
-    return audio
-
-def beatswap(pattern: str, audio = None, scale: float = 1, shift: float = 0, output='', samplerate = None, bmap = None, log = True, suffix=' (beatswap)'):
-    audio = _tosong(audio=audio, bmap=bmap, samplerate=samplerate, log=log)
-    output = _outputfilename(output=output, filename=audio.path, suffix=suffix)
-    audio.quick_beatswap(pattern = pattern, scale=scale, shift=shift, output=output)
-    return audio.path
-
-def generate_beat_image(audio = None, scale: float = 1, shift: float = 0, output='', samplerate = None, bmap = None, log = True, ext='png', maximum=4096):
-    audio = _tosong(audio=audio, bmap=bmap, samplerate=samplerate, log=log)
-    output = _outputfilename(output=output, filename=audio.path, ext=ext, suffix = '')
-    audio.beatmap.generate()
-    audio.beatmap.scale(scale)
-    audio.beatmap.shift(shift)
-    audio.beat_image.generate()
-    audio.beat_image.write(output=output, maximum = maximum)
-    return output
-
-def generate_osu_map(audio = None, samplerate = None, log = True, difficulties = [0.2, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01, 0.005]):
-    audio = _tosong(audio=audio, samplerate=samplerate, log=log)
-    audio.hitmap.generate()
-    audio.generate_osu_beatmap(difficulties=difficulties)
-    return audio.path
+                        line = scipy.interpolate.CubicSpline([0, num+1], [0, following1], bc_type='clamped')(np.arange(0, num, 1))
+                        #print(line)
+                        line2 = np.linspace(1, 0, num)**0.5
+                        result[i][0][-num:] *= line2
+                        result[i][1][-num:] *= line2
+                        result[i][0][-num:] += line
+                        result[i][1][-num:] += line
+                    except (IndexError, ValueError): pass
+
+        self.beatmap = beatmap_default.copy()
+        # Beats are conjoined into a song
+        import functools
+        import operator
+        # Makes a [l, r, l, r, ...] list of beats (left and right channels)
+        result = functools.reduce(operator.iconcat, result, [])
+
+        # Every first beat is conjoined into left channel, every second beat is conjoined into right channel
+        if return_audio is False: self.audio = np.array([functools.reduce(operator.iconcat, result[::2], []), functools.reduce(operator.iconcat, result[1:][::2], [])])
+        else: return np.array([functools.reduce(operator.iconcat, result[::2], []), functools.reduce(operator.iconcat, result[1:][::2], [])])
+
+    def normalize_beats(self):
+        if self.normalized is not None: 
+            if ',' in self.normalized: 
+                self.beatswap(pattern = self.normalized)
+            else:
+                from . import presets
+                self.beatswap(*presets.get(self.normalized))
+
+    def image_generate(self, scale=1, shift=0, mode = 'median'):
+        if self.beatmap is None: self.beatmap_generate()
+        beatmap_default = self.beatmap.copy()
+        self.beatmap_shift(shift)
+        self.beatmap_scale(scale)
+        from .image import generate as image_generate
+        self.image = image_generate(song = self, mode = mode, log = self.log)
+        self.beatmap = beatmap_default.copy()
+
+    def image_write(self, output='', mode = 'color', max_size = 4096, ext = 'png', rotate=True, suffix = ''):
+        from .image import write as image_write
+        output = io._outputfilename(output, self.path, ext=ext, suffix = suffix)
+        image_write(self.image, output = output, mode = mode, max_size = max_size , rotate = rotate)
+        return output
+
+
+
+def beatswap(audio = None, pattern = 'test', scale = 1, shift = 0, length = None, sr = None, output = '', log = True, suffix = ' (beatswap)', copy = True):
+    if not isinstance(audio, song): audio = song(audio = audio, sr = sr, log = log)
+    elif copy is True: 
+        beatmap = audio.beatmap
+        path = audio.path
+        audio = song(audio = audio.audio, sr = audio.sr)
+        audio.beatmap = beatmap
+        audio.path = path
+    audio.beatswap(pattern = pattern, scale = scale, shift = shift, length = length)
+    if output is not None: 
+        return audio.write(output = output, suffix = suffix)
+    else: return audio
+
+def image(audio, scale = 1, shift = 0, sr = None, output = '', log = True, suffix = '', max_size = 4096):
+    if not isinstance(audio, song): audio = song(audio = audio, sr = sr, log = log)
+    audio.image_generate(scale = scale, shift = shift)
+    if output is not None: 
+        return audio.image_write(output = output, max_size=max_size, suffix=suffix)
+    else: return audio.image

beat_manipulator/metrics.py

@@ -0,0 +1,40 @@
+import numpy as np
+from . import effects
+
+def volume(audio: np.ndarray) -> float:
+    return np.average(np.abs(audio))
+
+def volume_gradient(audio: np.ndarray, number:int = 1) -> float:
+    audio = effects.gradient(audio, number = number)
+    return np.average(np.abs(audio))
+
+def maximum_high(audio: np.ndarray, number:int = 1) -> float:
+    audio = effects.gradient(audio, number = number)
+    return np.max(np.abs(audio))
+
+def locate_1st_hit(audio: np.ndarray, number: int = 1):
+    audio = effects.gradient(audio, number = number)
+    return np.argmax(audio, axis=1) / len(audio[0])
+
+def is_hit(audio: np.ndarray, threshold: float = 0.5, number:int = 1) -> int:
+    return 1 if maximum_high(audio, number=number) > threshold else 0
+
+def hit_at_start(audio: np.ndarray, diff = 0.1) -> int:
+    return is_hit(audio) * (locate_1st_hit(audio) <= diff)
+
+def hit_in_middle(audio: np.ndarray, diff = 0.1) -> int:
+    return is_hit(audio) * ((0.5 - diff) <= locate_1st_hit(audio) <= (0.5 + diff))
+
+def hit_at_end(audio: np.ndarray, diff = 0.1) -> int:
+    return is_hit(audio) * (locate_1st_hit(audio) >= (1-diff))
+
+BM_METRICS = {
+    "v": volume,
+    "g": volume_gradient,
+    "m": maximum_high,
+    "l": locate_1st_hit,
+    "h": is_hit,
+    "s": hit_at_start,
+    "a": hit_in_middle,
+    "e": hit_at_end,
+}

beat_manipulator/mix.py

@@ -1,44 +0,0 @@
-import numpy
-from . import main as bm
-def mix_shuffle_approx_random(audio1, audio2, iterations, minlength=0, maxlength=None, bias=0):
-    import random
-    if isinstance(audio1, bm.song): 
-        minlength*=audio1.samplerate
-        if maxlength is not None: maxlength*=audio1.samplerate
-        audio1=audio1.audio
-    else:
-        minlength*=44100
-        if maxlength is not None: maxlength*=44100
-    if isinstance(audio2, bm.song): audio2=audio2.audio
-    if len(audio1)>16: audio1=numpy.asarray([audio1,audio1])
-    if len(audio2)>16: audio1=numpy.asarray([audio2,audio2])
-    shape2=len(audio2)
-    mono1=numpy.abs(numpy.gradient(audio1[0]))
-    mono2=numpy.abs(numpy.gradient(audio2[0]))
-    length1=len(mono1)
-    length2=len(mono2)
-    result=numpy.zeros(shape=(shape2, length2))
-    result_diff=numpy.zeros(shape=length2)
-    old_difference=numpy.sum(mono2)
-    random_result=result_diff.copy()
-    for i in range(iterations):
-        rstart=random.randint(0, length1)
-        if maxlength is not None:
-            rlength=random.randint(minlength, min(length1-rstart, maxlength))
-        else: rlength=random.randint(minlength, minlength+length1-rstart)
-        rplace=random.randint(0, length2-rlength)
-        random_result=numpy.array(result_diff, copy=True)
-        random_result[rplace:rplace + rlength] = mono1[rstart:rstart + rlength]
-        difference = numpy.sum(numpy.abs(mono2 - random_result))
-        if difference<old_difference-bias:
-            print(i, difference)
-            result[:, rplace:rplace + rlength] = audio1[:, rstart:rstart + rlength]
-            result_diff=random_result
-            old_difference = difference
-    return result
-# 10 5 4 1
-# 10 0 0 0
-# 0  5 4 1 10
-# 10 5 4 1
-# 10 5 4 1
-

beat_manipulator/osu.py

@@ -0,0 +1,244 @@
+from . import main
+import numpy as np
+
+# L L L L L L L L L 
+def generate(song, difficulties = [0.2, 0.1, 0.05, 0.025, 0.01, 0.0075, 0.005, 0.0025], lib='madmom.MultiModelSelectionProcessor', caching=True, log = True, output = '', add_peaks = True):
+    # for i in difficulties:
+    #     if i<0.005: print(f'Difficulties < 0.005 may result in broken beatmaps, found difficulty = {i}')
+    if lib.lower == 'stunlocked': add_peaks = False
+
+    if not isinstance(song, main.song): song = main.song(song)
+    if log is True: print(f'Using {lib}; ', end='')
+    
+    filename = song.path.replace('\\', '/').split('/')[-1]
+    if ' - ' in filename and len(filename.split(' - '))>1: 
+        artist = filename.split(' - ')[0]
+        title = ' - '.join(filename.split(' - ')[1:])
+    else:
+        artist = ''
+        title = filename
+    
+    if caching is True:
+        audio_id=hex(len(song.audio[0]))
+        import os
+        if not os.path.exists('beat_manipulator/beatmaps'):
+            os.mkdir('beat_manipulator/beatmaps')
+        cacheDir="beat_manipulator/beatmaps/" + filename + "_"+lib+"_"+audio_id+'.txt'
+        try: 
+            beatmap=np.loadtxt(cacheDir)
+            if log is True: print('loaded cached beatmap.')
+        except OSError: 
+            if log is True:print("beatmap hasn't been generated yet. Generating...")
+            beatmap = None
+
+    if beatmap is None:
+        if 'madmom' in lib.lower():
+            from collections.abc import MutableMapping, MutableSequence
+            import madmom
+            assert len(song.audio[0])>song.sr*2, f'Audio file is too short, len={len(song.audio[0])} samples, or {len(song.audio[0])/song.sr} seconds. Minimum length is 2 seconds, audio below that breaks madmom processors.'
+        if lib=='madmom.RNNBeatProcessor':
+            proc = madmom.features.beats.RNNBeatProcessor()
+            beatmap = proc(madmom.audio.signal.Signal(song.audio.T, song.sr))
+        elif lib=='madmom.MultiModelSelectionProcessor':
+            proc = madmom.features.beats.RNNBeatProcessor(post_processor=None)
+            predictions = proc(madmom.audio.signal.Signal(song.audio.T, song.sr))
+            mm_proc = madmom.features.beats.MultiModelSelectionProcessor(num_ref_predictions=None)
+            beatmap= mm_proc(predictions)*song.sr
+            beatmap/= np.max(beatmap)
+        elif lib=='stunlocked':
+            spikes = np.abs(np.gradient(np.clip(song.audio[0], -1, 1)))[:int(len(song.audio[0]) - (len(song.audio[0])%int(song.sr/100)))]
+            spikes = spikes.reshape(-1, (int(song.sr/100)))
+            spikes = np.asarray(list(np.max(i) for i in spikes))
+            if len(beatmap) > len(spikes): beatmap = beatmap[:len(spikes)]
+            elif len(spikes) > len(beatmap): spikes = spikes[:len(beatmap)]
+            zeroing = 0
+            for i in range(len(spikes)):
+                if zeroing > 0:
+                    if spikes[i] <= 0.1: zeroing -=1
+                    spikes[i] = 0
+                elif spikes[i] >= 0.1:
+                    spikes[i] = 1
+                    zeroing = 7
+                if spikes[i] <= 0.1: spikes[i] = 0
+            beatmap = spikes
+
+        if caching is True: np.savetxt(cacheDir, beatmap)
+        
+    if add_peaks is True:
+        spikes = np.abs(np.gradient(np.clip(song.audio[0], -1, 1)))[:int(len(song.audio[0]) - (len(song.audio[0])%int(song.sr/100)))]
+        spikes = spikes.reshape(-1, (int(song.sr/100)))
+        spikes = np.asarray(list(np.max(i) for i in spikes))
+        if len(beatmap) > len(spikes): beatmap = beatmap[:len(spikes)]
+        elif len(spikes) > len(beatmap): spikes = spikes[:len(beatmap)]
+        zeroing = 0
+        for i in range(len(spikes)):
+            if zeroing > 0:
+                if spikes[i] <= 0.1: zeroing -=1
+                spikes[i] = 0
+            elif spikes[i] >= 0.1:
+                spikes[i] = 1
+                zeroing = 7
+            if spikes[i] <= 0.1: spikes[i] = 0
+    else: spikes = None
+
+    def _process(song: main.song, beatmap, spikes, threshold):
+        '''ඞ'''
+        if add_peaks is True: beatmap += spikes
+        hitmap=[]
+        actual_samplerate=int(song.sr/100)
+        beat_middle=int(actual_samplerate/2)
+        for i in range(len(beatmap)):
+            if beatmap[i]>threshold: hitmap.append(i*actual_samplerate + beat_middle)
+        hitmap=np.asarray(hitmap)
+        clump=[]
+        for i in range(len(hitmap)-1):
+            #print(i, abs(song.beatmap[i]-song.beatmap[i+1]), clump)
+            if abs(hitmap[i] - hitmap[i+1]) < song.sr/16 and i != len(hitmap)-2: clump.append(i)
+            elif clump!=[]: 
+                clump.append(i)
+                actual_time=hitmap[clump[0]]
+                hitmap[np.array(clump)]=0
+                #print(song.beatmap)
+                hitmap[clump[0]]=actual_time
+                clump=[]
+        
+        hitmap=hitmap[hitmap!=0]
+        return hitmap
+    
+    osufile=lambda title,artist,version: ("osu file format v14\n"
+    "\n"
+    "[General]\n"
+    f"AudioFilename: {song.path.split('/')[-1]}\n"
+    "AudioLeadIn: 0\n"
+    "PreviewTime: -1\n"
+    "Countdown: 0\n"
+    "SampleSet: Normal\n"
+    "StackLeniency: 0.5\n"
+    "Mode: 0\n"
+    "LetterboxInBreaks: 0\n"
+    "WidescreenStoryboard: 0\n"
+    "\n"
+    "[Editor]\n"
+    "DistanceSpacing: 1.1\n"
+    "BeatDivisor: 4\n"
+    "GridSize: 8\n"
+    "TimelineZoom: 1.6\n"
+    "\n"
+    "[Metadata]\n"
+    f"Title:{title}\n"
+    f"TitleUnicode:{title}\n"
+    f"Artist:{artist}\n"
+    f"ArtistUnicode:{artist}\n"
+    f'Creator:{lib} + BeatManipulator\n'
+    f'Version:{version} {lib}\n'
+    'Source:\n'
+    'Tags:BeatManipulator\n'
+    'BeatmapID:0\n'
+    'BeatmapSetID:-1\n'
+    '\n'
+    '[Difficulty]\n'
+    'HPDrainRate:4\n'
+    'CircleSize:4\n'
+    'OverallDifficulty:5\n'
+    'ApproachRate:10\n'
+    'SliderMultiplier:3.3\n'
+    'SliderTickRate:1\n'
+    '\n'
+    '[Events]\n'
+    '//Background and Video events\n'
+    '//Break Periods\n'
+    '//Storyboard Layer 0 (Background)\n'
+    '//Storyboard Layer 1 (Fail)\n'
+    '//Storyboard Layer 2 (Pass)\n'
+    '//Storyboard Layer 3 (Foreground)\n'
+    '//Storyboard Layer 4 (Overlay)\n'
+    '//Storyboard Sound Samples\n'
+    '\n'
+    '[TimingPoints]\n'
+    '0,140.0,4,1,0,100,1,0\n'
+    '\n'
+    '\n'
+    '[HitObjects]\n')
+    # remove the clumps
+    #print(self.beatmap)
+
+    #print(self.beatmap)
+
+    
+    #print(len(osumap))
+    #input('banana')
+    import shutil, os
+    if os.path.exists('beat_manipulator/temp'): shutil.rmtree('beat_manipulator/temp')
+    os.mkdir('beat_manipulator/temp')
+    hitmap=[]
+    import random
+    for difficulty in difficulties:
+        for i in range(4):
+            #print(i)
+            this_difficulty=_process(song, beatmap, spikes, difficulty)
+        hitmap.append(this_difficulty)
+
+    for k in range(len(hitmap)):
+        osumap=np.vstack((hitmap[k],np.zeros(len(hitmap[k])),np.zeros(len(hitmap[k])))).T
+        difficulty= difficulties[k]
+        for i in range(len(osumap)-1):
+            if i==0:continue
+            dist=(osumap[i,0]-osumap[i-1,0])*(1-(difficulty**0.3))
+            if dist<1000: dist=0.005
+            elif dist<2000: dist=0.01
+            elif dist<3000: dist=0.015
+            elif dist<4000: dist=0.02
+            elif dist<5000: dist=0.25
+            elif dist<6000: dist=0.35
+            elif dist<7000: dist=0.45
+            elif dist<8000: dist=0.55
+            elif dist<9000: dist=0.65
+            elif dist<10000: dist=0.75
+            elif dist<12500: dist=0.85
+            elif dist<15000: dist=0.95
+            elif dist<20000: dist=1
+            #elif dist<30000: dist=0.8
+            prev_x=osumap[i-1,1]
+            prev_y=osumap[i-1,2]
+            if prev_x>0: prev_x=prev_x-dist*0.1
+            elif prev_x<0: prev_x=prev_x+dist*0.1
+            if prev_y>0: prev_y=prev_y-dist*0.1
+            elif prev_y<0: prev_y=prev_y+dist*0.1
+            dirx=random.uniform(-dist,dist)
+            diry=dist-abs(dirx)*random.choice([-1, 1])
+            if abs(prev_x+dirx)>1: dirx=-dirx
+            if abs(prev_y+diry)>1: diry=-diry
+            x=prev_x+dirx
+            y=prev_y+diry
+            #print(dirx,diry,x,y)
+            #print(x>1, x<1, y>1, y<1)
+            if x>1: x=0.8
+            if x<-1: x=-0.8
+            if y>1: y=0.8
+            if y<-1: y=-0.8
+            #print(dirx,diry,x,y)
+            osumap[i,1]=x
+            osumap[i,2]=y
+
+        osumap[:,1]*=300
+        osumap[:,1]+=300
+        osumap[:,2]*=180
+        osumap[:,2]+=220
+
+        file=osufile(artist, title, difficulty)
+        for j in osumap:
+            #print('285,70,'+str(int(int(i)*1000/self.samplerate))+',1,0')
+            file+=f'{int(j[1])},{int(j[2])},{str(int(int(j[0])*1000/song.sr))},1,0\n'
+        with open(f'beat_manipulator/temp/{artist} - {title} (BeatManipulator {difficulty} {lib}].osu', 'x', encoding="utf-8") as f:
+            f.write(file)
+    from . import io
+    import shutil, os
+    shutil.copyfile(song.path, 'beat_manipulator/temp/'+filename)
+    shutil.make_archive('beat_manipulator_osz', 'zip', 'beat_manipulator/temp')
+    outputname = io._outputfilename(path = output, filename = song.path, suffix = ' ('+lib + ')', ext = 'osz')
+    if not os.path.exists(outputname):
+        os.rename('beat_manipulator_osz.zip', outputname)
+        if log is True: print(f'Created `{outputname}`')
+    else: print(f'{outputname} already exists!')
+    shutil.rmtree('beat_manipulator/temp')
+    return outputname

beat_manipulator/parse.py

@@ -0,0 +1,251 @@
+from .utils import C_SLICE, C_JOIN, C_MISC, C_MATH
+import numpy as np
+from . import io, utils, main
+def _getnum(pattern, cur, symbols = '+-*/'):
+    number = ''
+    while pattern[cur].isdecimal() or pattern[cur] in symbols:
+        number+=pattern[cur]
+        cur+=1
+    return number, cur-1
+
+def parse(pattern:str, samples:dict, pattern_length:int = None,
+        c_slice:str = C_SLICE,
+        c_join:str = C_JOIN, 
+        c_misc:str = C_MISC,
+        log = True,
+        simple_mode = False):
+    """Returns (beats, operators, pattern_length, c_slice, c_misc, c_join)"""
+    if log is True: print(f'Beatswapping with `{pattern}`')
+    
+    #load samples:
+    if isinstance(samples, str): samples = (samples,)
+    if not isinstance(samples, dict):
+        samples = {str(i+1):samples[i] for i in range(len(samples))}
+
+    #preprocess pattern
+    separator = c_join[0]
+    #forgot separator
+    if simple_mode is True:
+        if c_join[0] not in pattern and c_join[1] not in pattern and c_join[2] not in pattern and c_join[3] not in pattern: pattern = pattern.replace(' ', separator)
+    if ' ' not in c_join: pattern = pattern.replace(' ', '') # ignore spaces
+    for i in c_join:
+        while i+i in pattern: pattern = pattern.replace(i+i, i) #double separator
+        while pattern.startswith(i): pattern = pattern[1:]
+        while pattern.endswith(i): pattern = pattern[:-1]
+
+    # Creates a list of beat strings so that I can later see if there is a `!` in the string
+    separated = pattern
+    for i in c_join:
+        separated = separated.replace(i, c_join[0])
+    separated = separated.split(c_join[0])
+    pattern = pattern.replace(c_misc[6], '')
+    
+    # parsing
+    length = 0
+    num = ''
+    cur = 0
+    beats = []
+    operators = [separator]
+    shuffle_beats = []
+    shuffle_groups = []
+    current_beat = 0
+    effect = None
+    pattern += ' '
+    sample_toadd = None
+
+    # Loops over all characters
+    while cur < len(pattern):
+        char = pattern[cur]
+        #print(f'char = {char}, cur = {cur}, num = {num}, current_beat = {current_beat}, effect = {effect}, len(beats) = {len(beats)}, length = {length}')
+        if char == c_misc[3]: char = str(current_beat+1)  # Replaces `i` with current number
+
+        # If character is `", ', `, or [`: searches for closing quote and gets the sample rate, 
+        # moves cursor to the character after last quote/bracket, creates a sample_toadd variable with the sample.
+        elif char in c_misc[0:3]+c_misc[10:12]:
+            quote = char
+            if quote == c_misc[10]: quote = c_misc[11] # `[` is replaced with `]`
+            cur += 1
+            sample = ''
+
+            # Gets sample name between quote characters, moves cursor to the ending quote.
+            while pattern[cur] != quote:
+                sample += pattern[cur]
+                cur += 1
+            assert sample in samples, f"No sample named `{sample}` found in samples. Available samples: {samples.keys()}"
+            
+            # If sample is a song, it will be converted to a song if needed, and beatmap will be generated
+            if quote == c_misc[11]: 
+                if not isinstance(samples[sample], main.song): samples[sample] = main.song(samples[sample])
+                if samples[sample].beatmap is None: 
+                    samples[sample].beatmap_generate()
+                    samples[sample].beatmap_adjust()
+
+            # Else sample is a sound file
+            elif not isinstance(samples[sample], np.ndarray): samples[sample] = io._load(samples[sample])[0] 
+
+            sample_toadd = [samples[sample], [], quote, None] # Creates the sample_toadd variable
+            cur += 1
+            char = pattern[cur]
+
+        # If character is a math character, a slice character, or `@_?!%` - random, not count, skip, create variable -
+        # - it gets added to `num`, and the loop repeats.
+        # _safer_eval only takes part of the expression to the left of special characters (@%#), so it won't affect length calculation
+        if char.isdecimal() or char in (C_MATH + c_slice + c_misc[4:8] + c_misc[9]):
+            num += char
+            #print(f'char = {char}, added it to num: num = {num}')
+
+            # If character is `%` and beat hasn't been created yet, it takes the next character as well
+            if char == c_misc[7] and len(beats) == current_beat:
+                cur += 1
+                char = pattern[cur]
+                num += char
+
+        # If character is a shuffle character `#` + math expression, beat number gets added to `shuffle_beats`, 
+        # beat shuffle group gets added to `shuffle_groups`, cursor is moved to the character after the math expression, and loop repeats.
+        # That means operations after this will only execute once character is not a math character.
+        elif char == c_misc[8]:
+            cur+=1
+            number, cur = _getnum(pattern, cur)
+            char = pattern[cur]
+            shuffle_beats.append(current_beat)
+            shuffle_groups.append(number)
+
+        # If character is not math/shuffle, that means math expression has ended. Now it tries to figure out where the expression belongs, 
+        # and parses the further characters
+        else:
+            
+            # If the beat has not been added, it adds the beat. Also figures out pattern length.
+            if len(beats) == current_beat and len(num) > 0:
+                # Checks all slice characters in the beat expression. If slice character is found, splits the slice and breaks.
+                for c in c_slice:
+                    if c in num:
+                        num = num.split(c)[:2] + [c]
+                        #print(f'slice: split num by `{c}`, num = {num}, whole beat is {separated[current_beat]}')
+                        if pattern_length is None and c_misc[6] not in separated[current_beat]:
+                            num0, num1 = utils._safer_eval(num[0]), utils._safer_eval(num[1])
+                            if c == c_slice[0]: length = max(num0, num1, length)
+                            if c == c_slice[1]: length = max(num0-1, num0+num1-1, length)
+                            if c == c_slice[2]: length = max(num0-num1, num0, length)
+                        break
+                # If it didn't break, the expression is not a slice, so it pattern length is just compared with the beat number.
+                else: 
+                    #print(f'single beat: {num}. Whole beat is {separated[current_beat]}')
+                    if c_misc[6] not in separated[current_beat]: length = max(utils._safer_eval(num), length)
+
+                # If there no sample saved in `sample_toadd`, adds the beat to list of beats.
+                if sample_toadd is None: beats.append([num, []])
+                # If `sample_toadd` is not None, beat is a sample/song. Adds the beat and sets sample_toadd to None
+                else: 
+                    sample_toadd[3] = num
+                    beats.append(sample_toadd)
+                    sample_toadd = None
+                #print(f'char = {char}, got num = {num}, appended beat {len(beats)}')
+
+            # Sample might not have a `num` with a slice, this adds the sample without a slice
+            elif len(beats) == current_beat and len(num) == 0 and sample_toadd is not None:
+                beats.append(sample_toadd)
+                sample_toadd = None
+
+            # If beat has been added, it now parses beats.
+            if len(beats) == current_beat+1:
+                #print(f'char = {char}, parsing effects:')
+
+                # If there is an effect and current character is not a math character, effect and value are added to current beat, and effect is set to None
+                if effect is not None:
+                    #print(f'char = {char}, adding effect: type = {effect}, value = {num}')
+                    beats[current_beat][1].append([effect, num if num!='' else None])
+                    effect = None
+
+                # If current character is a letter, it sets that letter to `effect` variable. 
+                # Since loop repeats after that, that while current character is a math character, it gets added to `num`.
+                if char.isalpha() and effect is None:
+                    #print(f'char = {char}, effect type is {effect}')
+                    effect = char
+
+            # If character is a beat separator, it starts parsing the next beat in the next loop. 
+            if char in c_join and len(beats) == current_beat + 1:
+                #print(f'char = {char}, parsing next beat')
+                current_beat += 1
+                effect = None
+                operators.append(char)
+
+            num = '' # `num` is set to empty string. btw `num` is only used in this loop so it needs to be here
+        
+        cur += 1 # cursor goes to the next character
+
+    
+    #for i in beats: print(i)
+    import math
+    if pattern_length is None: pattern_length = int(math.ceil(length))
+
+    return beats, operators, pattern_length, shuffle_groups, shuffle_beats, c_slice, c_misc, c_join
+
+# I can't be bothered to annotate this one. It just works, okay?
+def _random(beat:str, length:int, rchar = C_MISC[4], schar = C_MISC[5]) -> str:
+    """Takes a string and replaces stuff like `@1_4_0.5` with randomly generated number where 1 - start, 4 - stop, 0.5 - step. Returns string."""
+    import random
+    beat+=' '
+    while rchar in beat:
+        rand_index = beat.find(rchar)+1
+        char = beat[rand_index]
+        number = ''
+        while char.isdecimal() or char in '.+-*/':
+            number += char
+            rand_index+=1
+            char = beat[rand_index]
+        if number != '': start = utils._safer_eval(number)
+        else: start = 0
+        if char == schar:
+            rand_index+=1
+            char = beat[rand_index]
+            number = ''
+            while char.isdecimal() or char in '.+-*/':
+                number += char
+                rand_index+=1
+                char = beat[rand_index]
+            if number != '': stop = utils._safer_eval(number)
+            else: stop = length
+            if char == schar:
+                rand_index+=1
+                char = beat[rand_index]
+                number = ''
+                while char.isdecimal() or char in '.+-*/':
+                    number += char
+                    rand_index+=1
+                    char = beat[rand_index]
+                if number != '': step = utils._safer_eval(number)
+                else: step = length
+        choices = []
+        while start <= stop:
+            choices.append(start)
+            start+=step
+        beat = list(beat)
+        beat[beat.index(rchar):rand_index] = list(str(random.choice(choices)))
+        beat = ''.join(beat)
+    return beat
+
+def _shuffle(pattern: list, shuffle_beats: list, shuffle_groups: list) -> list:
+    """Shuffles pattern according to shuffle_beats and shuffle_groups"""
+    import random
+    done = []
+    result = pattern.copy()
+    for group in shuffle_groups:
+        if group not in done:
+            shuffled = [i for n, i in enumerate(shuffle_beats) if shuffle_groups[n] == group]
+            unshuffled = shuffled.copy()
+            random.shuffle(shuffled)
+            for i in range(len(shuffled)):
+                result[unshuffled[i]] = pattern[shuffled[i]]
+            done.append(group)
+    return result
+
+def _metric_get(v, beat, metrics, c_misc7 = C_MISC[7]):
+    assert v[v.find(c_misc7)+1] in metrics, f'`%{v[v.find(c_misc7)+1]}`: No metric called `{v[v.find(c_misc7)+1]}` found in metrics. Available metrics: {metrics.keys()}'
+    metric = metrics[v[v.find(c_misc7)+1]](beat)
+    return metric
+
+
+def _metric_replace(v, metric, c_misc7 = C_MISC[7]):
+    for _ in range(v.count(c_misc7)):
+        v= v[:v.find(c_misc7)] + str(metric) + v[v.find(c_misc7)+2:]
+    return v

beat_manipulator/presets.py

@@ -0,0 +1,84 @@
+from . import main, utils
+BM_SAMPLES = {'cowbell' : 'beat_manipulator/samples/cowbell.flac',
+              }
+
+presets = {}
+
+def presets_load(path, mode = 'add'):
+    global presets
+    import yaml
+    with open(path, 'r') as f:
+        yaml_presets = yaml.safe_load(f.read())
+    
+    if mode.lower() == 'add':
+        presets = presets | yaml_presets
+    elif mode.lower() == 'replace':
+        presets = yaml_presets
+
+presets_load('beat_manipulator/presets.yaml')
+
+def _beatswap(song, pattern, pattern_name, scale = 1, shift = 0, output = '', modify = False):
+    if isinstance(scale, str):
+        if ',' in scale: scale = scale.replace(' ', '').split(',')
+    elif not isinstance(scale, list): scale = [scale]
+    if modify is False:
+        for i in scale:
+            main.beatswap(song, pattern = pattern, scale = i, shift = shift, output=output, suffix = f' ({pattern_name}{(" x"+str(round(utils._safer_eval(i), 4))) * (len(scale)>1)})', copy = True)
+    else:
+        assert isinstance(song, main.song), f"In order to modify a song, it needs to be of a main.song type, but it is {type(song)}"
+        song.beatswap(pattern, scale = scale[0], shift = shift)
+        return song
+
+def get(preset):
+    """returns (pattern, scale, shift)"""
+    global presets
+    assert preset in presets, f"{preset} not found in presets."
+    preset = presets[preset]
+    return preset['pattern'], preset['scale'] if 'scale' in preset else 1, preset['shift'] if 'shift' in preset else 0
+
+def use(song, preset, output = '', scale = 1, shift = 0):
+    global presets
+    assert preset in presets, f"{preset} not found in presets."
+    preset_name = preset
+    preset = presets[preset]
+    if not isinstance(song, main.song): song = main.song(song)
+    if isinstance(list(preset.values())[0], dict):
+        for i in preset.values():
+            if 'sample' in i:
+                pass
+            elif 'sidechain' in i:
+                pass
+            else:
+                song = _beatswap(song, pattern = i['pattern'], scale = scale*(i['scale'] if 'scale' in i else 1), shift = shift*(i['shift'] if 'shift' in i else 0), output = output, modify = True, pattern_name = preset_name)
+        song.write(output, suffix = f' ({preset})')
+    else:
+        if 'sample' in preset:
+            pass
+        elif 'sidechain' in preset:
+            pass
+        else:
+            _beatswap(song, pattern = preset['pattern'], scale = scale*(preset['scale'] if 'scale' in preset else 1), shift = shift*(preset['shift'] if 'shift' in preset else 0), output = output, modify = False, pattern_name = preset_name)
+
+def use_all(song, output = ''):
+    if not isinstance(song, main.song): song = main.song(song)
+    for key in presets.keys():
+        print(f'__ {key} __')
+        use(song, key, output = output)
+        print()
+
+def test(song, scale = 1, shift = 0, adjust = 0, output = '', load_settings = False):
+    song = main.song(song)
+    song.beatmap_generate(load_settings = load_settings)
+    song.beatswap('test', scale = scale, shift = shift, adjust = 500+adjust)
+    song.write(output = output, suffix = ' (test)')
+
+def save(song, scale = 1, shift = 0, adjust = 0):
+    song = main.song(song)
+    song.beatmap_save_settings(scale = scale, shift = shift, adjust = adjust)
+
+def savetest(song, scale = 1, shift = 0, adjust = 0, output = '', load_settings = False):
+    song = main.song(song)
+    song.beatmap_generate(load_settings = load_settings)
+    song.beatswap('test', scale = scale, shift = shift, adjust = 500+adjust)
+    song.write(output = output, suffix = ' (test)')
+    song.beatmap_save_settings(scale = scale, shift = shift, adjust = adjust)

beat_manipulator/presets.yaml

@@ -0,0 +1,365 @@
+# Presets. `Scales` can be a list of all scales that the pattern works with.
+# ________________ BASIC ________________
+2x speed:
+  pattern: 1>0.5
+  scale: 1, 0.5, 1/3, 0.25
+
+3x speed:
+  pattern: 1>1/3
+  scale: 1, 0.5
+
+4x speed:
+  pattern: 1>0.25
+  scale: 1, 0.5
+
+6x speed:
+  pattern: 1>1/6
+  scale: 1, 0.5
+
+8x speed:
+  pattern: 1>0.125
+  scale: 1, 0.5
+
+1.33x faster:
+  pattern: 1>0.75
+  scale: 1, 2/3, 0.5, 1/3, 0.25
+
+1.5x faster:
+  pattern: 1>2/3
+  scale: 1, 2/3
+
+1.5x slower:
+  pattern: 1>0.5, 1<0.5r, 1<0.5
+  scale: 2, 1, 0.75, 0.5
+
+1.33x slower: 
+  pattern: 1>2/3, 1<1/3r, 1<1/3
+  scale: 2, 1
+
+reverse:
+  pattern: reverse
+  scale: 8, 4, 2, 1, 0.5, 1/3, 0.25, 0.2, 1/7, 0.125
+
+reverse 8 beats:
+  pattern: 8, 7, 6, 5, 4, 3, 2, 1
+  scale: 1, 0.5
+
+shuffle:
+  pattern: shuffle
+
+shuffle 3 beats:
+  pattern: 1#1, 2#1, 3#1
+  scale: 2, 1, 0.75, 0.5, 0.25, 0.2, 0.125
+
+shuffle 4 beats:
+  pattern: 1#1, 2#1, 3#1, 4#1
+  scale: 2, 1, 0.75, 0.5, 0.25, 0.125
+
+shuffle 8 beats:
+  pattern: 1#1, 2#1, 3#1, 4#1, 5#1, 6#1, 7#1, 8#1
+  scale: 2, 1, 0.75, 0.5, 0.25
+
+shuffle alternate:
+  pattern: 1#1, 2#2, 3#1, 4#2, 5#1, 6#2, 7#1, 8#2
+  scale: 1, 0.125
+
+shuffle mix:
+  pattern: i#1, i#2, i#3, i#4, i#1, i#2, i#3, i#4, i#1, i#2, i#3, i#4, i#1, i#2, i#3, i#4
+  scale: 1, 0.5
+
+3 bars mix:
+  pattern: i, i+4?, i+8?, 3!
+  scale: 1, 0.5, 1/3
+
+4 bars mix:
+  pattern: i, i+4?, i+8?, i+12?, 4!
+  scale: 1, 0.5
+
+6 bars mix:
+  pattern: i, i+4?, i+8?, i+12?, i+16?, i+20?, 6!
+  scale: 1, 0.5
+
+8 bars mix:
+  pattern: i, i+4?, i+8?, i+12?, i+16?, i+20?, i+24?, i+28?, 8!
+  scale: 1, 0.5
+
+2 in 1:
+  pattern: 1; 2
+  scale: 8, 6, 4, 3, 2, 1, 0.5, 0.25
+
+3 in 1:
+  pattern: 1; 2; 3
+  scale: 4, 3, 1
+
+4 in 1:
+  pattern: 1; 2; 3; 4
+  scale: 4, 1
+
+5 in 1:
+  pattern: 1;2;3;4;5
+  scale: 2, 1
+
+2 in 1 reverse:
+  pattern: 1;2r?
+  scale: 8, 3, 1, 0.75, 0.5, 0.25, 0.125
+
+reverse mix:
+  pattern: 1;1r
+  scale: 4, 1, 0.75, 0.5
+
+random:
+  pattern: random
+  scale: 2, 1, 0.5, 0.25, 0.125
+  description: generates a new random pattern each time
+
+kicks only:
+  pattern: 1>0.5
+  scale: 2
+  description: plays only kicks
+
+kicks only double-time:
+  pattern: 1>0.25
+  scale: 2
+  description: plays only kicks
+
+snares only:
+  pattern: 1<0.5
+  scale: 2
+  description: plays only snares
+
+no main drums:
+  pattern: 1<0.5
+  scale: 1, 0.5, 0.25, 0.125
+  description: skips kicks and snares
+
+# ________________ STRUCTURES ________________
+half-time:
+  pattern: 1,2,4,5, | 3,6,8,7, | 9,11,12,13, | 15,13,14,16
+  scale: 1, 0.5 #0.25
+  description: halves the BPM
+
+quarter-time 1:
+  pattern: 1,2,4,5,|6,8,9,10,|11,12,13,14,|16,14,15,16
+  scale: 0.5
+  description: 4 times lower BPM
+
+quarter-time 2:
+  pattern: 1,2,4,5, | 6,8,10,12, | 11,10,12,13, | 9,13,14,16
+  scale: 0.5 #0.25
+  description: 4 times lower BPM, with a syncopated structure
+
+dotted snares 1:
+  pattern: 1, 2>0.5, 3, 4>0.5, 5, 6>0.5, 3, 4>0.5, 7, 8
+  scale: 2, 1
+  description: Plays 5 snares in a 4/3 syncopation, a rhythm commonly used in drum&bass
+
+dotted snares 2:
+  pattern: 1, 2, 3 , 4, | 5, 7 , 6, 8, | 11 , 10, 9, 11 , | 13, 14, 15 , 16
+  scale: 0.5 #0.25
+  description: Plays 5 snares in a 4/3 syncopation, a rhythm commonly used in drum&bass. This one only swaps snares and preserves the original rhythm better.
+
+dotted snares 2 long:
+  pattern: 1, 2, 3 , 4, | 5, 7 , 6, 8, | 11 , 10, 9, 11 , | 13, 14, 15 , 16, | 17, 19 , 18, 20, | 23 , 22, 21, 23 , | 25, 26, 27 , 28, | 29, 31 , 30, 32
+  scale: 0.5 #0.25
+  description: Plays 10 snares in a long 4/3 syncopation, a rhythm commonly used in drum&bass/darkstep.
+  
+dotted snares 2 longer:
+  pattern: 1, 2, 3 , 4, | 5, 7 , 6, 8, | 11 , 10, 9, 11 , | 13, 14, 15 , 16, | 17, 19 , 18, 20, | 23 , 22, 21, 23 , | 25, 26, 27 , 28, | 29, 31 , 30, 32
+  scale: 0.5 #0.25
+  description: Plays 20 snares in a very long 4/3 syncopation to create a rolling, jazzy feel.
+
+dotted snares fast 1:
+  pattern: 1, 2, 3, 5>0.5, 7, 5>0.5, 11, 5>0.5, 7, 5>0.5, 11, 9>0.5, 7, 9>0.5, 11, 9>0.5, 7, 9>0.5, 11, 16
+  scale: 0.5
+  description: Plays 10 snares in a fast 4/3 syncopation, a rhythm commonly used in drum&bass
+
+dotted snares fast 2:
+  pattern: 1, 2>0.75,   2>0.25, 1.25:1.75;3, 4>0.75, 4>0.75, 4>0.75, 4>0.25, 3.25:3.75;5, 6>0.75, 6>0.75;7, 8>0.75, 6>0.25;8<0.25
+  scale: 1
+  description: Plays 10 snares in a fast 4/3 syncopation, a rhythm commonly used in drum&bass
+
+dotted kicks:
+  pattern: 1>0.75, 1>0.25, 2>0.5, 1>0.75, 1>0.75, 4>0.75, 1>0.75, 1>0.5, 6>0.25, 1>0.75, 1>0.75, 1>0.25, 8>0.5, 1>0.5
+  scale: 1
+  description: Plays the first beat in a 4/3 syncopation while preserving snare beats.
+
+dotted kicks 2:
+  pattern: 0:0.75, 0.75:1.5;0:0.75, 1.5:2.25;0:0.75, 2.25:3;0:0.75, 3:3.75;0:0.75, 3.75:4.5;0:0.75, 4.5:5.25;0:0.75, 5.25:6;0:0.75, 6:6.75;0:0.75, 6.75:7.5;0:0.75, 7.5:8;0:0.5
+  scale: 1
+  description: Plays a 4/3 syncopated first beat on top of normal beats.
+
+tripple dotted: #try shifts
+  pattern: 1>0.375, 1>0.375, 1>0.25
+  scale: 8, 4, 2, 1, 0.5
+  description: Each beat turns into three 4/3 syncopated notes. Can be somewhat similar to footwork.
+
+tripple dotted snares:
+  pattern: 1>0.375, 1>0.375, 1>0.25
+  scale: 8, 4, 2
+  shift: 1
+  description: plays only the snare beats in three 4/3 syncopated notes, a rhythm used in drum&bass/jungle.
+
+dotted structure:
+  pattern: 1>0.75, 2>0.75, 4>0.5
+  scale: 4, 2, 1 #0.5
+  description: plays the significant drum beats as three 4/3 syncopated notes. Similar to moombahton but without the second kick.
+
+dotted chaos 1:
+  pattern: 1>1/3
+  scale: 0.75
+
+dotted chaos 2:
+  pattern: 1>1/6
+  scale: 0.75
+
+dotted pattern 1:
+  pattern: 1, 2>0.75,   2>0.25, 1.25:1.75;3, 2>0.75, 2>0.75, 2>0.75, 2>0.25, 1.25:1.75;5, 2>0.75, 2>0.75;7, 2>0.75, 2>0.25;8<0.25
+  scale: 0.5
+  description: plays part between first kick and snare in a 4/3 syncopation, with original drums on top.
+
+dotted pattern 2:
+  pattern: 1, 2>0.75,   2>0.25, 1.25:1.75;3, 4>0.75, 4>0.75, 4>0.75, 4>0.25, 3.25:3.75;5, 6>0.75, 6>0.75;7, 8>0.75, 6>0.25;8<0.25
+  scale: 0.5
+  description: plays parts between each kick and snare in a 4/3 syncopation, with original drums on top.
+
+# ________________ TIME SIGNATURES ________________
+4-3:
+  pattern: 1>2/3, 2>2/3, 2>2/3
+  scale: 2, 1, 0.5
+  description: 4/3 time signature, preserves length
+
+3-4:
+  pattern: 1>0.75
+  scale: 8, 4, 3, 2
+  description: plays 3 beats out of each 4, creating 3/4 time signature
+
+4-7 1:
+  pattern: 1, 2, 3, 4>0.5
+  scale: 2, 1, 0.5, 0.25, 0.125
+  description: cuts 4th beat in half, creating 4/7 time signature
+
+4-7 2:
+  pattern: 1, 2, 3, 4>0.25, 3.75:4, 5,6>0.5, 7, 8
+  scale: 2, 1, 0.5, 0.25, 0.125
+  description: alternates between cutting 2nd and 4th beats in half, creating a natural 4/7 time signature
+
+4-13:
+  pattern: 1, 2, 3, 4>0.25
+  scale: 4, 2, 1, 0.5
+  description: abruptly stops on quarter of the 4th beat, creating 4/13 time signature
+
+# ________________ GENRES ________________
+moombahton:
+  pattern: 1>0.75, 2>0.25, 1>0.5, 4>0.5
+  scale: 3, 2, 1
+  description: a distinct popular moombathon/dutch house rhythm.
+
+four-on-the-floor 1:
+  pattern: 1, 2, 1, 4, 1, 6, 1, 8, 1, 10, 1, 12, 1, 14, 1, 16
+  scale: 0.5
+  description: replaces snares with kicks
+
+four-on-the-floor 1 double-time:
+  pattern: 1, 2, 1, 4, 1, 6, 1, 8, 1, 10, 1, 12, 1, 14, 1, 16, 1, 18, 1, 20, 1, 22, 1, 24, 1, 26, 1, 28, 1, 30, 1, 32
+  scale: 0.25
+  description: replaces snares with kicks
+
+house 1:
+  pattern: 1, 2, 3, 4, 1, 6, 7, 8, 1, 10, 11, 12, 1, 14, 15, 16
+  scale: 0.5
+  
+house 1 double-time:
+  pattern: 1, 2, 5, 4, 1, 6, 5, 8, 1, 10, 13, 12, 1, 14, 13, 16, 1, 18, 21, 20, 1, 22, 21, 24, 1, 26, 29, 28, 1, 30, 29, 32
+  scale: 0.25
+
+house 2:
+  pattern: 1>0.5
+  scale: 4
+
+house 2 double-time:
+  pattern: 1>0.25
+  scale: 4
+
+drill:
+  pattern: 1>0.75, 2>0.75, 2>0.5,  3>0.75, 4>0.75, 4>0.5,  5>0.75, 6>0.75, 6>0.5,  6, 7>0.75, 8<0.25
+  scale: 1, 0.5, 0.25 #2
+  description: distinct drill rhythm with 4/3 syncopatied notes and a shifted second snare.
+
+jungle 1:
+  pattern: 1, 2, 3, 4, 5, 7, 6, 8, | 11, 10, 11, 12, 13, 15, 14, 16, | 19, 18, 19, 20, 21, 23, 22, 24, | 27, 26, 27, 28, 29, 31, 30, 32
+  scale: 1.5, 0.75, 0.5
+  description: Rhythm commonly used in jungle, otherwise sounds like a buildup snare pattern.
+
+jungle 2:
+  pattern: 1, 2, 1, 2, | 3>0.5, 3>0.5, 1>0.5, 7>0.5, | 7>0.5, 7>0.5, 5>0.5, 11>0.5, | 11>0.5, 7>0.5, 0>0.5, 11>0.5, |  14>0.5, 11>0.5, 13>0.5, 15>0.5, 16!
+  scale: 0.5
+  description: 4/3 syncopated snares with additional snare-rolls
+
+drumfunk:
+  pattern: 1, 2, 3 , 4, | 3 , 4, 9, 7 , | 8, 10, 11 , 0>0.5, 11>0.5 , | 0>0.5, 15>0.5, 14, 15 , 16
+  scale: 1, 0.5
+  description: pattern commonly used in drumfunk
+
+jazzy:
+  pattern: 1, 2>0.5, 3, 4>0.5, 5, 6>0.5, 3, 4>0.5, 7, 8
+  scale: 0.5, 0.25
+  description: seamlessly adds a 4/3 syncopation without disrupting the original rhythm
+
+darkstep:
+  pattern: 1,1,3,1, | 1,7,1,1, | 11,9,9,11, | 9,9,15,16
+  scale: 1, 0.5
+
+darkstep long:
+  pattern: 1,1,3,1, | 1,7,1,1, | 11,9,9,11, | 9,9,15,9, | 17,19,17,17, | 19,17,17,23, | 25,25,27,25, | 25,31,25,32
+  scale: 0.5
+
+darkstep fast:
+  pattern: 1,1,5,1, | 1,13,1,1, | 21,17,17,21, | 17,17,29,32
+  scale: 0.25
+
+# ________________ EFFECTS ________________
+staccato reverese:
+  pattern: 1>0.5, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 3>0.6, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.7r, 5>0.5, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 7>0.6, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 7.6:7.9, 7.0>0
+  scale: 0.5, 0.25
+
+staccato reverese syncopated 1:
+  pattern: 1, 2>0.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:3r, | 9, 10.5:12, 10.5:12r, 10.5:12, 10.5:12r, 10.5:11.5, | 16:16.5, 18.5:20r, 18.5:20, 18.5:20r, 18.5:20, 18.5:20r, | 25, 25:25.5, 26.5:28r, 26.5:28, 26.5:28r, 26.5:28, 31.5:32
+  scale: 1/8, 1/16
+
+staccato reverese syncopated 2:
+  pattern: 1, 2>0.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:3r, | 9, 2.5:4, 2.5:4r, 2.5:4, 2.5:4r, 2.5:3.5, | 16:16.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:4r, | 25, 25:25.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 31.5:32
+  scale: 1/8, 1/16
+
+staccato reverese syncopated 3:
+  pattern: 1, 2>0.5, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, 2.5:3, | 9, 2.5:4r, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, | 16:17.5, 2.5:4r, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r, | 24:25.5, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, 2.5:4, 31.5:32r
+  scale: 1/8, 1/16
+
+# ________________ SONGS ________________
+BS6:
+  pattern: 1, 1, | 3>1.5, 3>1.5, 3>1.5, 3>1.5, | 9, 9>0.5 | 14.5>1.5, 14.5>1.5, 14.5>1.5, 14.5>1.5, 14.5>0.5, 16!
+  scale: 1, 0.5
+  description: Hyroglifics & Sinistarr - BS6
+
+Poison:
+  pattern: 0:1/3, 0:1/3, 1:4/3, 1:4/3, 2:7/3, 2:7/3, 3:10/3, 3:10/3, 1/3:2/3, 4/3:5/3, 10/3:4
+  scale: 1
+  description: Stray & Halogenix - Poison
+
+Szamar Madar:
+  pattern: 1, 2, 3, 4, 4, 1, 2, 3, 1, 1v0, 1v0, 1, 7, 8,|9, 10, 11, 12, 13, 14, 15, 16, 15, 10, 10, 10, 11, 16,|17, 18, 19, 20, 20, 17, 18, 19, 20, 20, 17, 17v0, 23, 24,|25, 25:25.5, 24:24.5, 27, 25, 28, 25, 31, 24:24.5, 27.5:28, 24:24.5, 27.5:28, 25, 25, 25, 31, 32
+  scale: 0.5
+  description: Venetian Snares - Szamár Madár (11/4)
+
+Conceivability:
+  pattern: 1, 2, 3, 4, 9, 10, 11, 12, 13, 14, 16<0.5, 16>0.5, | 17, 18, 19>0.5, 20, 21, 21<0.5, 22, 23, 23<0.5, 24, 30, 31, 32>0.5
+  scale: 1
+
+Rhythm Era:
+  pattern: 1, 2>0.75, 2>0.75, 2>0.75, 2>0.25, | 5, 6>0.75, 8>0.75, 6>0.75, 8>0.25, | 9, 10>0.75, 10>0.75, 10>0.75, 10>0.25, | 13, 14>0.75v0.6; 16>0.75v0.6, 14>0.75, 14>0.5, 14>0.5v0.6; 16>0.5v0.6
+  scale: 1
+  description: stunlocked - Rhythm Era (7/4)
+
+# ________________ OTHER ________________
+test:
+  pattern: test
+  description: puts cowbells on beats

beat_manipulator/tests.py

@@ -1,121 +0,0 @@
-from . import main as bm
-audio=list(i/100 for i in range(-100,100,1))
-beatmap=list(range(0,100,10))+list(range(100,201,20))
-
-def printb(text):
-    print(f'\033[1m{text}\033[0m')
-def printe(text):
-    print(f'\x1b[0;31;40m{text}\x1b[0m')
-
-# audio:
-# [-1.0, -0.99, -0.98, -0.97, -0.96, -0.95, -0.94, -0.93, -0.92, -0.91, -0.9, -0.89, -0.88, -0.87, -0.86, -0.85, -0.84, -0.83, -0.82, -0.81, -0.8, -0.79, -0.78, -0.77, -0.76, -0.75, -0.74, -0.73, -0.72, -0.71, -0.7, -0.69, -0.68, -0.67, -0.66, -0.65, -0.64, -0.63, -0.62, -0.61, -0.6, -0.59, -0.58, -0.57, -0.56, -0.55, -0.54, -0.53, -0.52, -0.51, -0.5, -0.49, -0.48, -0.47, -0.46, -0.45, -0.44, -0.43, -0.42, -0.41, -0.4, -0.39, -0.38, -0.37, -0.36, -0.35, -0.34, -0.33, -0.32, -0.31, -0.3, -0.29, -0.28, -0.27, -0.26, -0.25, -0.24, -0.23, -0.22, -0.21, -0.2, -0.19, -0.18, -0.17, -0.16, -0.15, -0.14, -0.13, -0.12, -0.11, -0.1, -0.09, -0.08, -0.07, -0.06, -0.05, -0.04, -0.03, -0.02, -0.01, 0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.7, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.8, 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, 0.9, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99] 
-# audio at beatmap:
-# [-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
-
-test=bm.song(audio=audio, samplerate=2, bmap=beatmap, filename='test.mp3', log=False)
-if list(test.bm) == beatmap: printb('beatmap assignment passed')
-else: printe(f'''beatmap assignment error.
-{beatmap}
-{test.beatmap}''')
-
-test.beatmap.shift(2)
-if list(test.bm) == beatmap[2:]: printb('beatmap_shift(2) passed')
-else: printe(f'''beatmap_shift(2) error, 1st line is the expected result:
-{[0, 1, 2] + beatmap[1:]}
-{test.beatmap}''')
-
-test.beatmap.beatmap = beatmap.copy()
-test.beatmap.shift(-2)
-if list(test.bm) == list([0, 1, 2] + beatmap[1:]): printb ('beatmap_shift(-2) passed')
-else:printe(f'''beatmap_shift(-2) error, 1st line is the expected result:
-{beatmap[2:]}
-{test.beatmap}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[5, 15, 25, 35, 45, 55, 65, 75, 85, 95, 110, 130, 150, 170, 190, 200]
-test.beatmap.shift(0.5)
-if list(test.bm) == should: printb('beatmap_shift(0.5) passed')
-else:printe(f'''beatmap_shift(0.5) error, 1st line is the expected result:
-{should}
-{test.beatmap}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[0, 5, 15, 25, 35, 45, 55, 65, 75, 85, 95, 110, 130, 150, 170, 190]
-test.beatmap.shift(-0.5)
-if list(test.bm) == should: printb('beatmap_shift(-0.5) passed')
-else:printe(f'''beatmap_shift(-0.5) error, 1st line is the expected result:
-{should}
-{test.beatmap}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[25, 35, 45, 55, 65, 75, 85, 95, 110, 130, 150, 170, 190, 200]
-test.beatmap.shift(2.5)
-if list(test.bm) == should: printb('beatmap_shift(2.5) passed')
-else:printe(f'''beatmap_shift(2.5) error, 1st line is the expected result:
-{should}
-{list(test.beatmap)}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[1, 2, 3, 5, 15, 25, 35, 45, 55, 65, 75, 85, 95, 110, 130, 150, 170, 190]
-test.beatmap.shift(-2.5)
-if list(test.bm) == should: printb('beatmap_shift(-2.5) passed')
-else:printe(f'''beatmap_shift(-2.5) error, 1st line is the expected result:
-{should}
-{list(test.beatmap)}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[0, 20, 40, 60, 80, 100, 140, 180]
-test.beatmap.scale(2)
-if list(test.bm) == should: printb('beatmap_scale(2) passed')
-else:printe(f'''beatmap_scale(2) error, 1st line is the expected result:
-{should}
-{list(test.beatmap)}''')
-
-test.beatmap.beatmap = beatmap.copy()
-should=[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190]
-test.beatmap.scale(0.5)
-if list(test.bm) == should: printb('beatmap_scale(2) passed')
-else:printe(f'''beatmap_scale(2) error, 1st line is the expected result:
-{should}
-{list(test.beatmap)}''')
-
-test.beatmap.beatmap = beatmap.copy()
-test.beatswap("1, 3, 2, 4", smoothing=0)
-should=[[-1.0, -0.99, -0.98, -0.97, -0.96, -0.95, -0.94, -0.93, -0.92, -0.91, -0.8, -0.79, -0.78, -0.77, -0.76, -0.75, -0.74, -0.73, -0.72, -0.71, -0.9, -0.89, -0.88, -0.87, -0.86, -0.85, -0.84, -0.83, -0.82, -0.81, -0.7, -0.69, -0.68, -0.67, -0.66, -0.65, -0.64, -0.63, -0.62, -0.61, -0.6, -0.59, -0.58, -0.57, -0.56, -0.55, -0.54, -0.53, -0.52, -0.51, -0.4, -0.39, -0.38, -0.37, -0.36, -0.35, -0.34, -0.33, -0.32, -0.31, -0.5, -0.49, -0.48, -0.47, -0.46, -0.45, -0.44, -0.43, -0.42, -0.41, -0.3, -0.29, -0.28, -0.27, -0.26, -0.25, -0.24, -0.23, -0.22, -0.21, -0.2, -0.19, -0.18, -0.17, -0.16, -0.15, -0.14, -0.13, -0.12, -0.11, 0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, -0.1, -0.09, -0.08, -0.07, -0.06, -0.05, -0.04, -0.03, -0.02, -0.01, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.8, 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, 0.9, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99, 0.6, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.7, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79], [-1.0, -0.99, -0.98, -0.97, -0.96, -0.95, -0.94, -0.93, -0.92, -0.91, -0.8, -0.79, -0.78, -0.77, -0.76, -0.75, -0.74, -0.73, -0.72, -0.71, -0.9, -0.89, -0.88, -0.87, -0.86, -0.85, -0.84, -0.83, -0.82, -0.81, -0.7, -0.69, -0.68, -0.67, -0.66, -0.65, -0.64, -0.63, -0.62, -0.61, -0.6, -0.59, -0.58, -0.57, -0.56, -0.55, -0.54, -0.53, -0.52, -0.51, -0.4, -0.39, -0.38, -0.37, -0.36, -0.35, -0.34, -0.33, -0.32, -0.31, -0.5, -0.49, -0.48, -0.47, -0.46, -0.45, -0.44, -0.43, -0.42, -0.41, -0.3, -0.29, -0.28, -0.27, -0.26, -0.25, -0.24, -0.23, -0.22, -0.21, -0.2, -0.19, -0.18, -0.17, -0.16, -0.15, -0.14, -0.13, -0.12, -0.11, 0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, -0.1, -0.09, -0.08, -0.07, -0.06, -0.05, -0.04, -0.03, -0.02, -0.01, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.8, 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, 0.9, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99, 0.6, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.7, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79]]
-if list(test.audio) == should: printb('beatswap("1, 3, 2, 4") passed')
-else:printe(f'''beatswap("1, 3, 2, 4") error, 1st line is the expected result:
-{should}
-{list(test.audio)}''')
-
-# [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 120, 140, 160, 180, 200]
-
-def import_test():
-    audio2=list(i/100000 for i in range(-100000,100000,1))
-    beatmap2=list(range(0,100000,10))+list(range(100,200001,20))
-    test2=bm.song(audio=audio2, samplerate=2, bmap=beatmap2, filename='test2.mp3', log=False)
-
-def shift_test(number, shift):
-    audio2=list(i/number for i in range(-number,number,1))
-    beatmap2=list(range(0,number,10))+list(range(100,number*2+1,20))
-    test2=bm.song(audio=audio2, samplerate=2, bmap=beatmap2, filename='test2.mp3', log=False)
-    test2.beatmap.shift(shift)
-
-def scale_test(number, scale):
-    audio2=list(i/number for i in range(-number,number,1))
-    beatmap2=list(range(0,number,10))+list(range(100,number*2+1,20))
-    test2=bm.song(audio=audio2, samplerate=2, bmap=beatmap2, filename='test2.mp3',log=False)
-    test2.beatmap.scale(0.5)
-
-def beatswap_test(number, pattern):
-    audio2=list((i/number)*100 for i in range(-number,number,1))
-    beatmap2=list(range(0,number*100,1000))+list(range(10000,number*200+1,2000))
-    test2=bm.song(audio=audio2, samplerate=2, bmap=beatmap2, filename='test2.mp3',log=False)
-    test2.beatswap(pattern)
-
-input('run time tests?')
-import timeit
-printb(f'beatmap_shift(-2.5) for 1000 beats takes {timeit.timeit(lambda: shift_test(1000,shift=-2.5), number=1)}') #0.0028216999489814043
-printb(f'beatmap_shift(-2.5) for 20000 beats takes {timeit.timeit(lambda: shift_test(20000,shift=-2.5), number=1)}') #0.6304191001690924
-printb(f'beatmap_scale(0.5) for 20000 beats takes {timeit.timeit(lambda: scale_test(20000,scale=0.5), number=1)}') #0.10623739985749125
-printb(f'test2.beatswap("1,3,2,4") for 20000 beats takes {timeit.timeit(lambda: beatswap_test(20000,pattern="1,3,2,4"), number=1)}') #0.406920799985528
-printb(f'test2.beatswap("1v2, 0:0.5b5, 1:1.5r, 3c, 4:3") for 20000 beats takes {timeit.timeit(lambda: beatswap_test(20000,pattern="1v2, 0:0.5b5, 1:1.5r, 3c, 4:3"), number=1)}') #0.5667359000071883

beat_manipulator/utils.py

@@ -0,0 +1,25 @@
+C_SLICE = ":><"  # 0 - range, 1 - first, 2 - last
+C_JOIN = ",;~&^$}" # 0 - append, 1 - first length, 2 - cut, 3 - maximum, 4 - sidechain
+C_MISC = "'\"`i@_?%#![]"
+# 0 ',1 " - sample, 2 ` - sample uncut, 3 i - current, 4 @ - random, 
+# # 5 _ - random sep, 6 ? - not count, 7 % - create variable, 8 # - shuffle, 9 ! skip
+# 10, 11 [] - song
+C_MATH = '+-*/.'
+C_MATH_STRICT = '.+-*/'
+
+def _safer_eval(string:str) -> float:
+    if isinstance(string, str): 
+        try:
+            for i in (C_MISC[4], C_MISC[7], C_MISC[8]):
+                if i in string: string = string[:string.find(i)]
+            string = string.replace('{', '<').replace('}', '>')
+            string = eval(''.join([i for i in string if i.isdecimal() or i in C_MATH]))
+        except (NameError, SyntaxError): string = 1
+    return string
+
+def _safer_eval_strict(string:str) -> float:
+    if isinstance(string, str): 
+        for n, v in enumerate(string):
+            assert v in C_MATH_STRICT or v == ' ' or v.isdecimal, f"_safer_eval_strict error: {string}[{n}] = {v}, which isn't a decimal, isn't in {C_MATH_STRICT} and isn't a space"
+        string = eval(''.join([i for i in string if i.isdecimal() or i in C_MATH_STRICT]))
+    return string

beat_manipulator/wrapper.py

@@ -1,209 +0,0 @@
-from . import main as bm
-from .main import _outputfilename
-import json
-def _safer_eval(string:str) -> float:
-    if isinstance(string, str): 
-        #print(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-        string = eval(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
-    return string
-
-with open("presets.json", "r") as f:
-    presets=f.read()
-
-presets=json.loads(presets)
-
-def _song_copy(audio:bm.song):
-    return bm.song(path=audio.path, audio=audio.audio, samplerate=audio.samplerate, bmap=audio.beatmap, caching=audio.caching, filename=audio.filename, copied=True)
-
-def _normalize(song: bm.song, beat, pattern=None, scale=None, shift=None):
-    beat=beat.lower()
-    if pattern is not None:
-        if scale is None: scale=1
-        if shift is None: shift=0
-        song.quick_beatswap(output=None, pattern=pattern, scale=scale,shift=shift)
-    elif beat=='normal' or beat is None: pass
-    elif beat=='shifted': song.quick_beatswap(output=None, pattern='1,2,3,4,5,7,6,8', scale=0.5)
-    elif beat=='shifted2': song.quick_beatswap(output=None, pattern='1,2,3,4,5,6,8,7', scale=0.5)
-    else: print(f"'{beat}' is not a valid beat")
-    return song
-
-def lib_test(filename,output='', samplerate=44100, lib='madmom.BeatDetectionProcessor', scale=1, shift=0,beat='normal', log=False):
-    '''basically a way to quickly test scale and offset'''
-    if type(filename)==str :
-        song=bm.song(filename)
-        samplerate=song.samplerate
-    else:
-        song=filename
-    if beat!='normal' and beat is not None: song=_normalize(song=song, beat=beat, scale=scale, shift=shift)
-    song.quick_beatswap(output=None, pattern='test', scale=scale, shift=shift, log=log)
-    if beat!='normal' and beat is not None: song=_normalize(song=song, beat=beat, scale=scale, shift=shift)
-    song.write_audio(output=bm.outputfilename('', song.filename, f' ({lib} x{scale} {shift})'))
-
-def lib_test_full(filename,samplerate, log):
-    '''A way to test all beat detection modules to see which one performs better.'''
-    print(filename)
-    lib_test(filename, samplerate,'madmom.BeatDetectionProcessor', log=log)
-    lib_test(filename, samplerate,'madmom.BeatDetectionProcessor.consistent', log=log)
-    #lib_test(filename, samplerate,'madmom.BeatTrackingProcessor') # better for live performances with variable BPM
-    #lib_test(filename, samplerate,'madmom.BeatTrackingProcessor.constant') # results identical to madmom.BeatDetectionProcessor
-    lib_test(filename, samplerate,'madmom.BeatTrackingProcessor.consistent', log=log)
-    lib_test(filename, samplerate,'madmom.CRFBeatDetectionProcessor', log=log)
-    lib_test(filename, samplerate,'madmom.CRFBeatDetectionProcessor.constant',log=log)
-    #lib_test(filename, samplerate,'madmom.DBNBeatTrackingProcessor') # better for live performances with variable BPM
-    lib_test(filename, samplerate,'madmom.DBNBeatTrackingProcessor.1000',log=log)
-    lib_test(filename, samplerate,'madmom.DBNDownBeatTrackingProcessor',log=log)
-    import gc
-    gc.collect()
-
-def _process_list(something)-> list:
-    if isinstance(something, int) or isinstance(something, float): something=(something,)
-    elif isinstance(something,list): False if isinstance(something[0],int) or isinstance(something[0],float) else list(_safer_eval(i) for i in something)
-    else: something=list(_safer_eval(i) for i in something.split(','))
-    return something
-
-def _process(song:bm.song, preset: str, scale:float, shift:float, random=False, every=False, log=True)->bm.song:
-    #print(preset)
-    if 'pattern' in preset:
-        shift=shift+(preset['shift'] if 'shift' in preset else 0)
-        # Scale can be a list and we either take one value or all of them
-        if 'scale' in preset: pscale=_process_list(preset['scale'])
-        else: pscale=(1,)
-        #input(pscale)
-        if random is True:
-            import random
-            pscale=random.choice(pscale)
-        elif every is True:
-            songs=[]
-            for i in pscale:
-                song2=_song_copy(song)
-                song2.quick_beatswap(output=None, pattern=preset['pattern'], scale=scale*i, shift=shift, log = log)
-                songs.append((song2, i))
-            return songs
-        else: pscale=preset['scale_d'] if 'scale_d' in preset else pscale[0]
-        if every is False: song.quick_beatswap(output=None, pattern=preset['pattern'], scale=scale*pscale, shift=shift, log = log)
-    elif preset['type'] =='sidechain':
-        length=preset['sc length'] if 'sc length' in preset else 0.5
-        curve=preset['sc curve'] if 'sc curve' in preset else 2
-        vol0=preset['sc vol0'] if 'sc vol0' in preset else 0
-        vol1=preset['sc vol1'] if 'sc vol1' in preset else 1
-        from . import generate
-        sidechain=bm.open_audio(preset['sc impulse'])[0] if 'sc impulse' in preset else generate.sidechain(samplerate=song.samplerate, length=length, curve=curve, vol0=vol0, vol1=vol1, smoothing=40)
-        scale=scale*(preset['scale'] if 'scale' in preset else 1)
-        shift=shift+(preset['shift'] if 'shift' in preset else 0)
-        song.quick_sidechain(output=None, audio2=sidechain, scale=scale, shift=shift)
-    elif preset['type'] =='beatsample':
-        sample=preset['filename']
-        scale=scale*(preset['scale'] if 'scale' in preset else 1)
-        shift=shift+(preset['shift'] if 'shift' in preset else 0)
-        song.quick_beatsample(output=None, filename2=sample, scale=scale, shift=shift)
-    return song
-
-
-def use_preset(output:str,song: str, preset: str, presets=presets, scale=1, shift=0, beat:str='normal', test=False, _normalize=True, random=False, every=False, log = True):
-    if not isinstance(song, bm.song): 
-        song=bm.song(song)
-    else: song = _song_copy(song)
-    #print(song.samplerate)
-    if preset is None:
-        weights=[]
-        for i in presets.items():
-            weights.append(i[1]['weight'])
-        import random
-        preset = random.choices(population=list(presets), weights=weights, k=1)[0]
-    name=preset
-    if isinstance(preset, str): preset=presets[preset]
-    if test is True:
-        testsong=_song_copy(song)
-        lib_test(testsong, output, samplerate=testsong.samplerate, log = log)
-        del testsong
-    #print(name, preset)
-    if _normalize is True and beat!='normal' and beat is not None:
-        if '_normalize' in preset:
-            if preset['_normalize'] is True:
-                song=_normalize(song, beat)
-    if '1' in preset:
-        for i in preset:
-            if type(preset[i])==dict:song=_process(song, preset[i], scale=scale, shift=shift, log=log)
-    else: song=_process(song, preset,scale=scale,shift=shift,random=random, every=every, log=log)
-    if isinstance(song, list): 
-        for i in song:
-            i[0].write(output=_outputfilename(output, i[0].filename, suffix=f' ({name}{(" x"+str(round(i[1], 3)))*(len(song)>1)})'))
-    else: 
-        out_folder = _outputfilename(output,  song.filename, suffix=' ('+name+')')
-        song.write(output=out_folder)
-        return out_folder
-
-def all(output:str,filename: str, presets:dict=presets, scale=1, shift=0, beat='normal', test=True, boring=False, effects=False, variations=False, log = False):
-    if boring is False:
-        for i in ['2x faster','3x faster','4x faster','8x faster','1.33x faster','1.5x faster','1.5x slower','reverse','random', 'syncopated effect']:
-            if i in presets: 
-                #print(i)
-                presets.pop(i)
-    if not isinstance(filename, bm.song): song=bm.song(filename)
-    else: song=filename
-    song__normalized=_normalize(_song_copy(song), beat)
-    if test is True:
-        testsong=_song_copy(song)
-        lib_test(testsong, output, samplerate=testsong.samplerate, log = log)
-        del testsong
-    for key, i in presets.items():
-        #print(key, i)
-        if 'scale' in i:
-            #print(i['scale'])
-            if isinstance(i['scale'], int) or isinstance(i['scale'], float):
-                if i['scale']<0.01:
-                    continue
-                if effects is False:
-                    if 'effect - ' in key: continue
-        if '_normalize' in i:
-            if i['_normalize'] is True:
-                song2=_song_copy(song__normalized)
-            else: song2=_song_copy(song)
-        else: song2=_song_copy(song)
-        use_preset(output, song2, preset=key, presets=presets, scale=scale, shift=shift, beat=beat, test=False, _normalize=False, every=variations, log = log)
-
-
-
-# ___ my stuff ___
-
-# ___ get song ___
-#filename='F:/Stuff/Music/Tracks/Poseidon & Leon Ross - Parallax.mp3'
-#filename = 'F:/Stuff/Music/Tracks/'+random.choice(os.listdir("F:\Stuff\Music\Tracks"))
-# print(filename)
-
-# ___ analyze+fix ___
-#scale, shift = 1,0
-#lib_test(filename, scale=scale, shift=shift)
-#bm.fix_beatmap(filename, scale=scale, shift=shift)
-
-# ___ presets ___
-#use_preset ('', filename, 'dotted kicks', scale=1, shift=0, beat='normal', test=False)
-#use_preset ('', filename, None, scale=scale, shift=shift, test=False)
-#all('', filename, scale=1, shift=0, beat='normal', test=False)
-
-# ___ beat swap __
-#song=bm.song(filename)
-#song.quick_beatswap(output='', pattern='test', scale=1, shift=0)
-
-# ___ osu ___
-#song=bm.song()
-#song.generate_hitmap()
-#song.osu()
-#song.hitsample()
-
-# ___ saber2osu ___
-#import Saber2Osu as s2o
-#osu=s2o.osu_map(threshold=0.3, declumping=100)
-
-# ___ song to image ___
-#song.write_image()
-
-# ___ randoms ___
-# while True:
-#     filename = 'F:/Stuff/Music/Tracks/'+random.choice(os.listdir("F:\Stuff\Music\Tracks"))
-#     use_preset ('', filename, None, scale=scale, shift=shift, test=False)
-
-# ___ effects ___
-#song = bm.song(filename)
-#song.audio=bm.pitchB(song.audio, 2, 100)
-#song.write_audio(bm.outputfilename('',filename, ' (pitch)'))

examples.py

@@ -0,0 +1,11 @@
+import beat_manipulator as bm, os, random
+
+path = 'F:/Stuff/Music/Tracks/'
+song = 'Phonetick - You.mp3'
+song = path + song
+
+#bm.presets.savetest(song, scale = 1, shift = 0)
+
+bm.beatswap(song, 'random', scale = 1, shift = 0)
+
+#bm.presets.use(song = song, preset = 'dotted snares fast 1', scale = 1)

jupiter.ipynb

@@ -0,0 +1,137 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<h1><b><center>Beat Manipulator</center></b></h1>"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simply put your pattern in the cell below and run it as many times as you wish. Pattern syntax, scale and shift are explained here https://github.com/stunlocked1/BeatManipulator\n",
+    "\n",
+    "A file selection dialog will open. Note: you might need to Alt+Tab to it due to how Jupiter works (press Alt+Tab and select file selection dialog). Alternatively you can add `audio=\"path/to/audio\"` attribute into bm.beatswap to load a specified audio file.\n",
+    "\n",
+    "Choose any audio file, and the beatswapped version will be displayed, as well as saved next to this Jupiter Notebook file.\n",
+    "\n",
+    "Analyzing beats for the first time will take some time, but if you open the same file for the second time, it will load a saved beat map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pattern = '1, 4' # Replace this with your pattern. You can write \"test\" as a pattern to test where each beat is.\n",
+    "scale = 1\n",
+    "shift = 0\n",
+    "audio = None # If you want to skip select file dialog, replace None with a path to your audio file\n",
+    "\n",
+    "pattern_length = None # Length of the pattern. If None, this will be inferred from the highest number in the pattern\n",
+    "\n",
+    "\n",
+    "import beat_manipulator as bm, IPython\n",
+    "print(\"Press alt+tab if file selection dialog didn't show\")\n",
+    "path = bm.beatswap(audio=audio, pattern = pattern, scale = scale, shift = shift, length = pattern_length)\n",
+    "IPython.display.Audio(path)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "***\n",
+    "## Other stuff\n",
+    "Those operate the same as the above cell"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Song to image**\n",
+    "\n",
+    "creates an image based on beat positions, so each song will generate a unique image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_size = 512 # image will be a square with this size in pixels\n",
+    "audio = None # If you want to skip select file dialog, replace None with a path to your audio file\n",
+    "\n",
+    "\n",
+    "import beat_manipulator as bm, IPython\n",
+    "print(\"Press alt+tab if file selection dialog didn't show\")\n",
+    "path = bm.image(audio=audio, max_size = image_size)\n",
+    "IPython.display.Image(path)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "***\n",
+    "**osu! beatmap generator**\n",
+    "\n",
+    "generates an osu! beatmap from your song. This generates a hitmap, probabilities of hits at each sample, picks all ones above a threshold, and turns them into osu circles, trying to emulate actual osu beatmap. This doesn't generate sliders, however, because no known science has been able to comprehend the complexity of those.\n",
+    "\n",
+    "The .osz file will be generated next to this notebook, open it with osu! to install it as any other beatmap."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "difficulties = [0.2, 0.1, 0.05, 0.025, 0.01, 0.0075, 0.005, 0.0025, 0.0001] # all difficulties will be embedded in one beatmap, lower = harder.\n",
+    "audio = None # If you want to skip select file dialog, replace None with a path to your audio file\n",
+    "\n",
+    "\n",
+    "import beat_manipulator.osu\n",
+    "print(\"Press alt+tab if file selection dialog didn't show\")\n",
+    "beat_manipulator.osu.generate(song=audio, difficulties = difficulties)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "audio310",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "f56da36b984886453ea677d340712034d0bd218b2dc7a53ab7c38da0c6f67f35"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

packages.txt

@@ -1,3 +0,0 @@
-ffmpeg
-cython
-python3-opencv

presets.json

@@ -1,316 +0,0 @@
-{
-    "2x faster": {
-        "pattern": "0:0.5",
-        "scale": "8/3, 2, 4/3, 1, 0.5, 1/3, 0.25",
-        "scale_d": 1,
-        "weight": 2.5
-    },
-    "3x faster": {
-        "pattern": "0:1/3",
-        "scale": "8, 4, 2, 1, 0.5, 1/3",
-        "scale_d": 1,
-        "weight": 2.5
-    },
-    "4x faster": {
-        "pattern": "0:0.25",
-        "scale": "2, 1, 0.5, 1/3",
-        "scale_d": 1,
-        "weight": 1.25
-    },
-    "8x faster": {
-        "pattern": "0:0.125",
-        "scale": "2, 1, 0.5",
-        "scale_d": 1,
-        "weight": 0.75
-    },
-    "1.33x faster": {
-        "pattern": "0:0.75",
-        "scale": "16, 8, 4, 2, 1, 0.5, 1/3, 0.25, 0.2",
-        "scale_d": 1,
-        "weight": 5
-    },
-    "1.5x faster": {
-        "pattern": "0:2/3",
-        "scale": "16, 8, 4, 2, 1, 0.5, 1/3",
-        "scale_d": 1,
-        "weight": 5
-    },
-    "1.5x slower": {
-        "pattern": "0:0.5, 0.5:1r, 0.5:1",
-        "scale": "1, 0.5, 1/3, 0.25, 0.2, 1/7, 0.125",
-        "weight": 4
-    },
-    "reverse": {
-        "pattern": "reverse",
-        "scale": "1, 0.5, 1/3, 0.25, 0.2",
-        "weight": 5
-    },
-    "random": {
-        "pattern": "random",
-        "scale": "1, 0.5, 1/3",
-        "weight": 0.000000001
-    },
-    "half-time A": {
-        "pattern": "1,2,4,5, | 3,6,8,7, | 9,11,12,13, | 15,13,14,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "half-time B": {
-        "pattern": "1,2,2r,4,3,6r,6,8",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 5
-    },
-    "half-time C": {
-        "pattern": "1,2,4,5,3,8,6,8, | 9,10,12,13,15,16,14,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "quarter-time A": {
-        "pattern": "1,2,4,5,|6,8,9,10,|11,12,13,14,|16,14,15,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "quarter-time B": {
-        "pattern": "1,2,2,4, | 5,6r,6,8, | 11,10,10r,12, | 13,14r,14r,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 5
-    },
-    "quarter-time C": {
-        "pattern": "1,2,4,5, | 6,8,10,12, | 11,10,12,13, | 9,13,14,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted snares A": {
-        "pattern": "1, 1:1.5, 3, 3:3.5, 5, 5:5.5, 3, 3:3.5, 7, 8",
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted snares B": {
-        "pattern": "1, 2, 3 , 4, | 5, 7 , 6, 8, | 11 , 10, 9, 11 , | 13, 14, 15 , 16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted snares B 4": {
-        "pattern": "1, 2, 3 , 4, | 5, 7 , 6, 8, | 11 , 10, 9, 11 , | 13, 14, 15 , 16, | 17, 19 , 18, 20, | 23 , 22, 21, 23 , | 25, 26, 27 , 28, | 29, 31 , 30, 32, | 35 , 34, 33, 35 , | 37, 38, 39 , 40, | 41, 43 , 42, 44, | 47 , 46, 45, 47 , | 49, 50, 51 , 52, | 53, 55 , 54, 56, | 59 , 58, 57, 59 , | 61, 62, 63 , 64",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted snares 0.5 A": {
-        "pattern": "0:3, 4:4.5,7, 4:4.5,11, 4:4.5,7, 4:4.5,11, 8:8.5,7, 8:8.5,11, 8:8.5,7, 8:8.5,11, 16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted kicks": {
-        "pattern": "0:0.75, 0:0.25, 1:1.5, 0:0.75, 0:0.75, 3:3.75, 0:0.75, 0:0.5, 5:5.25, 0:0.75, 0:0.75, 0:0.25, 7:7.5, 0:0.5",
-        "scale": 1,
-        "normalize": true,
-        "weight": 10
-    },
-    "dotted kicks B": {
-        "pattern": "1, 2, 3, 1, |5, 6, 1, 8, 9, 1, 11, 12, |13, 14, 15, 1, 17, 18, 1, 20, |21, 1, 23, 24, 1, 26, 27, 1, |29, 30, 1, 32",
-        "scale": 0.25,
-        "normalize": true,
-        "weight": 10
-    },
-    "drum&bass": {
-        "pattern": "1, 2, 3, 4, 5, 7, 6, 8",
-        "scale": 0.5,
-        "weight": 2
-    },
-    "tripple dotted": {
-        "pattern": "0:0.375, 0:0.375, 0:0.25",
-        "scale": "8, 4, 2, 1, 0.5",
-        "scale_d": 1,
-        "weight": 5
-    },
-    "tripple dotted snares": {
-        "pattern": "0:0.375, 0:0.375, 0:0.25",
-        "scale": 2,
-        "shift": 1,
-        "normalize": true,
-        "weight": 5
-    },
-    "dotted structure": {
-        "pattern": "0:0.75, 1:1.75, 3:3.5",
-        "scale": "4, 2, 1, 1/3, 0.25, 0.2",
-        "scale_d": 1,
-        "weight": 10
-    },
-    "moombahton": {
-        "pattern": "0:0.75, 1:1.25, 0:0.5, 3:3.5",
-        "weight": 10
-    },
-    "four-on-the-floor": {
-        "pattern": "1, 0:0.5, 1.5:2,  0:0.5, 2.5:3,  0:0.5, 3.5:4,  0:0.5, 4.5:5,  0:0.5, 5.5:6,   0:0.5, 6.5:7,  0:0.5, 7.5:8",
-        "weight": 10
-    },
-    "four-on-the-floor 0.5": {
-        "pattern": "1, 2, 1, 4, 1, 6, 1, 8, 1, 10, 1, 12, 1, 14, 1, 16, 1, 18, 1, 20, 1, 22, 1, 24, 1, 26, 1, 28, 1, 30, 1, 32",
-        "scale": 0.25,
-        "weight": 10
-    },
-    "house": {
-        "pattern": "1, 2, 0:0.5, 2.5:3,  1:1.5, 3.5:4,  0:0.5, 4.5:5,  3:3.5, 5.5:6,   0:0.5, 6.5:7,  3:3.5, 7.5:8",
-        "weight": 10
-    },
-    "house 0.5": {
-        "pattern": "1, 2, 5, 4, 1, 6, 5, 8, 1, 10, 13, 12, 1, 14, 13, 16, 1, 18, 21, 20, 1, 22, 21, 24, 1, 26, 29, 28, 1, 30, 29, 32",
-        "scale": 0.25,
-        "weight": 10
-    },
-    "drill": {
-        "pattern": "0:0.75,1:1.75,1:1.5, 2:2.75,3:3.75,3:3.5, 4:4.75,5:5.75,5:5.5, 6, 6:6.75, 7.75:8",
-        "scale": 0.5,
-        "weight": 10
-    },
-    "jungle A": {
-        "pattern": "1, 2, 3, 4, 5, 7, 6, 8, | 11, 10, 11, 12, 13, 15, 14, 16, | 19, 18, 19, 20, 21, 23, 22, 24, | 27, 26, 27, 28, 29, 31, 30, 32",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "jungle B": {
-        "pattern": "1, 2, 1, 2, | 2:3.5, 2:2.5, 0:0.5, 6:6.5, | 6:7.5, 6:6.5, 4:4.5, 10:10.5, | 10:11.5, 6:6.5, 8:8.5, 10:10.5, |  14:15.5, 10:10.5, 12:12.5, 14:14.5, 16!",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "drumfunk": {
-        "pattern": "1, 2, 3 , 4, | 3 , 4, 9, 7 , | 8, 10, 11 , 8:8.5, 10:10.5 , | 8:8.5, 14:14.5, 14, 15 , 16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "neuro-hop": {
-        "pattern": "1, 1:1.5, 3, 3:3.5, 5, 5:5.5, 3, 3:3.5, 7, 8",
-        "scale": "0.5, 0.25",
-        "weight": 10
-    },
-    "BS6": {
-        "pattern": "1, 1, | 2:3.5, 2:3.5, 2:3.5, 2:3.5, 8!",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 10
-    },
-    "staccato reverese": {
-        "pattern": "0:0.5, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 2:2.6, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.7r, 4:4.5, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 6:6.6, 0.5:0.8r, 0.5:0.8, 0.5:0.8r, 7.6:7.9, 7.8:8",
-        "scale": "0.5, 0.25",
-        "weight": 2
-    },
-    "staccato reverese syncopated": {
-        "pattern": "1, 1:1.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:3r, | 9, 10.5:12, 10.5:12r, 10.5:12, 10.5:12r, 10.5:11.5, | 16:16.5, 18.5:20r, 18.5:20, 18.5:20r, 18.5:20, 18.5:20r, | 25, 25:25.5, 26.5:28r, 26.5:28, 26.5:28r, 26.5:28, 31.5:32",
-        "scale": "1/8, 1/16",
-        "scale_d": 0.125,
-        "weight": 2
-    },
-    "staccato reverese syncopated B": {
-        "pattern": "1, 1:1.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:3r, | 9, 2.5:4, 2.5:4r, 2.5:4, 2.5:4r, 2.5:3.5, | 16:16.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 2.5:4r, | 25, 25:25.5, 2.5:4r, 2.5:4, 2.5:4r, 2.5:4, 31.5:32",
-        "scale": "1/8, 1/16",
-        "scale_d": 0.125,
-        "weight": 2
-    },
-    "staccato reverese syncopated C": {
-        "pattern": "1, 1:1.5, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, 2.5:3, | 9, 2.5:4r, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, | 16:17.5, 2.5:4r, 2.5:4s2,2.5:4s2r, 2.5:4, 2.5:4r, | 24:25.5, 2.5:4, 2.5:4r,  2.5:4s2,2.5:4s2r, 2.5:4, 31.5:32r",
-        "scale": "1/8, 1/16",
-        "scale_d": 0.125,
-        "weight": 2
-    },
-    "syncopated effect": {
-        "pattern": "1s2, 1s2r, 2, 3, 4",
-        "scale": 0.375,
-        "weight": 1
-    },
-    "darkstep": {
-        "pattern": "1,1,3,1, | 1,7,1,1, | 11,9,9,11, | 9,9,15,16",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 4
-    },
-    "darkstep long": {
-        "pattern": "1,1,3,1, | 1,7,1,1, | 11,9,9,11, | 9,9,15,9, | 17,19,17,17, | 19,17,17,23, | 25,25,27,25, | 25,31,25,32",
-        "scale": 0.5,
-        "normalize": true,
-        "weight": 4
-    },
-    "darkstep fast": {
-        "pattern": "1,1,5,1, | 1,13,1,1, | 21,17,17,21, | 17,17,29,32",
-        "scale": 0.25,
-        "normalize": true,
-        "weight": 4
-    },
-    "4-3 time": {
-        "pattern": "0:2/3, 1:5/3, 1:5/3",
-        "scale": "2, 1, 0.5, 0.25",
-        "scale_d": 0.5,
-        "weight": 4
-    },
-    "4-7 time A": {
-        "pattern": "1, 2, 3, 3:3.5",
-        "scale": "2, 1, 0.5",
-        "scale_d": 1,
-        "weight": 6
-    },
-    "4-7 time B": {
-        "pattern": "1, 2, 3, 3:3.25, 3.75:4, 5,5:5.5, 7, 8",
-        "scale": "2, 1, 0.5",
-        "scale_d": 1,
-        "weight": 6
-    },
-    "Stray & Halogenix - Poison": {
-        "pattern": "0:1/3, 0:1/3, 1:4/3, 1:4/3, 2:7/3, 2:7/3, 3:10/3, 3:10/3, 1/3:2/3, 4/3:5/3, 10/3:4",
-        "scale": "1",
-        "normalize": true,
-        "scale_d": 1,
-        "weight": 5
-    },
-    "Venetian Snares - Szamar Madar": {
-        "pattern": "1, 2, 3, 4, 4, 1, 2, 3, 1, 1v0, 1v0, 1, 7, 8,|9, 10, 11, 12, 13, 14, 15, 16, 15, 10, 10, 10, 11, 16,|17, 18, 19, 20, 20, 17, 18, 19, 20, 20, 17, 17v0, 23, 24,|25, 25:25.5, 24:24.5, 27, 25, 28, 25, 31, 24:24.5, 27.5:28, 24:24.5, 27.5:28, 25, 25, 25, 31, 32",
-        "scale": "0.5",
-        "scale_d": 0.5,
-        "weight": 5
-    },
-    "effect - octave up": {
-        "pattern": "1s2,1s2",
-        "scale": 0.01,
-        "weight": 0.000000001
-    },
-    "effect - octave down": {
-        "pattern": "0:0.5s0.5",
-        "scale": 0.01,
-        "weight": 0.000000001
-    },
-    "effect - speed 2x": {
-        "pattern": "1,2!",
-        "scale": 0.01,
-        "weight": 0.000000001
-    },
-    "effect - speed 0.5x": {
-        "pattern": "1,1",
-        "scale": 0.01,
-        "weight": 0.000000001
-    },
-    "effect - robot": {
-        "pattern": "1,1,1,1,1,1,1,1,8!",
-        "scale": 0.01,
-        "weight": 0.000000001
-    },
-    "hardcore": {
-        "1": {
-            "type": "sidechain"
-        },
-        "2": {
-            "type": "beatsample",
-            "filename": "samples/cowbell.mp3"
-        },
-        "weight": 0.000000001
-    }
-}

requirements.txt

@@ -1,12 +0,0 @@
-cython
-mido
-numpy
-scipy
-pytest
-pyfftw
-soundfile
-ffmpeg-python
-librosa
-pedalboard
-opencv-python
-git+https://github.com/CPJKU/madmom