yes mr krabs

app.py

@@ -1,9 +1,60 @@
-import gradio as gr
-import BeatManipulator as bm
-def BeatSwap(pattern: str):
-    song=bm.song()
-    song.quick_beatswap(output=None, pattern=pattern)
-    return song.audio
-
-ui=gr.Interface (fn=BeatSwap,inputs="audio",outputs="audio",theme="default" )
-ui.launch
+import gradio as gr, numpy as np
+from gradio.components import Audio, Textbox, Checkbox
+import beat_manipulator as bm
+def BeatSwap(audiofile, pattern: str, scale:float, shift:float, caching:bool):
+    scale=float(scale)
+    shift=float(shift)
+    song=bm.song(path=audiofile, filename=audiofile.split('.')[-2][:-8]+'.'+audiofile.split('.')[-1], caching=caching)
+    song.quick_beatswap(output=None, pattern=pattern, scale=scale, shift=shift)
+    #song.write_audio(output=bm.outputfilename('',song.filename, suffix=' (beatswap)'))
+    return (song.samplerate, np.asarray(song.audio).T)
+
+audiofile=Audio(source='upload', type='filepath')
+patternbox = Textbox(label="Pattern:", placeholder="1, 3, 2r, 4d8", lines=1)
+scalebox = Textbox(value=1, label="Beatmap scale, beatmap's beats per minute will be multiplied by this:", 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 beatmaps. If True, a text file with the beatmap will be saved to the server (your PC if you are running locally), so that beatswapping for the second time doesn't have to generate the beatmap again. 
+
+Text file will be named after your file, and will only contain a list of numbers of positions of each beat. Note: I have no idea if this actually works on Hugging Face.""")
+
+gr.Interface (fn=BeatSwap,inputs=[audiofile,patternbox,scalebox,shiftbox, cachebox],outputs=Audio(type='numpy'),theme="default",
+title = "Stunlocked's Beat Manipulator"
+,description = "Remix music via AI-powered beat detection and advanced beat swapping. https://github.com/stunlocked1/BeatManipulator/blob/main/presets.json"
+,article="""# <h1><p style='text-align: center'><a href='https://github.com/stunlocked1/BeatManipulator' target='_blank'>Github</a></p></h1>
+
+# Basic usage
+
+Upload your audio, enter the beat swapping pattern, change scale and shift if needed, and run the app.
+
+You can test where each beat is by writing `test` into the `pattern` field, which will put cowbells on each beat. Beatmap can sometimes be shifted, for example 0.5 beats forward, so this use scale and shift to adjust it.
+
+Feel free to use complex patterns and very low scales - most of the computation time is in detecting beats, not swapping them.
+
+# Pattern syntax
+
+Patterns are sequences of numbers or ranges, separated by `,`. Numbers and ranges can be followed by letters that apply effects to them. Spaces can be freely used for formatting as they will be ignored. Any other character that isnt used in the syntax can also be used for formatting but only between beats, not inside them.
+- `1, 3, 2, 4` - every 4 beats, swap 2nd and 3rd beat. This pattern loops every 4 beats, because 4 is the biggest number in it.
+- `!` after a number sets length of the pattern (beat isnt played). `1, 3, 2, 4, 8!` - every 8 beats, swap 2nd and 3rd beat, and 5-8 beats will be skipped.
+- `1, 3, 4` - skip 2nd beat
+- `1, 2, 2, 4` - repeat 2nd beat
+- `1, 1:1.5, 4` - play a range of beats. `0:0.5` means first half of 1st beat. Keep that in mind, to play first half of 5th beat, you do `4:4.5`, not `5:5.5`. `1` is equivalent to `0:1`. `1.5` is equivalent to `0.5:1.5`. `1,2,3,4` is `0:4`.
+- `1, 0:1/3, 0:1/3, 2/3:1` - you can use expressions with `+`, `-`, `*`, `/`.
+- `?` after a beat makes that number not count for looping. `1, 2, 3, 4!, 8?` - every 4 beats, 4th beat is replaced with 8th beat.
+- `v` + number - controls volume of that beat. `1v2` means 200% volume, `1v1/3` means 33.33% volume, etc.
+- `r` after a beat reverses that beat. `1r, 2` - every two beats first beat will be reversed
+- another way to reverse - `4:0` is reversed `0:4`.
+- `s` + number - changes speed and pitch of that beat. 2 will be 2 times faster, 1/2 will be 2 times slower. Note: Only integers or 1/integer numbers are supported, everything else will be rounded.
+- `c` - swaps left and right channels of the beat. If followed by 0, mutes left channel instead, 1 - right channel.
+- `b` + number - bitcrush. The higher the number, the stronger the effect. Barely noticeable at values less then 1
+- `d` + number - downsample (8-bit sound). The higher the number, the stronger the effect. Starts being noticeable at 3, good 8-bit sounding values are around 8+.
+- `t` + number - saturation
+- you can combine stuff like `0:1/3d8v2cr` - that line means 0:1/3 beat will be downsampled, 200% volume, swapped channels, and reversed
+
+there are certain commands you can write in pattern instead of the actual pattern:
+- `random` - each beat will be randomly selected from all beats, basically similar to shuffling all beats
+- `reverse` - reverses the order of all beats
+- `test` - test beat detection by putting cowbells on each beat. The highest pitched cowbell should be on the first beat; next cowbell should be on the snare. If it is not, use scale and shift.
+
+There are also some interesting patterns there: https://github.com/stunlocked1/BeatManipulator/blob/main/presets.json. Those are meant to be used with properly adjusted shift and scale, where 1st beat is 1st kick, 2nd beat is the snare after it.
+"""
+ ).launch(share=False)

beat_manipulator/__init__.py

@@ -0,0 +1,2 @@
+from .main import *
+from . import analyze, effect, generate, image, mix, wrapper

beat_manipulator/analyze.py

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

beat_manipulator/beatmap.py

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

beat_manipulator/effect.py

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

beat_manipulator/generate.py

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

beat_manipulator/image.py

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

BeatManipulator.py → beat_manipulator/main.py

@@ -1,14 +1,33 @@
 import numpy
 numpy.set_printoptions(suppress=True)
+from .beatmap import beatmap, hitmap
+from .image import spectogram, beat_image
 
-def open_audio(filename=None, lib='auto'):
+def _safer_eval(string:str) -> float:
+    if isinstance(string, str): 
+        #print(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
+        string = eval(''.join([i for i in string if i.isdecimal() or i in '.+-*/']))
+    return string
+
+def open_audio(filename=None, lib='auto') -> numpy.ndarray:
+    """Opens audio from path, returns (audio, samplerate) tuple.
+    
+    Audio is returned as an array with normal volume range between -1, 1.
+    
+    Example of returned audio: 
+    
+    [
+        [0.35, -0.25, ... -0.15, -0.15], 
+    
+        [0.31, -0.21, ... -0.11, -0.07]
+    ]"""
     if filename is None:
         from tkinter.filedialog import askopenfilename
         filename = askopenfilename(title='select song', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
     filename=filename.replace('\\', '/')
     if lib=='pedalboard.io':
-        from pedalboard.io import AudioFile
-        with AudioFile(filename) as f:
+        import pedalboard.io
+        with pedalboard.io.AudioFile(filename) as f:
             audio = f.read(f.frames)
             samplerate = f.samplerate
     elif lib=='librosa':
@@ -35,64 +54,162 @@ def open_audio(filename=None, lib='auto'):
                 audio,samplerate=open_audio(filename, i)
                 break
             except Exception as e:
-                print(e)
-    if len(audio)<2: audio=[audio,audio]
+                print(f'open_audio with {i}: {e}')
+    if len(audio)<2: audio=[audio]
     return audio,samplerate
 
 
-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'):
+def _outputfilename(output, filename, suffix=' (beatswap)', ext='mp3'):
     if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
             output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                return output+''.join(''.join(filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+                return output+'.'.join(''.join(filename.split('/')[-1]).split('.')[:-1])+suffix+'.'+ext
     
+class song:
+    def __init__(self, path:str=None, audio:numpy.array=None, samplerate:int=None, bmap:list=None, caching=True, filename=None, copied=False, log=True):
+        """song can be loaded from path to an audio file, or from a list/numpy array and samplerate. Audio array should have values from -1 to 1, multiple channels should be stacked vertically. Optionally you can provide your own beat map.
+        
+        Song object has the following attributes:
 
-def generate_sine(len, freq, samplerate, volume=1):
-    return numpy.sin(numpy.linspace(0, freq*3.1415926*2*len, int(len*samplerate)))*volume
+        path - file system path to load the audio file from. Can be absolute or relative.
+        
+        audio - either a numpy array with shape=(channels, values) or a list with two lists. Audio is converted to list for certain operations to improve performance.
+        
+        samplerate - integer, for example 44100. Determined automatically when audio is loaded from a path.
 
-def generate_saw(len, freq, samplerate, volume=1):
-    return (numpy.linspace(0, freq*2*len, int(len*samplerate))%2 - 1)*volume
+        bmap - list of integers, with positions of each beat in samples.
 
-def generate_square(len, freq, samplerate, volume=1):
-    return ((numpy.linspace(0, freq*2*len, int(len*samplerate)))//1%2 * 2 - 1)*volume
+        caching = True - if True, generated beatmaps will be saved to SavedBeatmaps folder and loaded when the same audio file is opened again, instead of generating beatmap each time.
 
-class song:
-    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")])
-            self.audio, self.samplerate=open_audio(self.filename)
+        log = True - if True, minimal info about all operations will be printed.
+        """
+        assert not (audio is not None and samplerate is None), 'If audio is provided, samplerate should be provided as well, for example samplerate=44100'
+        
+        self.audio=audio
+        self.samplerate=samplerate
+        
+        # ask for a path if audio isn't specified
+        if path is None and filename is None:
+            if audio is None:
+                from tkinter.filedialog import askopenfilename
+                self.path = askopenfilename(title='select song')
+            else:
+                # generate unique identifier for storing beatmap cache
+                audio_id = numpy.sum(audio[0][1000:2000]) if len(audio<2000) else numpy.sum(audio[1000:2000])
+                self.filename = 'unknown ' + str(hex(int(audio_id))) + ' ' + str(hex(int((audio_id%1)*(10**18))))
+                self.path = self.filename
+                print(self.filename)
         else: 
-            self.filename=filename
-            if audio is None or samplerate is None:
-                self.audio, self.samplerate=open_audio(self.filename)
-            else: self.audio, self.samplerate = audio, samplerate
-        self.beatmap=beatmap
-        self.filename=self.filename.replace('\\', '/')
+            if path is None: self.path=filename
+            else: self.path=path
+
+        # load from zip
+        if self.path.lower().endswith('.zip'): 
+            import shutil,os
+            if os.path.exists('BeatManipulator_TEMP'): shutil.rmtree('BeatManipulator_TEMP')
+            os.mkdir('BeatManipulator_TEMP')
+            shutil.unpack_archive(self.path, 'BeatManipulator_TEMP')
+            for root,dirs,files in os.walk('BeatManipulator_TEMP'):
+                for fname in files:
+                    if fname.lower().endswith('.mp3') or fname.lower().endswith('.wav') or fname.lower().endswith('.ogg') or fname.lower().endswith('.flac'):
+                        self.audio, self.samplerate=open_audio(root.replace('\\','/')+'/'+fname)
+                        stop=True
+                        break
+                if stop is True: break
+            shutil.rmtree('BeatManipulator_TEMP')
+    
+        # open audio from path
+        if self.audio is None or self.samplerate is None:
+            self.audio, self.samplerate=open_audio(self.path)
+
+        # mono to stereo
+        if len(self.audio)>16:
+            self.audio=numpy.asarray((self.audio,self.audio))
+
+        # stuff
+        self.path=self.path.replace('\\', '/')
+        if filename is None: self.filename=self.path.split('/')[-1]
+        else: self.filename=filename.replace('\\', '/').split('/')[-1]
         self.samplerate=int(self.samplerate)
+
+        # artist,  title
+        if ' - ' in self.path.split('/')[-1]:
+            self.artist = self.path.split('/')[-1].split(' - ')[0]
+            self.title= '.'.join(self.path.split('/')[-1].split(' - ')[1].split('.')[:-1])
+        elif path is not None or filename is not None:
+            self.title=''.join(self.path.split('/')[-1].split('.')[:-1])
+            self.artist=None
+        else:
+            self.title = None
+            self.artist = None
+        self.caching=caching
+        self.log=log
+        if copied is False and self.log is True: 
+            if self.artist is not None or self.title is not None: print(f'Loaded {self.artist} - {self.title}; ')
+            elif filename is not None: print(f'Loaded {self.filename}; ')
+            elif path is not None: print(f'Loaded {self.path}; ')
+            else: print(f'Loaded audio file; ')
+        self.audio_isarray = True
+        
+        if isinstance(bmap, beatmap): self.beatmap=bmap
+        else: self.beatmap = beatmap(beatmap = bmap, audio= self.audio, samplerate=self.samplerate, filename=self.filename, caching = caching, log=log, path=self.path, artist=self.artist, title=self.title)
+        self.hitmap = hitmap(audio= self.audio, samplerate=self.samplerate, filename=self.filename, caching = caching, log=log, path=self.path, artist=self.artist, title=self.title)
+        self.spectogram = spectogram(audio=self.audio, samplerate=self.samplerate, beatmap=self.beatmap, log=self.log)
+        self.beat_image = beat_image(audio=self.audio, samplerate=self.samplerate, beatmap=self.beatmap, log=self.log)
+    
+    @property
+    def bm(self):
+        return self.beatmap.beatmap
+    
+    @property
+    def hm(self):
+        return self.hitmap.beatmap
+    
+    def _printlog(self, string, end=None, force = False, forcei = False):
+        if (self.log is True or force is True) and forcei is False:
+            if end is None: print(string)
+            else:print(string,end=end)
     
-    def write_audio(self, output:str, lib:str='auto'):
-        """"writes audio"""
+    def _audio_tolist(self, force = True):
+        if self.audio_isarray:
+            self.audio = self.audio.tolist()
+            self.audio_isarray = False
+        elif force is True: 
+            self.audio = self.audio.tolist()
+            self.audio_isarray = False
+
+    def _audio_toarray(self, force = True):
+        if not self.audio_isarray:
+            self.audio = numpy.asarray(self.audio)
+            self.audio_isarray = True
+        elif force is True: 
+            self.audio = numpy.asarray(self.audio)
+            self.audio_isarray = True
+            
+    def _update(self):
+        self.beatmap.audio = self.audio
+        self.hitmap.audio = self.audio
+        self.spectogram.audio = self.audio
+        self.beat_image.audio = self.audio
+        self.beat_image.beatmap = self.bm
+
+    def write(self, output:str, lib:str='auto', libs=('pedalboard.io', 'soundfile')):
+        """"writes audio to path specified by output. Path should end with file extension, for example `folder/audio.mp3`"""
+        self._audio_toarray()
+        if lib!='auto': self._printlog(f'writing {output} with {lib}')
         if lib=='pedalboard.io':
-            if not isinstance(self.audio,numpy.ndarray): self.audio=numpy.asarray(self.audio)
             #print(audio)
-            from pedalboard.io import AudioFile
-            with AudioFile(output, 'w', self.samplerate, self.audio.shape[0]) as f:
+            import pedalboard.io
+            with pedalboard.io.AudioFile(output, 'w', self.samplerate, self.audio.shape[0]) as f:
                 f.write(self.audio)
         elif lib=='soundfile':
-            if not isinstance(self.audio,numpy.ndarray): self.audio=numpy.asarray(self.audio)
             audio=self.audio.T
             import soundfile
             soundfile.write(output, audio, self.samplerate)
             del audio
         elif lib=='auto':
-            for i in ('pedalboard.io', 'soundfile'):
+            for i in libs:
                 try: 
-                    song.write_audio(self, output, i)
+                    self.write(output, i)
                     break
                 except Exception as e:
                     print(e)
@@ -106,163 +223,38 @@ class song:
         #         output = output + '.' + format
         #     song.export(output, format=format)
 
-    def beatmap_scale(self, scale:float):
-        import math
-        if scale!=1:
-            a=0
-            b=numpy.array([])
-            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
-
-    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:
-            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+"_"+id+'.txt'
-            try: 
-                self.beatmap=numpy.loadtxt(cacheDir, dtype=int)
-                self.bpm=numpy.average(self.beatmap)/self.samplerate
-                return
-            except OSError: pass
-
-        if lib.split('.')[0]=='madmom':
-            from collections.abc import MutableMapping, MutableSequence
-            import madmom
-        if lib=='madmom.BeatTrackingProcessor':
-            proc = madmom.features.beats.BeatTrackingProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        if lib=='madmom.BeatTrackingProcessor.constant':
-            proc = madmom.features.beats.BeatTrackingProcessor(fps=100, look_ahead=None)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        if lib=='madmom.BeatTrackingProcessor.consistent':
-            proc = madmom.features.beats.BeatTrackingProcessor(fps=100, look_ahead=None, look_aside=0)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.BeatDetectionProcessor':
-            proc = madmom.features.beats.BeatDetectionProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.BeatDetectionProcessor.consistent':
-            proc = madmom.features.beats.BeatDetectionProcessor(fps=100, look_aside=0)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.CRFBeatDetectionProcessor':
-            proc = madmom.features.beats.CRFBeatDetectionProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.CRFBeatDetectionProcessor.constant':
-            proc = madmom.features.beats.CRFBeatDetectionProcessor(fps=100, use_factors=True, factors=[0.5, 1, 2])
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.DBNBeatTrackingProcessor':
-            proc = madmom.features.beats.DBNBeatTrackingProcessor(fps=100)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.DBNBeatTrackingProcessor.1000':
-            proc = madmom.features.beats.DBNBeatTrackingProcessor(fps=100, transition_lambda=1000)
-            act = madmom.features.beats.RNNBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='madmom.MultiModelSelectionProcessor': #broken
-            proc = madmom.features.beats.RNNBeatProcessor(post_processor=None)
-            predictions = proc(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            mm_proc = madmom.features.beats.MultiModelSelectionProcessor(num_ref_predictions=None)
-            self.beatmap= numpy.sort(mm_proc(predictions)*self.samplerate)
-        elif lib=='madmom.DBNDownBeatTrackingProcessor':
-            proc = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[4], fps=100)
-            act = madmom.features.downbeats.RNNDownBeatProcessor()(madmom.audio.signal.Signal(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-            self.beatmap=self.beatmap[:,0]
-        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(self.audio.T, self.samplerate))
-            self.beatmap= proc(act)*self.samplerate
-            self.beatmap=self.beatmap[:,0]
-        elif lib=='madmom.DBNBarTrackingProcessor': #broken
-            beats = song.analyze_beats(self,lib='madmom.DBNBeatTrackingProcessor', caching = caching)
-            proc = madmom.features.downbeats.DBNBarTrackingProcessor(beats_per_bar=[4], fps=100)
-            act = madmom.features.downbeats.RNNBarProcessor()(((madmom.audio.signal.Signal(self.audio.T, self.samplerate)), beats))
-            self.beatmap= proc(act)*self.samplerate
-        elif lib=='librosa': #broken in 3.9, works in 3.8
-            import librosa
-            beat_frames = librosa.beat.beat_track(y=self.audio[0], sr=self.samplerate,hop_length=512)
-            self.beatmap = librosa.frames_to_samples(beat_frames[1])
-        # elif lib=='BeatNet':
-        #     from BeatNet.BeatNet import BeatNet # doesn't seem to work well for some reason
-        #     estimator = BeatNet(1, mode='offline', inference_model='DBN', plot=[], thread=False)
-        #     beatmap = estimator.process(filename)
-        #     beatmap=beatmap[:,0]*samplerate
-        # elif lib=='jump-reward-inference': # doesn't seem to work well for some reason
-        #     from jump_reward_inference.joint_tracker import joint_inference
-        #     estimator = joint_inference(1, plot=False)
-        #     beatmap = estimator.process(filename)
-        #     beatmap=beatmap[:,0]*samplerate
-
-        elif lib=='split':
-            self.beatmap= list(range(0, len(self.audio), len(self.audio)//split))
-        if lib.split('.')[0]=='madmom':
-            self.beatmap=numpy.absolute(self.beatmap-500)
-            
-        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):
+    # def generate_beatmap(self, lib='madmom.BeatDetectionProcessor', split=None):
+    #     self.beatmap = beatmap(beatmap=None, samplerate=self.samplerate, length=len(self.audio[0]),caching=self.caching,log=self.log)
+    #     self.beatmap.generate(audio=self.audio, samplerate=self.samplerate, lib=lib, caching=self.caching, split=split, filename=self.filename)
+
+    # def generate_hitmap(self, lib='madmom.BeatDetectionProcessor'):
+    #     self.hitmap=hitmap(beatmap=None, samplerate=self.samplerate, length = len(self.audio), caching=self.caching, log=self.log)
+    #     self.hitmap.generate(audio=self.audio, samplerate=self.samplerate, lib=lib, caching=self.caching, filename=self.filename)
+
+    def generate_osu_beatmap(self, difficulties = [0.2, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01, 0.005]):
+        self.hitmap.osu(self, difficulties = difficulties)
+        import shutil, os
+        if self.path is not None: 
+            shutil.copyfile(self.path, 'BeatManipulator_TEMP/'+self.path.split('/')[-1])
+        else: self.write('BeatManipulator_TEMP/audio.mp3')
+        shutil.make_archive('BeatManipulator_TEMP', 'zip', 'BeatManipulator_TEMP')
+        os.rename('BeatManipulator_TEMP.zip', _outputfilename('', self.path, '_'+self.hm, 'osz'))
+        shutil.rmtree('BeatManipulator_TEMP')
+
+    def autotrim(self):
+        self._printlog(f'autotrimming; ')
         n=0
         for i in self.audio[0]:
             if i>=0.0001:break
             n+=1
+        if type(self.audio) is tuple or list: self.audio = numpy.asarray(self.audio)
         self.audio = numpy.asarray([self.audio[0,n:], self.audio[1,n:]])
-        #print(beatmap)
-        if self.beatmap is not None: 
-            self.beatmap=numpy.absolute(self.beatmap-n)
-        else: 
-            print('It is recommended to only use autotrim after computing the beatmap')
-
-    def beatmap_autoscale(self):
-        bpm=(self.beatmap[-1]-self.beatmap[0])/(len(self.beatmap)-1)
-        #print('BPM =', (bpm/samplerate) * 240, bpm)
-        if bpm>=160000: scale=1/8
-        elif (bpm)>=80000: scale=1/4
-        elif (bpm)>=40000: scale=1/2
-        elif (bpm)<=20000: scale=2
-        elif (bpm)<=10000: scale=4
-        elif (bpm)<=5000: scale=8
-        song.beatmap_scale(self,scale)        
-
-    def beatmap_autoinsert(self):
-        diff=(self.beatmap[1]-self.beatmap[0])
-        a=0
-        while diff<self.beatmap[0] and a<100:
-            self.beatmap=numpy.insert(self.beatmap, 0, self.beatmap[0]-diff)
-            a+=1
-
-    def beatmap_shift(self, shift: float):
-        if shift>0:
-            for i in range(len(self.beatmap)-1):
-                self.beatmap[i] = self.beatmap[i] + shift * (self.beatmap[i+1] - self.beatmap[i])
-        elif shift<0:
-            for i in reversed(range(len(self.beatmap)-1)):
-                self.beatmap[i+1] = self.beatmap[i+1] - shift * (self.beatmap[i] - self.beatmap[i+1])
-
-    def beatmap_trim(self, start=0, end=None):
-        start*=self.samplerate
-        self.beatmap=self.beatmap[self.beatmap>=start].astype(int)
-        if end is not None: self.beatmap=self.beatmap[self.beatmap<=end].astype(int)
-
+        if self.bm is not None: 
+            self.beatmap.beatmap=numpy.absolute(self.beatmap.beatmap-n)
+        if self.hm is not None: 
+            print(self.hm)
+            self.hitmap.beatmap=numpy.absolute(self.hitmap.beatmap-n)
+        self._update()
 
     def beatswap(self, pattern: str, sep=',', smoothing=40, smoothing_mode='replace'):
         import math, numpy
@@ -270,6 +262,7 @@ class song:
         size=0    
         #cut processing??? not worth it, it is really fast anyways
         pattern=pattern.replace(' ', '').split(sep)
+        self._printlog(f"beatswapping with {' '.join(pattern)}; ")
         for j in pattern:
             s=''
             if '?' not in j:
@@ -277,66 +270,59 @@ 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)
+                        #print(s, _safer_eval(s))
+                        size=max(math.ceil(float(_safer_eval(s))), size)
                         s=''
                     elif s!='': break
                 if s=='': s='0'
             if s=='': s='0'
-            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)
-
-        #beat=[]
-        #start=audio[:beatmap[0]]
-        #end=audio[beatmap[-1]:audio[-1]]
-        #for i in range(len(beatmap)-1):
-        #    beat[i]=audio[beatmap[i]:beatmap[i+1]]
-
-        # audio is a tuple with l and r channels
-        #print(len(audio))
+            size=max(math.ceil(float(_safer_eval(s))), size)
 
+        self._audio_tolist()
+        self.beatmap._toarray()
+        # turns audio into a tuple with L and R channels
         self.audio=(self.audio[0], self.audio[1])
-        #print(beatmap[0], audio[0][100])
+
+        # adds the part before the first beat
         result=(self.audio[0][:self.beatmap[0]],self.audio[1][:self.beatmap[0]])
         beat=numpy.asarray([[],[]])
 
         # size, iterations are integers
         size=int(max(size//1, 1))
     
-
-        # add beat to the end
-        self.beatmap=numpy.unique(numpy.abs(numpy.append(self.beatmap, len(self.audio[0]))))
+        self.beatmap._add_beat_to_end()
 
         iterations=int(len(self.beatmap)//size)
         
         if 'random' in pattern[0].lower():
             import random
             for i in range(len(self.beatmap)):
+
                 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)
+                    try:
+                        beat=self.audio[a][self.beatmap[choice-1]:self.beatmap[choice]-smoothing]
+                        if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
+                        result[a].extend(beat)
+                    except IndexError: pass
             self.audio = result
             return
         
         if 'reverse' in pattern[0].lower():
             for a in range(len(self.audio)): 
                 for i in list(reversed(range(len(self.beatmap))))[:-1]:
-                    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)
+                    try:
+                        beat=self.audio[a][self.beatmap[i-1]:self.beatmap[i]-smoothing]
+                        #print(self.beatmap[i-1],self.beatmap[i])
+                        #print(result[a][-1], beat[0])
+                        if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[0],smoothing))
+                        result[a].extend(beat)
+                    except IndexError: pass
 
             self.audio = result
             return
                     
         #print(len(result[0]))
-
-
         def beatswap_getnum(i: str, c: str):
             if c in i:
                 try: 
@@ -367,8 +353,8 @@ class song:
                         
                         # If character is : - get start
                         elif s!='' and c==':':
-                            #print ('Beat start:',s,'=', eval(s),'=',int(eval(s)//1), '+',j,'*',size,'    =',int(eval(s)//1)+j*size, ',   mod=',eval(s)%1)
-                            try: st=self.beatmap[int(eval(s)//1)+j*size ] + eval(s)%1* (self.beatmap[int(eval(s)//1)+j*size +1] - self.beatmap[int(eval(s)//1)+j*size])
+                            #print ('Beat start:',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size, ',   mod=',_safer_eval(s)%1)
+                            try: st=self.beatmap[int(_safer_eval(s)//1)+j*size ] + _safer_eval(s)%1* (self.beatmap[int(_safer_eval(s)//1)+j*size +1] - self.beatmap[int(_safer_eval(s)//1)+j*size])
                             except IndexError: break
                             s=''
                         
@@ -377,18 +363,18 @@ class song:
 
                             # start already exists
                             if st is not None:
-                                #print ('Beat end:  ',s,'=', eval(s),'=',int(eval(s)//1), '+',j,'*',size,'    =',int(eval(s)//1)+j*size, ',   mod=',eval(s)%1)
+                                #print ('Beat end:  ',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size, ',   mod=',_safer_eval(s)%1)
                                 try:
-                                    s=self.beatmap[int(eval(s)//1)+j*size ] + eval(s)%1* (self.beatmap[int(eval(s)//1)+j*size +1] - self.beatmap[int(eval(s)//1)+j*size])
+                                    s=self.beatmap[int(_safer_eval(s)//1)+j*size ] + _safer_eval(s)%1* (self.beatmap[int(_safer_eval(s)//1)+j*size +1] - self.beatmap[int(_safer_eval(s)//1)+j*size])
                                     #print(s)
                                 except IndexError: break
                             else:
                                 # start doesn't exist
-                                #print ('Beat start:',s,'=', eval(s),'=',int(eval(s)//1), '+',j,'*',size,'- 1 =',int(eval(s)//1)+j*size,   ',   mod=',eval(s)%1)
-                                #print ('Beat end:  ',s,'=', eval(s),'=',int(eval(s)//1), '+',j,'*',size,'    =',int(eval(s)//1)+j*size+1, ',   mod=',eval(s)%1)
+                                #print ('Beat start:',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'- 1 =',int(_safer_eval(s)//1)+j*size,   ',   mod=',_safer_eval(s)%1)
+                                #print ('Beat end:  ',s,'=', _safer_eval(s),'=',int(_safer_eval(s)//1), '+',j,'*',size,'    =',int(_safer_eval(s)//1)+j*size+1, ',   mod=',_safer_eval(s)%1)
                                 try:
-                                    st=self.beatmap[int(eval(s)//1)+j*size-1 ] + eval(s)%1* (self.beatmap[int(eval(s)//1)+j*size +1] - self.beatmap[int(eval(s)//1)+j*size])
-                                    s=self.beatmap[int(eval(s)//1)+j*size ] + eval(s)%1* (self.beatmap[int(eval(s)//1)+j*size +1] - self.beatmap[int(eval(s)//1)+j*size])
+                                    st=self.beatmap[int(_safer_eval(s)//1)+j*size-1 ] + _safer_eval(s)%1* (self.beatmap[int(_safer_eval(s)//1)+j*size +1] - self.beatmap[int(_safer_eval(s)//1)+j*size])
+                                    s=self.beatmap[int(_safer_eval(s)//1)+j*size ] + _safer_eval(s)%1* (self.beatmap[int(_safer_eval(s)//1)+j*size +1] - self.beatmap[int(_safer_eval(s)//1)+j*size])
                                 except IndexError: break
                             
                             if st>s: 
@@ -408,25 +394,25 @@ class song:
                             z=beatswap_getnum(i,'c')
                             if z is not None:
                                 if z=='': beat[0],beat[1]=beat[1],beat[0]
-                                elif eval(z)==0:beat[0]*=0
+                                elif _safer_eval(z)==0:beat[0]*=0
                                 else:beat[1]*=0
 
                             # volume
                             z=beatswap_getnum(i,'v')
                             if z is not None:
                                 if z=='': z='0'
-                                beat*=eval(z)
+                                beat*=_safer_eval(z)
 
                             z=beatswap_getnum(i,'t')
                             if z is not None:
                                 if z=='': z='2'
-                                beat**=1/eval(z)
+                                beat**=1/_safer_eval(z)
 
                             # speed
                             z=beatswap_getnum(i,'s')
                             if z is not None:
                                 if z=='': z='2'
-                                z=eval(z)
+                                z=_safer_eval(z)
                                 if z<1: 
                                     beat=numpy.asarray((numpy.repeat(beat[0],int(1//z)),numpy.repeat(beat[1],int(1//z))))
                                 else:
@@ -436,7 +422,7 @@ class song:
                             z=beatswap_getnum(i,'b')
                             if z is not None:
                                 if z=='': z='3'
-                                z=1/eval(z)
+                                z=1/_safer_eval(z)
                                 if z<1: beat=beat*z
                                 beat=numpy.around(beat, max(int(z), 1))
                                 if z<1: beat=beat/z
@@ -445,7 +431,7 @@ class song:
                             z=beatswap_getnum(i,'d')
                             if z is not None:
                                 if z=='': z='3'
-                                z=int(eval(z))
+                                z=int(_safer_eval(z))
                                 beat=numpy.asarray((numpy.repeat(beat[0,::z],z),numpy.repeat(beat[1,::z],z)))
 
                             # convert to list
@@ -461,26 +447,52 @@ class song:
                                 #print('Adding beat... a, s, st:', a, s, st, sep=',  ')
                                 #print(result[a][-1])
                                 #print(beat[a][0])
-                                if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[a][0],smoothing))
-                                result[a].extend(beat[a])
+                                try:
+                                    if smoothing>0: result[a].extend(numpy.linspace(result[a][-1],beat[a][0],smoothing))
+                                    result[a].extend(beat[a])
+                                except IndexError: pass
                                 #print(len(result[0]))
 
                             #   
                             break
-        #print(time.process_time() - benchmark)
 
         self.audio = result
+        self._update()
 
     def beatsample(self, audio2, shift=0):
+        self._printlog(f'beatsample; ')
         try: l=len(audio2[0])
         except (TypeError, IndexError): 
             l=len(audio2)
             audio2=numpy.vstack((audio2,audio2))
         for i in range(len(self.beatmap)):
+            #print(self.beatmap[i])
             try: self.audio[:,int(self.beatmap[i]) + int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i]))) : int(self.beatmap[i])+int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i])))+int(l)]+=audio2
             except (IndexError, ValueError): pass
+        self._update()
+
+    def hitsample(self, audio2=None):
+        self._printlog(f'hitsample; ')
+        from . import generate
+        if audio2 is None:audio2=generate.saw(0.05, 1000, self.samplerate)
+        try: l=len(audio2[0])
+        except (TypeError, IndexError): 
+            l=len(audio2)
+            audio2=numpy.vstack((audio2,audio2))
+        #print(self.audio)
+        self.audio=numpy.array(self.audio).copy()
+        #print(self.audio)
+        for i in range(len(self.hitmap)):
+            try: 
+                #print('before', self.audio[:,int(self.hitmap[i])])
+                self.audio[:,int(self.hitmap[i]) : int(self.hitmap[i]+l)]+=audio2
+                #print('after ', self.audio[:,int(self.hitmap[i])])
+                #print(self.hitmap[i])
+            except (IndexError, ValueError): pass
+        self._update()
 
     def sidechain(self, audio2, shift=0, smoothing=40):
+        self._printlog(f'sidechain; ')
         try: l=len(audio2[0])
         except (TypeError, IndexError): 
             l=len(audio2)
@@ -488,8 +500,9 @@ class song:
         for i in range(len(self.beatmap)):
             try: self.audio[:,int(self.beatmap[i])-smoothing + int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i]))) : int(self.beatmap[i])-smoothing+int(float(shift) * (int(self.beatmap[i+1])-int(self.beatmap[i])))+int(l)]*=audio2
             except (IndexError, ValueError): break
+        self._update()
 
-    def quick_beatswap(self, output:str='', pattern:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, suffix:str='_BeatSwap', lib:str='madmom.BeatDetectionProcessor'):
+    def quick_beatswap(self, output:str='', pattern:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, suffix:str=' (beatswap)', lib:str='madmom.BeatDetectionProcessor', log = True):
         """Generates beatmap if it isn't generated, applies beatswapping to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
         
         output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
@@ -513,26 +526,53 @@ class song:
         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
-        if autoscale is True: song.beatmap_autoscale(self)
-        if shift!=0: song.beatmap_shift(self,shift)
-        if scale!=1: song.beatmap_scale(self,scale)
-        if autoinsert is True: song.beatmap_autoinsert(self)
-        if start!=0 or end is not None: song.beatmap_trim(self,start, end)
-        song.beatswap(self,pattern)
+        if log is False and self.log is True: 
+            self.log = False
+            self.beatmap.log=False
+            log_disabled = True
+        else: log_disabled = False
+        self._printlog('___')
+        scale = _safer_eval(scale)
+        shift = _safer_eval(shift)
+        if self.bm is None: self.beatmap.generate(lib=lib)
+        if autotrim is True: self.autotrim()
+        save=self.beatmap.beatmap.copy()
+        if autoscale is True: self.beatmap.autoscale()
+        if shift!=0: self.beatmap.shift(shift)
+        if scale!=1: self.beatmap.scale(scale)
+        if autoinsert is True: self.beatmap.autoinsert()
+        if start!=0 or end is not None: self.beatmap.cut(start, end)
+        self._printlog(f'pattern = {pattern}')
+        if 'test' in pattern.lower():
+            self.audio*=0.7
+            self.beatmap.beatmap=save.copy()
+            if autoinsert is True: self.beatmap.autoinsert()
+            if start!=0 or end is not None: self.beatmap.cut(start, end)
+            audio2, samplerate2=open_audio('samples/cowbell.flac')
+            song.quick_beatsample(self, output=None, audio2=list(i[::3] for i in audio2), scale=8*scale, shift=0+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=list(i[::2] for i in audio2), scale=8*scale, shift=1*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=audio2, scale=8*scale, shift=2*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,2,axis=1), scale=8*scale, shift=3*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,3,axis=1), scale=8*scale, shift=4*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=numpy.repeat(audio2,2,axis=1), scale=8*scale, shift=5*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=audio2, scale=8*scale, shift=6*scale+shift, log=log)
+            song.quick_beatsample(self, output=None, audio2=list(i[::2] for i in audio2), scale=8*scale, shift=7*scale+shift, log=log)
+
+        else: self.beatswap(pattern)
 
         if output is not None:
             if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
             output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+''.join(''.join(self.filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
-            song.write_audio(self,output)
+                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+            self.write(output)
 
-        self.beatmap=save
+        self.beatmap.beatmap=save.copy()
+        if log_disabled is True: 
+            self.log = True
+            self.beatmap.log=True
 
 
-    def quick_sidechain(self, output:str='', audio2:numpy.array=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, filename2:str=None, suffix:str='_Sidechain', lib:str='madmom.BeatDetectionProcessor'):
+    def quick_sidechain(self, output:str='', audio2:numpy.array=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, filename2:str=None, suffix:str=' (sidechain)', lib:str='madmom.BeatDetectionProcessor', log=True):
         """Generates beatmap if it isn't generated, applies fake sidechain on each beat to the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
         
         output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
@@ -558,31 +598,40 @@ class song:
         suffix: suffix that will be appended to the filename
         
         lib: beat detection library"""
+        if log is False and self.log is True: 
+            self.log = False
+            log_disabled = True
+        else: log_disabled = False
+        self._printlog('___')
+        scale = _safer_eval(scale)
+        shift = _safer_eval(shift)
         if filename2 is None and audio2 is None:
-            audio2=generate_sidechain()
+            from . import generate
+            audio2=generate.sidechain()
 
         if audio2 is None:
             audio2, samplerate2=open_audio(filename2)
 
-        if self.beatmap is None: song.analyze_beats(self,lib=lib)
-        if autotrim is True: song.audio_autotrim(self)
-        save=self.beatmap
-        if autoscale is True: song.beatmap_autoscale(self)
-        if shift!=0: song.beatmap_shift(self,shift)
-        if scale!=1: song.beatmap_scale(self,scale)
-        if autoinsert is True: song.beatmap_autoinsert(self)
-        if start!=0 or end is not None: song.beatmap_trim(self,start, end)
-        song.sidechain(self,audio2)
+        if self.bm is None: self.beatmap.generate(lib=lib)
+        if autotrim is True: self.autotrim()
+        save=self.beatmap.beatmap.copy()
+        if autoscale is True: self.beatmap.autoscale()
+        if shift!=0: self.beatmap.shift(shift)
+        if scale!=1: self.beatmap.scale(scale)
+        if autoinsert is True: self.beatmap.autoinsert()
+        if start!=0 or end is not None: self.beatmap.cut(start, end)
+        self.sidechain(audio2)
 
         if output is not None:
             if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
             output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+''.join(''.join(self.filename.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
-            song.write_audio(self,output)
+                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+            self.write(output)
         
-        self.beatmap=save
+        self.beatmap.beatmap=save.copy()
+        if log_disabled is True: self.log = True
 
-    def quick_beatsample(self, output:str='', filename2:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, audio2:numpy.array=None, suffix:str='_BeatSample', lib:str='madmom.BeatDetectionProcessor'):
+    def quick_beatsample(self, output:str='', filename2:str=None, scale:float=1, shift:float=0, start:float=0, end:float=None, autotrim:bool=True, autoscale:bool=False, autoinsert:bool=False, audio2:numpy.array=None, suffix:str=' (BeatSample)', lib:str='madmom.BeatDetectionProcessor', log=True):
         """Generates beatmap if it isn't generated, adds chosen sample to each beat of the song and writes the processed song it next to the .py file. If you don't want to write the file, set output=None
         
         output: can be a relative or an absolute path to a folder or to a file. Filename will be created from the original filename + a suffix to avoid overwriting. If path already contains a filename which ends with audio file extension, such as .mp3, that filename will be used.
@@ -606,6 +655,13 @@ class song:
         suffix: suffix that will be appended to the filename
         
         lib: beat detection library"""
+        if log is False and self.log is True: 
+            self.log = False
+            log_disabled = True
+        else: log_disabled = False
+        self._printlog('___')
+        scale = _safer_eval(scale)
+        shift = _safer_eval(shift)
         if filename2 is None and audio2 is None:
             from tkinter.filedialog import askopenfilename
             filename2 = askopenfilename(title='select sidechain impulse', filetypes=[("mp3", ".mp3"),("wav", ".wav"),("flac", ".flac"),("ogg", ".ogg"),("wma", ".wma")])
@@ -613,96 +669,97 @@ class song:
         if audio2 is None:
             audio2, samplerate2=open_audio(filename2)
 
-        if self.beatmap is None: song.analyze_beats(self,lib=lib)
-        if autotrim is True: song.audio_autotrim(self)
-        save=numpy.copy(self.beatmap)
-        if autoscale is True: song.beatmap_autoscale(self)
-        if shift!=0: song.beatmap_shift(self,shift)
-        if scale!=1: song.beatmap_scale(self,scale)
-        if autoinsert is True: song.beatmap_autoinsert(self)
-        if start!=0 or end is not None: song.beatmap_trim(self,start, end)
-        song.beatsample(self,audio2)
+        if self.bm is None: self.beatmap.generate(lib=lib)
+        if autotrim is True: self.autotrim()
+        save=self.beatmap.beatmap.copy()
+        if autoscale is True: self.beatmap.autoscale()
+        if shift!=0: self.beatmap.shift(shift)
+        if scale!=1: self.beatmap.scale(scale)
+        if autoinsert is True: self.beatmap.autoinsert()
+        if start!=0 or end is not None: self.beatmap.cut(start, end)
+        self.beatsample(audio2)
 
         if output is not None:
             if not (output.lower().endswith('.mp3') or output.lower().endswith('.wav') or output.lower().endswith('.flac') or output.lower().endswith('.ogg') or 
             output.lower().endswith('.aac') or output.lower().endswith('.ac3') or output.lower().endswith('.aiff')  or output.lower().endswith('.wma')):
-                output=output+''.join(''.join(self.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)
+                output=output+'.'.join(''.join(self.path.split('/')[-1]).split('.')[:-1])+suffix+'.mp3'
+            self.write(output)
+        self.beatmap.beatmap=save.copy()
+        if log_disabled is True: self.log = True
+
+    def spectogram_to_audio(self):
+        self.audio = self.spectogram.toaudio()
+
+    def beat_image_to_audio(self):
+        self.audio = self.beat_image.toaudio()
 
-    def 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):
+    if scale==1 and shift==0:
+        print('scale = 1, shift = 0: no changes have been made.')
+        return
     track=song(filename)
-    track.analyze_beats(lib=lib)
-    track.beatmap_shift(shift)
-    track.beatmap_scale(scale)
-    id=hex(len(track.audio[0]))
+    audio_id=hex(len(track.audio[0]))
+    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
     import os
+    if not os.path.exists(cacheDir):
+        print(f"beatmap isn't generated: {filename}")
+        return
+    track.beatmap.generate(lib=lib)
+    track.beatmap.shift(shift)
+    track.beatmap.scale(scale)
     if not os.path.exists('SavedBeatmaps'):
         os.mkdir('SavedBeatmaps')
-    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')
+    a=input(f'Are you sure you want to overwrite {cacheDir} using scale = {scale}; shift = {shift}? ("y" to continue): ')
+    if 'n' in a.lower() or not 'y' in a.lower():
+        print('Operation canceled.') 
+        return
+    else: 
+        track.beatmap._toarray()
+        numpy.savetxt(cacheDir, track.bm.astype(int), fmt='%d')
+        print('Beatmap overwritten.')
 
 def delete_beatmap(filename, lib='madmom.BeatDetectionProcessor'):
-    track=open_audio(filename)[0]
-    id=hex(len(track.audio[0]))
+    track=song(filename)
+    audio_id=hex(len(track.audio[0]))
     import os
     if not os.path.exists('SavedBeatmaps'):
         os.mkdir('SavedBeatmaps')
-    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+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)
+    cacheDir="SavedBeatmaps/" + ''.join(track.filename.split('/')[-1]) + "_"+lib+"_"+audio_id+'.txt'
+    if not os.path.exists(cacheDir):
+        print(f"beatmap doesn't exist: {filename}")
+        return
+    a=input(f'Are you sure you want to delete {cacheDir}? ("y" to continue): ')
+    if 'n' in a.lower() or not 'y' in a.lower():
+        print('Operation canceled.') 
+        return
+    else: 
+        os.remove(cacheDir)
+        print('Beatmap deleted.')
+
+
+def _tosong(audio, bmap, samplerate, log):
+    from .wrapper import _song_copy
+    if isinstance(audio, str) or audio is None: audio = song(audio, bmap=bmap, log = log)
+    elif isinstance(audio, list) or isinstance(audio, numpy.ndarray) or isinstance(audio, tuple):
+        assert samplerate is not None, "If audio is an array, samplerate must be provided"
+        if len(audio)>16 and isinstance(audio[0], list) or isinstance(audio[0], numpy.ndarray) or isinstance(audio[0], tuple):
+            audio = numpy.asarray(audio).T
+        audio = song(audio=audio, samplerate=samplerate, bmap=bmap, log = log)
+    elif isinstance(audio, song): 
+        audio = _song_copy(audio)
+        audio.log, audio.beatmap.log, audio.beat_image.log = log, log, log
+    else: assert False, f"Audio should be either a path to a file, a list/array/tuple, a beat_manipulator.song object, or None for a pick file dialogue, but it is {type(audio)}"
+    return audio
+
+def beatswap(pattern: str, audio = None, scale: float = 1, shift: float = 0, output='', samplerate = None, bmap = None, log = True, suffix=' (beatswap)'):
+    audio = _tosong(audio=audio, bmap=bmap, samplerate=samplerate, log=log)
+    output = _outputfilename(output=output, filename=audio.path, suffix=suffix)
+    audio.quick_beatswap(pattern = pattern, scale=scale, shift=shift, output=output)
+
+def generate_beat_image(audio = None, output='', samplerate = None, bmap = None, log = True, ext='png', maximum=4096):
+    audio = _tosong(audio=audio, bmap=bmap, samplerate=samplerate, log=log)
+    output = _outputfilename(output=output, filename=audio.path, ext=ext, suffix = '')
+    audio.beatmap.generate()
+    audio.beat_image.generate()
+    audio.beat_image.write(output=output, maximum = maximum)

beat_manipulator/mix.py

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

beat_manipulator/tests.py

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

wrapper.py → beat_manipulator/wrapper.py

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

requirements.txt

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