it would seem that a new update has been uploaded, and that would, in fact, be true, should the truth of that be evaluated. Best regards, Remington (big ounce passed away)

BeatManipulator.py

@@ -1,4 +1,6 @@
 import numpy
+numpy.set_printoptions(suppress=True)
+
 def open_audio(filename=None, lib='auto'):
     if filename is None:
         from tkinter.filedialog import askopenfilename
@@ -38,12 +40,15 @@ def open_audio(filename=None, lib='auto'):
     return audio,samplerate
 
 
-def generate_sidechain(samplerate=44100, len=0.5, curve=2, vol0=0, vol1=1, smoothing=40):
-    x=numpy.concaterate((numpy.linspace(1,0,smoothing),numpy.linspace(vol0,vol1,int(len*samplerate))**curve))
+def generate_sidechain(samplerate=44100, length=0.5, curve=2, vol0=0, vol1=1, smoothing=40) ->numpy.array:
+    x=numpy.concatenate((numpy.linspace(1,0,smoothing),numpy.linspace(vol0,vol1,int(length*samplerate))**curve))
     return(x,x)
 
 def outputfilename(output, filename, suffix='_beatswap'):
-    return output+''.join(''.join(filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+    if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
+            output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
+                return output+''.join(''.join(filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+    
 
 def generate_sine(len, freq, samplerate, volume=1):
     return numpy.sin(numpy.linspace(0, freq*3.1415926*2*len, int(len*samplerate)))*volume
@@ -55,7 +60,8 @@ def generate_square(len, freq, samplerate, volume=1):
     return ((numpy.linspace(0, freq*2*len, int(len*samplerate)))//1%2 * 2 - 1)*volume
 
 class song:
-    def __init__(self, filename=None, audio=None, samplerate=None, beatmap=None):
+    def __init__(self, filename:str=None, audio:numpy.array=None, samplerate:int=None, beatmap:list=None):
+        """song can be loaded from path to an audio file, or from a list/numpy array and samplerate. Audio array should have values from -1 to 1, multiple channels should be stacked vertically. Optionally you can provide your own beat map."""
         if filename is None:
             from tkinter.filedialog import askopenfilename
             self.filename = askopenfilename(title='select song', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
@@ -64,11 +70,13 @@ class song:
             self.filename=filename
             if audio is None or samplerate is None:
                 self.audio, self.samplerate=open_audio(self.filename)
-            self.beatmap=beatmap
+            else: self.audio, self.samplerate = audio, samplerate
+        self.beatmap=beatmap
         self.filename=self.filename.replace('\\', '/')
         self.samplerate=int(self.samplerate)
     
-    def write_audio(self, output:str, lib='auto'):
+    def write_audio(self, output:str, lib:str='auto'):
+        """"writes audio"""
         if lib=='pedalboard.io':
             if not isinstance(self.audio,numpy.ndarray): self.audio=numpy.asarray(self.audio)
             #print(audio)
@@ -82,7 +90,7 @@ class song:
             soundfile.write(output, audio, self.samplerate)
             del audio
         elif lib=='auto':
-            for i in ('soundfile', 'pedalboard.io'):
+            for i in ('pedalboard.io', 'soundfile'):
                 try: 
                     song.write_audio(self, output, i)
                     break
@@ -106,23 +114,20 @@ class song:
             while a <len( self.beatmap[:-math.ceil(scale)]):
                 b=numpy.append(b, (1-(a%1))*self.beatmap[math.floor(a)]+(a%1)*self.beatmap[math.ceil(a)])
                 a+=scale
-        self.beatmap=b
+            self.beatmap=b
 
     def analyze_beats(self, lib='madmom.BeatDetectionProcessor', caching=True, split=None):
         #if audio is None and filename is None: (audio, samplerate) = open_audio()
         if caching is True:
-            import hashlib
-            with open(self.filename, "rb") as f:
-                file_hash = hashlib.blake2b()
-                while chunk := f.read(8192):
-                    file_hash.update(chunk)
+            id=hex(len(self.audio[0]))
             import os
             if not os.path.exists('SavedBeatmaps'):
                 os.mkdir('SavedBeatmaps')
-            cacheDir="SavedBeatmaps/" + ''.join(self.filename.split('/')[-1]) + lib+"_"+file_hash.hexdigest()[:5]+'.txt'
+            cacheDir="SavedBeatmaps/" + ''.join(self.filename.split('/')[-1]) + "_"+lib+"_"+id+'.txt'
             try: 
                 self.beatmap=numpy.loadtxt(cacheDir, dtype=int)
-                return numpy.loadtxt(cacheDir, dtype=int)
+                self.bpm=numpy.average(self.beatmap)/self.samplerate
+                return
             except OSError: pass
 
         if lib.split('.')[0]=='madmom':
@@ -211,7 +216,9 @@ class song:
         if lib.split('.')[0]=='madmom':
             self.beatmap=numpy.absolute(self.beatmap-500)
             
-        if caching is True: numpy.savetxt(cacheDir, self.beatmap.astype(int))
+        if caching is True: numpy.savetxt(cacheDir, self.beatmap.astype(int), fmt='%d')
+        self.bpm=numpy.average(self.beatmap)/self.samplerate
+        self.beatmap=self.beatmap.astype(int)
 
     def audio_autotrim(self):
         n=0
@@ -238,8 +245,10 @@ class song:
 
     def beatmap_autoinsert(self):
         diff=(self.beatmap[1]-self.beatmap[0])
-        while diff<self.beatmap[0]:
+        a=0
+        while diff<self.beatmap[0] and a<100:
             self.beatmap=numpy.insert(self.beatmap, 0, self.beatmap[0]-diff)
+            a+=1
 
     def beatmap_shift(self, shift: float):
         if shift>0:
@@ -268,12 +277,13 @@ class song:
                     if i.isdigit() or i=='.' or i=='-' or i=='/' or i=='+' or i=='%': s=str(s)+str(i)
                     elif i==':':
                         if s=='': s='0'
+                        #print(s, eval(s))
                         size=max(math.ceil(float(eval(s))), size)
                         s=''
                     elif s!='': break
                 if s=='': s='0'
             if s=='': s='0'
-            size=max(size, eval(s))
+            size=max(math.ceil(float(eval(s))), size)
 
         if isinstance(self.audio,numpy.ndarray): self.audio=numpy.ndarray.tolist(self.audio)
         if self.beatmap.dtype!='int32': self.beatmap=self.beatmap.astype(int)
@@ -294,11 +304,39 @@ class song:
 
         # size, iterations are integers
         size=int(max(size//1, 1))
-        iterations=int(len(self.beatmap)//size)
+    
 
         # add beat to the end
-        self.beatmap=numpy.append(self.beatmap, len(self.audio[0]))
+        self.beatmap=numpy.unique(numpy.abs(numpy.append(self.beatmap, len(self.audio[0]))))
+
+        iterations=int(len(self.beatmap)//size)
+        
+        if 'random' in pattern[0].lower():
+            import random
+            for i in range(len(self.beatmap)):
+                choice=random.randint(1,len(self.beatmap)-1)
+                for a in range(len(self.audio)): 
+                    beat=self.audio[a][self.beatmap[choice-1]:self.beatmap[choice]-smoothing]
+                    if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
+                    result[a].extend(beat)
+            self.audio = result
+            return
         
+        if 'reverse' in pattern[0].lower():
+            for a in range(len(self.audio)): 
+                for i in list(reversed(range(len(self.beatmap))))[:-1]:
+                    beat=self.audio[a][self.beatmap[i-1]:self.beatmap[i]-smoothing]
+                    #print(self.beatmap[i-1],self.beatmap[i])
+                    #print(result[a][-1], beat[0])
+                    if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
+                    result[a].extend(beat)
+
+            self.audio = result
+            return
+                    
+        #print(len(result[0]))
+
+
         def beatswap_getnum(i: str, c: str):
             if c in i:
                 try: 
@@ -313,9 +351,9 @@ class song:
                         return z
                 except ValueError: return None
 
-        #print(size, iterations)
+        #print(len(self.beatmap), size, iterations)
         # processing
-        for j in range(iterations):
+        for j in range(iterations+1):
             for i in pattern:
                 if '!' not in i:
                     n,s,st,reverse,z=0,'',None,False,None
@@ -451,8 +489,30 @@ class song:
             try: self.audio[:,int(self.beatmap[i])-smoothing + int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i]))) : int(self.beatmap[i])-smoothing+int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i])))+int(l)]*=audio2
             except (IndexError, ValueError): break
 
-    def quick_beatswap(self, output='', pattern=None, scale=1, shift=0, start=0, end=None, autotrim=True, autoscale=False, autoinsert=False, suffix='_BeatSwap', lib='madmom.BeatDetectionProcessor'):
+    def quick_beatswap(self, output:str='', pattern:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, suffix:str='_BeatSwap', lib:str='madmom.BeatDetectionProcessor'):
+        """Generates beatmap if it isn't generated, applies beatswapping to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
+        
+        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
         
+        pattern: the beatswapping pattern.
+        
+        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
+        
+        shift: shifts the beatmap by this amount of unscaled beats
+        
+        start: position in seconds, beats before the position will not be manipulated
+        
+        end: position in seconds, same. Set to None by default.
+        
+        autotrim: trims silence in the beginning for better beat detection, True by default
+        
+        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
+        
+        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
+        
+        suffix: suffix that will be appended to the filename
+        
+        lib: beat detection library"""
         if self.beatmap is None: song.analyze_beats(self,lib=lib)
         if autotrim is True: song.audio_autotrim(self)
         save=self.beatmap
@@ -472,8 +532,32 @@ class song:
         self.beatmap=save
 
 
-    def quick_sidechain(self, output='', audio2=None, scale=1, shift=0, start=0, end=None, autotrim=True, autoscale=False, autoinsert=False, filename2=None, suffix='_Sidechain', lib='madmom.BeatDetectionProcessor'):
+    def quick_sidechain(self, output:str='', audio2:numpy.array=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, filename2:str=None, suffix:str='_Sidechain', lib:str='madmom.BeatDetectionProcessor'):
+        """Generates beatmap if it isn't generated, applies fake sidechain on each beat to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
+        
+        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
+        
+        audio2: sidechain impulse, basically a curve that the volume will be multiplied by. By default one will be generated with generate_sidechain()
+        
+        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
+        
+        shift: shifts the beatmap by this amount of unscaled beats
+        
+        start: position in seconds, beats before the position will not be manipulated
+        
+        end: position in seconds, same. Set to None by default.
+        
+        autotrim: trims silence in the beginning for better beat detection, True by default
+        
+        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
+        
+        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
+        
+        filename2: loads sidechain impulse from the file if audio2 if not specified
+
+        suffix: suffix that will be appended to the filename
         
+        lib: beat detection library"""
         if filename2 is None and audio2 is None:
             audio2=generate_sidechain()
 
@@ -498,7 +582,30 @@ class song:
         
         self.beatmap=save
 
-    def quick_beatsample(self, output='', filename2=None, scale=1, shift=0, start=0, end=None, autotrim=True, autoscale=False, autoinsert=False, audio2=None, suffix='_BeatSample', lib='madmom.BeatDetectionProcessor'):
+    def quick_beatsample(self, output:str='', filename2:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, audio2:numpy.array=None, suffix:str='_BeatSample', lib:str='madmom.BeatDetectionProcessor'):
+        """Generates beatmap if it isn't generated, adds chosen sample to each beat of the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
+        
+        output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
+        
+        filename2: path to the sample.
+        
+        scale: scales the beatmap, for example if generated beatmap is two times faster than the song you can slow it down by putting 0.5.
+        
+        shift: shifts the beatmap by this amount of unscaled beats
+        
+        start: position in seconds, beats before the position will not be manipulated
+        
+        end: position in seconds, same. Set to None by default.
+        
+        autotrim: trims silence in the beginning for better beat detection, True by default
+        
+        autoscale: scales beats so that they are between 10000 and 20000 samples long. Useful when you are processing a lot of files with similar BPMs, False by default.
+        
+        autoinsert: uses distance between beats and inserts beats at the beginning at that distance if possible. Set to False by default, sometimes it can fix shifted beatmaps and sometimes can add unwanted shift.
+        
+        suffix: suffix that will be appended to the filename
+        
+        lib: beat detection library"""
         if filename2 is None and audio2 is None:
             from tkinter.filedialog import askopenfilename
             filename2 = askopenfilename(title='select sidechain impulse', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
@@ -522,4 +629,80 @@ class song:
                 output=output+''.join(''.join(self.filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
             song.write_audio(self,output)
         self.beatmap=save
-        
+        
+    def audio_spectogram(self, hop_length:int=512):
+        self.hop_length=hop_length
+        import librosa
+        self.spectogram=librosa.feature.melspectrogram(y=self.audio, sr=self.samplerate, hop_length=hop_length)
+
+    def spectogram_audio(self):
+        import librosa
+        self.audio=librosa.feature.inverse.mel_to_audio(M=numpy.swapaxes(numpy.swapaxes(numpy.dstack(( self.spectogram[0,:,:],  self.spectogram[1,:,:])), 0, 2), 1,2), sr=self.samplerate, hop_length=self.hop_length)
+
+    def write_image(self):
+        """Turns song into an image based on beat positions. Currently semi-broken"""
+        import cv2
+        audio=self.audio[0].tolist()
+        height=len(audio)/len(self.beatmap)
+        width=len(self.beatmap)
+        height*=3
+        if height>width:
+            increase_length=int(height/width)
+            reduce_width=1
+        else: 
+            reduce_width=int(width/height)
+            increase_length=1
+        increase_length/=10
+        reduce_width*=10
+        image=[audio[0:self.beatmap[0]]]
+        maximum=len(image)
+        for i in range(len(self.beatmap)-1):
+            image.append(audio[self.beatmap[i]:self.beatmap[i+1]])
+            maximum=max(maximum,len(image[i]))
+        for i in range(len(image)):
+            image[i].extend((maximum-len(image[i]))*[0])
+            image[i]=image[i][::reduce_width]
+
+        audio=self.audio[1].tolist()
+        image2=[audio[0:self.beatmap[0]]]
+        for i in range(len(self.beatmap)-1):
+            image2.append(audio[self.beatmap[i]:self.beatmap[i+1]])
+        for i in range(len(image2)):
+            image2[i].extend((maximum-len(image2[i]))*[0])
+            image2[i]=image2[i][::reduce_width]
+            print(len(image[i]), len(image2[i]))
+
+        image=numpy.asarray(image)*255
+        image2=numpy.asarray(image2)*255
+        image3=numpy.add(image, image2)/2
+        image,image2,image3=numpy.repeat(image,increase_length,axis=0),numpy.repeat(image2,increase_length,axis=0),numpy.repeat(image3,increase_length,axis=0)
+        image=cv2.merge([image.T,image2.T, image3.T])
+
+        #image=image.astype('uint8')
+        #image=cv2.resize(image, (0,0), fx=len(image))
+        cv2.imwrite('cv2_output.png', image)
+
+def fix_beatmap(filename, lib='madmom.BeatDetectionProcessor', scale=1, shift=0):
+    track=song(filename)
+    track.analyze_beats(lib=lib)
+    track.beatmap_shift(shift)
+    track.beatmap_scale(scale)
+    id=hex(len(track.audio[0]))
+    import os
+    if not os.path.exists('SavedBeatmaps'):
+        os.mkdir('SavedBeatmaps')
+    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+id+'.txt'
+    a=input(f'Are you sure you want to overwrite {cacheDir} using scale = {scale}; shift = {shift}? ("n" to cancel): ')
+    if 'n' in a.lower(): return
+    else: numpy.savetxt(cacheDir, track.beatmap.astype(int), fmt='%d')
+
+def delete_beatmap(filename, lib='madmom.BeatDetectionProcessor'):
+    track=open_audio(filename)[0]
+    id=hex(len(track.audio[0]))
+    import os
+    if not os.path.exists('SavedBeatmaps'):
+        os.mkdir('SavedBeatmaps')
+    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+id+'.txt'
+    a=input(f'Are you sure you want to delete {cacheDir}? ("n" to cancel): ')
+    if 'n' in a.lower(): return
+    else: os.remove(cacheDir)

app.py

@@ -1,9 +1,9 @@
 import gradio as gr
 import BeatManipulator as bm
 def BeatSwap(pattern: str):
-    audio=bm.song()
-    audio.quick_beatswap(output=None, pattern=pattern)
-    return audio.audio
+    song=bm.song()
+    song.quick_beatswap(output=None, pattern=pattern)
+    return song.audio
 
 ui=gr.Interface (fn=BeatSwap,inputs="audio",outputs="audio" )
 ui.launch

requirements.txt

@@ -1,4 +1,4 @@
 cython
 numpy
 soundfile
-madmom
+git+https://github.com/CPJKU/madmom

wrapper.py

@@ -0,0 +1,116 @@
+import BeatManipulator as bm, json
+with open("presets.json", "r") as f:
+    presets=f.read()
+
+presets=json.loads(presets)
+
+def lib_test(filename,output='', samplerate=44100, lib='madmom.BeatDetectionProcessor', scale=1, shift=0):
+    '''basically a way to quickly test scale and offset'''
+    if type(filename)==str :
+        song=bm.song(filename) 
+        samplerate=song.samplerate
+    else: 
+        song=filename
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_sine(0.1, 2000, samplerate), scale=8*scale, shift=0+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_sine(0.05, 1000, samplerate), scale=8*scale, shift=1*scale+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_saw(0.05, 500, samplerate), scale=8*scale, shift=2*scale+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_saw(0.05, 250, samplerate), scale=8*scale, shift=3*scale+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_saw(0.05, 125, samplerate), scale=8*scale, shift=4*scale+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_saw(0.05, 250, samplerate), scale=8*scale, shift=5*scale+shift)
+    song.quick_beatsample(output=None, lib=lib, audio2=bm.generate_saw(0.05, 500, samplerate), scale=8*scale, shift=6*scale+shift)
+    song.quick_beatsample(output=output, suffix=' ('+lib+')',lib=lib, audio2=bm.generate_saw(0.05, 1000, samplerate), scale=8*scale, shift=7*scale+shift)
+    del song
+
+def lib_test_full(filename,samplerate):
+    '''A way to test all beat detection modules to see which one performs better.'''
+    print(filename)
+    lib_test(filename, samplerate,'madmom.BeatDetectionProcessor')
+    lib_test(filename, samplerate,'madmom.BeatDetectionProcessor.consistent')
+    #lib_test(filename, samplerate,'madmom.BeatTrackingProcessor') # better for live performances with variable BPM
+    #lib_test(filename, samplerate,'madmom.BeatTrackingProcessor.constant') # results identical to madmom.BeatDetectionProcessor
+    lib_test(filename, samplerate,'madmom.BeatTrackingProcessor.consistent')
+    lib_test(filename, samplerate,'madmom.CRFBeatDetectionProcessor')
+    lib_test(filename, samplerate,'madmom.CRFBeatDetectionProcessor.constant')
+    #lib_test(filename, samplerate,'madmom.DBNBeatTrackingProcessor') # better for live performances with variable BPM
+    lib_test(filename, samplerate,'madmom.DBNBeatTrackingProcessor.1000')
+    lib_test(filename, samplerate,'madmom.DBNDownBeatTrackingProcessor')
+    import gc
+    gc.collect()
+
+def process(song:bm.song, preset: str, scale:float, shift:float)->bm.song:
+    #print(preset)
+    if 'pattern' in preset: 
+        scale=scale*(preset['scale'] if 'scale' in preset else 1)
+        shift=shift+(preset['shift'] if 'shift' in preset else 0)
+        song.quick_beatswap(output=None, pattern=preset['pattern'], scale=scale, shift=shift)
+    elif preset['type'] =='sidechain':
+        length=preset['sc length'] if 'sc length' in preset else 0.5
+        curve=preset['sc curve'] if 'sc curve' in preset else 2
+        vol0=preset['sc vol0'] if 'sc vol0' in preset else 0
+        vol1=preset['sc vol1'] if 'sc vol1' in preset else 1
+        sidechain=bm.open_audio(preset['sc impulse'])[0] if 'sc impulse' in preset else bm.generate_sidechain(samplerate=song.samplerate, length=length, curve=curve, vol0=vol0, vol1=vol1, smoothing=40)
+        scale=scale*(preset['scale'] if 'scale' in preset else 1)
+        shift=shift+(preset['shift'] if 'shift' in preset else 0)
+        song.quick_sidechain(output=None, audio2=sidechain, scale=scale, shift=shift)
+    elif preset['type'] =='beatsample':
+        sample=preset['filename']
+        scale=scale*(preset['scale'] if 'scale' in preset else 1)
+        shift=shift+(preset['shift'] if 'shift' in preset else 0)
+        song.quick_beatsample(output=None, filename2=sample, scale=scale, shift=shift)
+    return song
+
+
+def use_preset(output:str,filename: str, preset: str, presets=presets, scale=1, shift=0, beat:str='normal', test=False):
+    song=bm.song(filename)
+    if beat=='shifted': song.quick_beatswap(output=None, pattern='1,2,3,4,5,7,6,8', scale=0.5)
+    #print(song.samplerate)
+    if preset is None:
+        weights=[]
+        for i in presets.items():
+            weights.append(i[1]['weight'])
+        import random
+        preset = random.choices(population=list(presets), weights=weights, k=1)[0]
+    name=preset
+    preset=presets[preset]
+    if test is True: 
+        testsong=bm.song(filename=filename, audio=song.audio, samplerate=song.samplerate)
+        lib_test(testsong, output, samplerate=testsong.samplerate)
+        del testsong
+    #print(name, preset)
+    if '1' in preset:
+        for i in preset:
+            if type(preset[i])==dict:song=process(song, preset[i], scale=scale, shift=shift)
+    else: song=process(song, preset,scale=scale,shift=shift)
+    song.write_audio(output=bm.outputfilename(output, filename, suffix=' ('+name+')'))
+    
+def all(output:str,filename: str, presets:dict=presets, scale=1, shift=0, test=True):
+    if test is True: 
+        testsong=bm.song(filename=filename)
+        lib_test(testsong, output, samplerate=testsong.samplerate)
+        del testsong
+    for i in presets:
+        use_preset(output, filename, preset=i, presets=presets, scale=scale, shift=shift, test=False)
+
+
+
+# ___ my stuff ___
+
+import random, os
+filename='F:/Stuff/Music/Tracks/Ivlril - 2.00.mp3'
+#filename = 'F:/Stuff/Music/Tracks/'+random.choice(os.listdir("F:\Stuff\Music\Tracks"))
+
+scale=1
+shift=0
+test=False
+
+#bm.fix_beatmap(filename, scale=0.25, shift=-0.25)
+#lib_test(filename, scale=0.25, shift=-0.25)
+
+#use_preset ('', filename, 'jungle B', scale=scale, shift=shift, beat='normal', test=test)
+#use_preset ('', filename, None, scale=scale, shift=shift, test=False)
+all('',filename, scale=1, shift=0, test=test)
+
+#song=bm.song(filename)
+#song.analyze_beats()
+#song.write_image()
+#song.quick_beatswap('', 'random', 0.125, 0, autoinsert=False)