Duplicate from dpe1/beat_manipulator

Co-authored-by: Ivan Nikishev <dpe1@users.noreply.huggingface.co>

.gitignore

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

README.md

@@ -0,0 +1,13 @@
+---
+title: BeatManipulator
+emoji: 🥁
+colorFrom: blue
+colorTo: blue
+sdk: gradio
+sdk_version: 3.11.0
+app_file: app.py
+pinned: true
+license: cc-by-nc-sa-4.0
+duplicated_from: dpe1/beat_manipulator
+---
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,123 @@
+import gradio as gr, numpy as np
+from gradio.components import Audio, Textbox, Checkbox, Image
+import beat_manipulator as bm
+import cv2
+
+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}')
+    if pattern == '' or pattern is None: pattern = 'test'
+    if caching is not False: caching == True
+    if variableBPM is not True: variableBPM == False
+    try:
+        scale=bm.utils._safer_eval(scale)
+    except: scale = 1
+    try:
+        shift=bm.utils._safer_eval(shift)
+    except: shift = 0
+    if scale <0: scale = -scale
+    if scale < 0.02: scale = 0.02
+    print('Loading auidofile...')
+    if audiofile is not None:
+        try:
+            song=bm.song(audio=audiofile,log=False)
+        except Exception as e:
+            print(f'Failed to load audio, retrying: {e}')
+            song=bm.song(audio=audiofile, log=False)
+    else: 
+        print(f'Audiofile is {audiofile}')
+        return
+    try:
+        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.path = '.'.join(song.path.split('.')[:-1])[:-8]+'.'+song.path.split('.')[-1]
+    print(f'path: {song.path}')
+    print('Generating beatmap...')
+    song.beatmap_generate(lib=lib, caching=caching)
+    song.beatmap_shift(shift)
+    song.beatmap_scale(scale)
+    print('Generating image...')
+    try:
+        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.rot90(np.clip(cv2.resize(image, (y,y), interpolation=cv2.INTER_NEAREST), -1, 1))
+        #print(image)
+    except Exception as e: 
+        print(f'Image generation failed: {e}')
+        image = np.asarray([[0.5,-0.5],[-0.5,0.5]])
+    print('Beatswapping...')
+    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.sr, song.audio), image)
+
+audiofile=Audio(source='upload', type='filepath')
+patternbox = Textbox(label="Pattern:", placeholder="1, 3, 2, 4!", value="1, 2>0.5, 3, 4>0.5, 5, 6>0.5, 3, 4>0.5, 7, 8", 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')
+
+gr.Interface (fn=BeatSwap,inputs=[audiofile,patternbox,scalebox,shiftbox, cachebox, beatdetectionbox],outputs=[Audio(type='numpy'), Image(type='numpy')],theme="default",
+title = "Stunlocked's Beat Manipulator"
+,description = """Remix music using AI-powered beat detection and advanced beat swapping. Make \"every other beat is missing\" remixes, or completely change beat of the song. 
+
+Github - https://github.com/stunlocked1/beat_manipulator. 
+
+Colab version - https://colab.research.google.com/drive/1gEsZCCh2zMKqLmaGH5BPPLrImhEGVhv3?usp=sharing"""
+,article="""# <h1><p style='text-align: center'><a href='https://github.com/stunlocked1/beat_manipulator' target='_blank'>Github</a></p></h1>
+### Basic usage
+Upload your audio, enter the beat swapping pattern, change scale and shift if needed, and run it.
+
+### pattern syntax
+patterns are sequences of **beats**, separated by **commas** or other separators. You can use spaces freely in patterns to make them look prettier.
+- `1, 3, 2, 4` - swap 2nd and 3rd beat every four beats. Repeats every four beats because `4` is the biggest number in it.
+- `1, 3, 4` - skip 2nd beat every four beats
+- `1, 2, 3, 4!` - skip 4th beat every four beats. `!` skips the beat.
+
+**slicing:**
+- `1>0.5` - plays first half of 1st beat
+- `1<0.5` - plays last half of 1st beat
+- `1 > 1/3, 2, 3, 4` - every four beats, plays first third of the first beat - you can use math expressions anywhere in your pattern.
+- also instead of slicing beats you can use a smaller `scale` parameter to make more precise beat edits 
+
+**merging beats:**
+- `1; 2, 3, 4` - every four beats, play 1st and 2nd beats at the same time.
+
+**effects:**
+- `1, 2r` - 2nd beat will be reversed
+- `1, 2s0.5` - 2nd beat will be played at 0.5x speed
+- `1, 2d10` - 2nd beat will have 8-bit effect (downsampled)
+
+You can do much more with the syntax - shuffle/randomize beats, use samples, mix two songs, etc. Syntax is described in detail at https://github.com/stunlocked1/beat_manipulator
+### 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`.
+
+### Changelog:
+- play two beats at the same time by using `;` instead of `,`
+- significantly reduced clicking
+- shuffle and randomize beats
+- gradient effect, similar to high pass
+- add samples to beats
+- use beats from other songs
+
+### My soundcloud https://soundcloud.com/stunlocked
+"""
+ ).launch(share=False)

beat_manipulator/__init__.py

@@ -0,0 +1,2 @@
+from .main import *
+from . import beatmap, effects, image, io, metrics, presets, osu, utils

beat_manipulator/beatmap.py

@@ -0,0 +1,195 @@
+import numpy as np
+from . import utils
+
+
+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 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(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(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(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(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(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(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(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(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(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(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)
+            from madmom.audio.spectrogram import LogarithmicSpectrogramProcessor, SpectrogramDifferenceProcessor, MultiBandSpectrogramProcessor
+            from madmom.processors import SequentialProcessor
+            log = LogarithmicSpectrogramProcessor()
+            diff = SpectrogramDifferenceProcessor(positive_diffs=True)
+            mb = MultiBandSpectrogramProcessor(crossover_frequencies=[270])
+            pre_proc = SequentialProcessor([log, diff, mb])
+            act = pre_proc(madmom.audio.signal.Signal(audio.T, sr))
+            beatmap= proc(act)*sr
+            beatmap=beatmap[:,0]
+        elif lib=='madmom.DBNBarTrackingProcessor': #broken
+            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(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=audio[0], sr=sr, hop_length=512)
+            beatmap = librosa.frames_to_samples(beat_frames[1])
+        
+        # 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)}`'
+    
+    if adjust == 0: adjust = None
+
+    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}`")
+

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/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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,531 @@
+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
+
+
+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 = f'unknown_{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: return self.beatmap[int(a)]
+            a_int = int(int(a)//1)
+            start = self.beatmap[a_int]
+            return int(start + a_dec * (self.beatmap[a_int+1] - start))
+        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)
+                return result if isinstance(self.audio, np.ndarray) else 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, limit_beats=10000, limit_length = 52920000):
+        
+        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)
+
+
+        stop = False
+        total_length = 0
+        
+        # loop over pattern until it reaches the last beat
+        while n*pattern_length <= len(self.beatmap):
+            n+=1
+
+            if stop is True: break
+
+            # 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):
+
+                # check if beats limit has been reached
+                if limit_beats is not None and len(result) >= limit_beats:
+                    stop = True
+                    break
+
+                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_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)
+
+                # clip beat to -1, 1
+                beat = np.clip(beat, -1, 1)
+
+                # checks if length limit has been reached
+                if limit_length is not None:
+                    total_length += len(beat[0])
+                    if total_length>= limit_length: 
+                        stop = True
+                        break
+                
+                # 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
+                    
+                    # 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:
+                        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/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/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

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

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

requirements.txt

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