Example.scd

// Quarks.install("https://github.com/scztt/OSequence.quark"); // Quarks.install("https://github.com/scztt/Require.quark");

~loaded = Require("LOADER").("HKW-3/*"); ~loaded.postEvents; ~loaded.seq.do(_.postln); ~eventStream = ~loaded.seq.asStream;

// An array of all \degree values ~justDegrees = ~loaded.seq.collect(_[\degree]); ~justDegrees.events.asArray.flatten;

// Turn into Pbind ( var metaphrase, metabind; #metaphrase, metabind = Require("PBIND_PHRASE").(~eventStream);

metabind.play; // <-- a Pbind representing the original event stream metaphrase; // <-- each key as a separeate array? )

LOADER.scd

~parseMidi = {
	|name|
	var files;

	files = Require.resolvePaths(name, extensions:["mid"]).postln;
	files = files.collect {
		|path|
		PathName(path).fileNameWithoutExtension.asSymbol -> SimpleMIDIFile.read(path);
	};
	files = files.asEvent;

	~tempos = files.collectAs({
		|midi|
		midi.tempo;
	}, Array);

	files = files.collect {
		|midi, name|
		OSequence.fromStream(midi.p(name).asStream).modifyEvents_(false)
	};
};

~unique = {
	|files|
	files.collect {
		|seq|
		var unique = IdentitySet();
		seq.do({
			|e|
			unique.add((e.midinote - 69) % 12);
		});
		unique.asSortedList;
	};
};

~merge = {
	|files|
	var result = OSequence();

	files.keysValuesDo {
		|name, seq|
		seq.do {
			|e|
			// e[\fileSource] = name;
		};
		result.putSeq(0, seq);
	};

	result;
};

~process = {
	|sequence, quantize|

	sequence.filter({ |e| e.midinote != \rest });

	sequence.do {
		|e|
		var midinote = e[\midinote];
		e[\scale] = Scale.chromatic;
		e[\degree] = (midinote - 60).mod(12).round(1);
		e[\octave] = 5 + (midinote - 60).div(12).round(1);
		// e[\originalMidinote] = midinote;
		e[\midinote] = nil;

		if (abs(e[\delta] - e[\dur]) > 0.01) {
			"Wierd delta and dur: % <> %".format(e[\delta], e[\dur]).warn;
		};
	};

	if (quantize.notNil) {
		sequence.warp(_.round(quantize), false);
	};

	sequence.do {
		|e|
		e[\dur] = nil;
		e[\delta] = nil;
	};

	sequence.doReplaceTimes {
		|events, time|
		var newEvents = ();

		events.do {
			|e|
			newEvents[e[\instrument]] = newEvents[e[\instrument]].add(e);
		};

		newEvents = newEvents.collect {
			|events|

			if (events.size == 1) {
				events
			} {
				var newEvent = ();
				var keys = events.collect(_.keys).collect(_.asArray).flatten.asSet;

				events.do {
					|e|
					keys.do {
						|k|
						newEvent[k] = newEvent[k].add(e[k] ? nil);
					}
				};

				newEvent = newEvent.collect {
					|values|
					if (values.asArray.asSet.size == 1) {
						values[0]
					} {
						values;
					}
				};

				newEvent;
			}
		};

		List.newFrom(newEvents.values.flatten);
	};

	sequence;
};

~bars = {
	|seq|
	var barLength, bar, bars;
	barLength = 4;
	(0..(seq.duration / barLength)).do {
		|i|
		bars = bars.add(
			seq.copy
			.delete(0, (i * barLength), false)
			.delete((i + 1) * barLength, inf, false)
		);
	};
	bars;
};

{
	|spec, quantize|
	~files = ~parseMidi.(spec);
	~seq = ~merge.(~files);
	~process.(~seq, quantize);

	(
		tempo: ~tempos,
		seq: ~seq,
		postEvents: {
			~seq.do({
				|e, t|
				"[%]  --------".format(t).postln;
				e.keysValuesDo {
					|k, v|
					"\t%: %".format(k, v).postln;
				}
			})
		}
	)
};

PBIND_PHRASE.scd

{
	|phrase|
	var metaBind, metaPhrase = ();
	var minOct, scaleNotes;

	phrase.do {
		|e|
		e.keysValuesDo {
			|k, v|
			metaPhrase[k] = metaPhrase[k].add(v)
		}
	};

	metaPhrase.keysValuesChange {
		|k, v|
		if (v.asSet.size == 1) {
			v[0]
		} {
			v
		}
	};

	minOct = metaPhrase[\octave].asArray.minItem;
	metaPhrase[\degree] = metaPhrase[\degree].asArray;

	metaPhrase[\octave].do {
		|oct, i|
		metaPhrase[\degree].wrapPut(i,
			metaPhrase[\degree].wrapAt(i) + ((oct - minOct) * 12)
		)
	};
	metaPhrase[\octave] = minOct;

	scaleNotes = metaPhrase[\degree].collect({ |d| d % 12 }).asSet.asArray.sort;
	metaPhrase[\degree] = metaPhrase[\degree].collect {
		|d|
		var rem = (d / 12).floor;
		scaleNotes.indexOf(d % 12) + (rem * scaleNotes.size);
	};
	metaPhrase[\scale] = Scale(scaleNotes, 12);

	metaPhrase.keysValuesDo {
		|k, v|
		"%: %".format(k, v).postln;
	};

	metaBind = metaPhrase.collect {
		|v|
		if (v.isArray) {
			Pseq(v)
		} {
			v
		}
	};

	metaBind = Pbind(*metaBind.asPairs);
	[metaPhrase, metaBind]
}