Integrated and Enhanced: Audio-to-MIDI and Advanced MIDI Renderer

- **Integration of asigalov61's Projects:**
Merges the `ByteDance-Solo-Piano-Audio-to-MIDI-Transcription` and `Advanced-MIDI-Renderer` projects into a single, cohesive application. This forms the foundational workflow for MIDI processing and rendering.

- **Addition of General-Purpose Transcription:**
Implements Spotify's `basic-pitch` library as a new transcription option. This allows for the effective transcription of non-piano music, including songs with vocals and multiple instruments.

- **Dynamic UI for Method Selection:**
A new UI control allows users to choose between the "General Purpose" (basic-pitch) and "Piano-Specific" (ByteDance) transcription models, with the UI dynamically showing relevant settings for the selected method.

- **Refactor: Extract shared MIDI module to reduce duplication:**
The `midi_to_colab_audio.py` and `TMIDIX.py` scripts both contained a large, duplicated block of code for MIDI processing.

- **Improve FluidSynth rendering speed in midi_to_colab_audio:**
Optimized the audio synthesis process to fix a major performance issue with long MIDI files. The previous method of using `np.concatenate` in a loop was very slow.
The new implementation now collects audio chunks in a list and merges them all at once at the end, making the rendering process significantly faster.
This change reduces the time complexity from O(n^2) to O(n), resulting in a significant performance improvement for long MIDI files.

.gitignore

@@ -0,0 +1,12 @@
+.vs
+.vscode
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+venv/
+tmp/
+sf2/
+models/
+output/
+rendered_midi/
+transcribed_/

KBH-Real-Choir-V2.5.sf2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:04848e9c6cb7e27f2131156dd2ecedc283c1805bd326b5ea64ed2b6da23e106a
-size 17360134

Live HQ Natural SoundFont GM.sf2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5ed1b6a205686e43ead7386560c6610406b3cf4a0dfda230b89b8403dcf5efb7
-size 836038682

Nice-Strings-PlusOrchestra-v1.6.sf2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:215e41f740172ddf72bf729c7df2f38356866f84a99fac39f84f861a02eddddd
-size 442272364

Orpheus_18.06.2020.sf2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:759fb756dcc8560c46f7e911ce981c69690e1d4aa3a634c537dbf658ccd11615
-size 1288303498

README.md

@@ -1,5 +1,5 @@
 ---
-title: Advanced MIDI Renderer
+title: Audio To MIDI And Advanced Renderer
 emoji: 🎹
 colorFrom: purple
 colorTo: green
@@ -13,8 +13,8 @@ tags:
 - renderer
 - MIDI rendering
 - MIDI renderer
-short_description: Transform and render any MIDI
-sdk_version: 5.39.0
+short_description: Audio to MIDI Transcription and Advanced render
+sdk_version: 5.41.1
 thumbnail: >-
   https://cdn-uploads.huggingface.co/production/uploads/5f57ea2d3f32f12a3c0692e6/SvsnExU8EVOdm-Ol32RIn.png
 ---

SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cd41a4639c9e7a96413b4b22540d48e6741e24bcdabcb2eff22cd65929df3cfa
-size 553961496

TCUPY.py

@@ -1,1093 +0,0 @@
-#! /usr/bin/python3
-
-r'''############################################################################
-################################################################################
-#
-#
-#	    Tegridy Cupy Python Module (TCUPY)
-#	    Version 1.0
-#
-#	    Project Los Angeles
-#
-#	    Tegridy Code 2025
-#
-#       https://github.com/asigalov61/tegridy-tools
-#
-#
-################################################################################
-#
-#       Copyright 2024 Project Los Angeles / Tegridy Code
-#
-#       Licensed under the Apache License, Version 2.0 (the "License");
-#       you may not use this file except in compliance with the License.
-#       You may obtain a copy of the License at
-#
-#           http://www.apache.org/licenses/LICENSE-2.0
-#
-#       Unless required by applicable law or agreed to in writing, software
-#       distributed under the License is distributed on an "AS IS" BASIS,
-#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#       See the License for the specific language governing permissions and
-#       limitations under the License.
-#
-################################################################################
-################################################################################
-#
-#       Critical dependencies
-#
-#       !pip install cupy-cuda12x
-#       !pip install numpy==1.24.4
-#
-################################################################################
-'''
-
-################################################################################
-
-print('=' * 70)
-print('Loading module...')
-print('Please wait...')
-print('=' * 70)
-
-################################################################################
-
-import sys
-import os
-
-################################################################################
-
-try:
-    import cupy as cp
-    import cupy as np
-    print('=' * 70)
-    print('CuPy is found!')
-    print('Will use CuPy and GPU for processing!')
-    print('=' * 70)
-
-except ImportError as e:
-    print(f"Error: Could not import CuPy. Details: {e}")
-    # Handle the error, such as providing a fallback or exiting the program
-    # For example:
-    print("Please make sure CuPy is installed.")
-    print('=' * 70)
-    
-    raise RuntimeError("CuPy could not be loaded!") from e
-
-################################################################################
-
-from collections import defaultdict, deque
-from typing import Optional, Tuple, Dict, Any, List
-
-################################################################################
-
-# Constants
-MEMORY_LEN = 12       # Autoregressive context length
-SEQUENCE_LENGTH = 32  # Each sequence has 24 triplets
-
-# Baseline penalty values:
-REPETITION_PENALTY = (1.0, 1.0, 1.0)      # base repetition penalty per element
-SPIKE_PENALTY_STRENGTH = (1.0, 1.0, 1.0)    # base spike penalty strength per element
-SPIKE_SIGMA = (1.0, 1.0, 1.0)               # baseline sigma value per element (minimum allowed)
-
-###################################################################################
-
-def find_numpy_array(src_array, trg_array):
-
-    """
-    Finds 1D numpy array in 2D numpy array
-    """
-
-    match_mask = np.all(src_array == trg_array, axis=1)
-    
-    return np.where(match_mask)[0]
-
-###################################################################################
-
-def vertical_list_search(src_list, trg_list):
-    
-    """
-    For each vertical window of consecutive rows of height len(trg_list) in src_list,
-    this function checks whether for every offset j (0 <= j < len(trg_list)) the row
-    at index (window_start + j) contains trg_list[j].
-
-    It returns a list of windows (each a list of consecutive row indices) that meet this condition.
-    """
-    
-    if not src_list or not trg_list:
-        return []
-    
-    n = len(src_list)
-    k = len(trg_list)
-    
-    num_windows = n - k + 1
-    
-    if num_windows <= 0:
-        return []
-    
-    # Determine the maximum row length.
-    max_len = max(len(row) for row in src_list)
-    
-    # Determine a fill value guaranteed to be less than any valid value.
-    global_min = min(min(row) for row in src_list if row)
-    fill_value = global_min - 1
-
-    # Build a padded 2D array A (shape n x max_len) from src_list.
-    A = np.full((n, max_len), fill_value, dtype=np.int64)
-    for i, row in enumerate(src_list):
-        L = len(row)
-        A[i, :L] = row
-
-    # For each unique target in trg_list, compute a Boolean vector of length n.
-    # present[t][i] will be True if A[i, :] contains t, else False.
-    unique_targets = set(trg_list)
-    
-    present_dict = {}
-    
-    for t in unique_targets:
-        # Compute along axis=1 so that for each row we see if any element equals t.
-        present_dict[t] = np.any(A == t, axis=1)
-    
-    # Build a Boolean array B of shape (k, num_windows) where for each offset j,
-    # B[j, s] = present_dict[ trg_list[j] ][s + j] for each window starting index s.
-    B = np.empty((k, num_windows), dtype=bool)
-    
-    for j in range(k):
-        t = trg_list[j]
-        # For a vertical window starting at s, row s+j should contain t.
-        B[j, :] = present_dict[t][j: j + num_windows]
-    
-    # A window is valid if all k rows in that window contain the required target.
-    valid_windows_mask = np.all(B, axis=0)
-    valid_starts = np.nonzero(valid_windows_mask)[0]
-    
-    # Create output windows (each as a list of consecutive row indices).
-    result = [list(range(s, s + k)) for s in valid_starts]
-    
-    return result
-
-
-###################################################################################
-
-def pack_sequences(train_data, pad_val=-1):
-    """
-    Packs a list of variable-length token sequences into a 2D CuPy array.
-    
-    This version computes lengths and builds the padded array and mask entirely on GPU.
-    It converts each sequence into a CuPy array, concatenates them, and assigns tokens in one shot.
-    
-    Returns:
-      batch: a CuPy array of shape (n, max_len)
-      lengths: a CuPy array of shape (n,) containing each sequence's length.
-    """
-    n = len(train_data)
-    # Compute lengths of each sequence and convert to a CuPy array.
-    lengths = cp.array([len(seq) for seq in train_data], dtype=cp.int64)
-    max_len_val = int(cp.max(lengths).get())
-    # Allocate the padded 2D array filled with pad_val.
-    batch = cp.full((n, max_len_val), pad_val, dtype=cp.int64)
-    # Create a boolean mask: for each row, positions less than the sequence length are valid.
-    mask = cp.arange(max_len_val).reshape(1, max_len_val) < lengths.reshape(n, 1)
-    # Convert each sequence to a CuPy array and concatenate them.
-    sequences = [cp.array(seq, dtype=cp.int64) for seq in train_data]
-    flat = cp.concatenate(sequences)
-    # Fill in the valid positions.
-    batch[mask] = flat
-    return batch, lengths
-
-###################################################################################
-
-def count_best_pair_gpu(batch, lengths, factor, pad_val=-1):
-    """
-    Given the entire GPU-resident packed data, compute the most frequent
-    adjacent pair (encoded as: pair_val = first * factor + second) on GPU.
-    """
-    n, L = batch.shape
-    cols = cp.arange(L - 1, dtype=cp.int64)
-    cols_expanded = cp.broadcast_to(cols, (n, L - 1))
-    valid_mask = cols_expanded < cp.reshape(lengths, (n, 1)) - 1
-
-    first_tokens = batch[:, :L - 1]
-    second_tokens = batch[:, 1:L]
-    valid_first = first_tokens[valid_mask]
-    valid_second = second_tokens[valid_mask]
-
-    pairs = valid_first * factor + valid_second
-    if pairs.size == 0:
-        return None
-
-    sorted_pairs = cp.sort(pairs)
-    diff = cp.diff(sorted_pairs)
-    boundaries = cp.nonzero(diff)[0] + 1
-    group_starts = cp.concatenate([cp.array([0], dtype=cp.int64), boundaries])
-    group_ends = cp.concatenate([boundaries, cp.array([sorted_pairs.size], dtype=cp.int64)])
-    group_counts = group_ends - group_starts
-
-    max_idx = int(cp.argmax(group_counts))
-    best_pair_enc = int(sorted_pairs[group_starts[max_idx]])
-    best_freq = int(group_counts[max_idx])
-    first = best_pair_enc // factor
-    second = best_pair_enc % factor
-    return (first, second, best_freq)
-
-###################################################################################
-
-merge_kernel_code = r'''
-extern "C" __global__
-void merge_pair_kernel(const long* input, long* output, 
-                       const long* input_lengths, long* output_lengths,
-                       const long num_rows, const long num_cols,
-                       const long a, const long b, const long new_token,
-                       const long pad_val) {
-    int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= num_rows) return;
-    long in_length = input_lengths[row];
-    long out_idx = 0;
-    bool skip_next = false;
-    for (long i = 0; i < in_length; i++) {
-        if (skip_next) {
-            skip_next = false;
-            continue;
-        }
-        long token = input[row * num_cols + i];
-        if (i < in_length - 1 && token == a && input[row * num_cols + i + 1] == b) {
-            output[row * num_cols + out_idx] = new_token;
-            out_idx++;
-            skip_next = true;
-        } else {
-            output[row * num_cols + out_idx] = token;
-            out_idx++;
-        }
-    }
-    output_lengths[row] = out_idx;
-    for (long j = out_idx; j < num_cols; j++) {
-        output[row * num_cols + j] = pad_val;
-    }
-}
-'''
-merge_kernel = cp.RawKernel(merge_kernel_code, 'merge_pair_kernel')
-
-###################################################################################
-
-def learn_bpe_codes_gpu(train_data, vocab_size=4096, max_merges=None, pad_val=-1):
-    """
-    Learn BPE merge rules completely on GPU.
-    
-    The training data is packed once (using the vectorized pack_sequences).
-    On each merge iteration, the best adjacent pair is computed on GPU and then merged
-    into a new token via a custom merge kernel (with double-buffering).
-    
-    Returns:
-      codes: a list of merge rules as ((first, second), new_token)
-      final_data: the merged training data (list of sequences)
-    """
-    # Pack the entire dataset onto GPU.
-    batch, lengths = pack_sequences(train_data, pad_val)
-    n, L = batch.shape
-
-    # Initialize vocabulary and the next available token.
-    initial_vocab = {token for seq in train_data for token in seq}
-    next_token = max(initial_vocab) + 1
-    codes = []
-    merge_count = 0
-    pbar = tqdm.tqdm(total=max_merges if max_merges is not None else None,
-                desc="Learning BPE Codes (GPU)", leave=True)
-
-    # Preallocate buffers for double-buffering.
-    work_batch = cp.empty_like(batch)
-    work_lengths = cp.empty_like(lengths)
-    input_batch = batch
-    input_lengths = lengths
-
-    threads_per_block = 128
-    blocks = (n + threads_per_block - 1) // threads_per_block
-
-    while next_token < vocab_size and (max_merges is None or merge_count < max_merges):
-        # Early stop if all sequences have collapsed (checked on GPU).
-        if bool(cp.all(input_lengths == 1)):
-            pbar.write("All sequences have collapsed; stopping early.")
-            break
-
-        factor = next_token  # by construction, every token is < next_token
-        best = count_best_pair_gpu(input_batch, input_lengths, factor, pad_val)
-        if best is None:
-            pbar.write("No mergeable pairs found; stopping early.")
-            break
-        
-        best_pair = (best[0], best[1])
-        best_freq = best[2]
-        if best_freq < 2:
-            pbar.write("Best pair frequency is less than 2; stopping early.")
-            break
-
-        codes.append((best_pair, next_token))
-
-        # Launch the merge kernel.
-        merge_kernel((blocks,), (threads_per_block,),
-                     (input_batch,
-                      work_batch,
-                      input_lengths,
-                      work_lengths,
-                      cp.int64(n),
-                      cp.int64(L),
-                      cp.int64(best_pair[0]),
-                      cp.int64(best_pair[1]),
-                      cp.int64(next_token),
-                      cp.int64(pad_val)))
-        # Swap buffers for double-buffering.
-        input_batch, work_batch = work_batch, input_batch
-        input_lengths, work_lengths = work_lengths, input_lengths
-
-        next_token += 1
-        merge_count += 1
-        pbar.update(1)
-    pbar.close()
-
-    final_batch = cp.asnumpy(input_batch)
-    final_lengths = cp.asnumpy(input_lengths)
-    final_data = [final_batch[i, :final_lengths[i]].tolist() for i in range(n)]
-    return codes, final_data
-
-###################################################################################
-
-fused_merge_kernel_code = r'''
-extern "C" __global__
-void fused_merge_kernel(long* data_in, long* data_out, long* lengths, const long pad_val,
-                          const long num_rows, const long max_len, const long num_merges, const long* merge_rules) {
-    int row = blockIdx.x * blockDim.x + threadIdx.x;
-    if (row >= num_rows) return;
-    long base = row * max_len;
-    long cur_len = lengths[row];
-    long* cur = data_in + base;
-    long* other = data_out + base;
-    // Process each merge rule sequentially.
-    for (int m = 0; m < num_merges; m++) {
-        long a = merge_rules[3 * m];
-        long b = merge_rules[3 * m + 1];
-        long new_token = merge_rules[3 * m + 2];
-        long out_idx = 0;
-        for (int i = 0; i < cur_len; i++) {
-            if (i < cur_len - 1 && cur[i] == a && cur[i+1] == b) {
-                other[out_idx] = new_token;
-                out_idx++;
-                i++;  // Skip the next token.
-            } else {
-                other[out_idx] = cur[i];
-                out_idx++;
-            }
-        }
-        cur_len = out_idx;
-        // Swap pointers for the next merge.
-        long* temp = cur;
-        cur = other;
-        other = temp;
-    }
-    lengths[row] = cur_len;
-    // Pad the remaining positions with pad_val.
-    for (int i = cur_len; i < max_len; i++) {
-        cur[i] = pad_val;
-    }
-    // If the final result is not in data_in, copy back.
-    if (cur != data_in + base) {
-        for (int i = 0; i < cur_len; i++) {
-            data_in[base + i] = cur[i];
-        }
-    }
-}
-'''
-fused_kernel = cp.RawKernel(fused_merge_kernel_code, 'fused_merge_kernel')
-
-###################################################################################
-
-def retokenize_train_data_fused_gpu(train_data, codes, pad_val=-1):
-    """
-    Retokenize training data using the fully fused GPU kernel.
-    
-    The entire training dataset is first packed into GPU memory (using pack_sequences).
-    All learned merge rules (provided in 'codes') are applied via a single kernel launch.
-    Each GPU thread processes one sequence by applying all merge rules sequentially.
-    
-    Returns:
-      tokenized_data: list of retokenized sequences.
-    """
-    # Pack the data.
-    batch, lengths = pack_sequences(train_data, pad_val)
-    n, max_len = batch.shape
-    # Build a flattened merge_rules array using CuPy.
-    if len(codes) > 0:
-        merge_rules_list = [[rule[0][0], rule[0][1], rule[1]] for rule in codes]
-        merge_rules_gpu = cp.array(merge_rules_list, dtype=cp.int64)
-        merge_rules_gpu = merge_rules_gpu.reshape(-1)
-    else:
-        merge_rules_gpu = cp.empty((0,), dtype=cp.int64)
-    num_merges = merge_rules_gpu.shape[0] // 3
-    # Preallocate a scratch buffer.
-    scratch = cp.empty_like(batch)
-    threads_per_block = 128
-    blocks = (n + threads_per_block - 1) // threads_per_block
-    # Launch the fused kernel.
-    fused_kernel((blocks,), (threads_per_block,),
-                 (batch, scratch, lengths, cp.int64(pad_val),
-                  cp.int64(n), cp.int64(max_len), cp.int64(num_merges), merge_rules_gpu))
-    final_batch = cp.asnumpy(batch)
-    final_lengths = cp.asnumpy(lengths)
-    tokenized_data = [final_batch[i, :final_lengths[i]].tolist() for i in range(n)]
-    return tokenized_data
-
-###################################################################################
-
-def bpe_encode(seq, codes):
-    """
-    Iteratively encodes a sequence using BPE merge rules provided in a dictionary.
-    
-    Args:
-        seq (list): A list of tokens (e.g. integers) representing the input sequence.
-        codes (dict): A dictionary mapping token pairs (a tuple of two tokens) 
-                      to a merged token. For example:
-                      { (1, 2): 100, (100, 3): 101 }
-    
-    Returns:
-        list: The encoded sequence after applying all possible merges.
-    
-    The function repeatedly scans the entire sequence from left to right;
-    whenever it finds a contiguous token pair that exists as a key in the
-    codes dict, it replaces that pair with the merged token. This pass is
-    repeated until no more merges are possible.
-    """
-
-    if type(codes) == list:
-        codes = dict(codes)
-        
-    encoded_seq = seq.copy()  # work on a copy so as not to modify the original
-    done = False
-    while not done:
-        new_seq = []
-        i = 0
-        changed = False
-        while i < len(encoded_seq):
-            # If a merge is possible, merge the two tokens.
-            if i < len(encoded_seq) - 1 and (encoded_seq[i], encoded_seq[i + 1]) in codes:
-                new_seq.append(codes[(encoded_seq[i], encoded_seq[i + 1])])
-                i += 2  # Skip the next token as it was merged.
-                changed = True
-            else:
-                new_seq.append(encoded_seq[i])
-                i += 1
-        # If no merges occurred in this pass, exit the loop.
-        if not changed:
-            done = True
-        encoded_seq = new_seq
-    return encoded_seq
-
-###################################################################################
-
-def bpe_decode(seq, codes):
-    """
-    Decodes a sequence encoded with BPE merge rules defined in a codes dictionary.
-    
-    Args:
-        seq (list): The encoded sequence (a list of tokens).
-        codes (dict): A dictionary mapping token pairs to the merged token, used during encoding.
-    
-    Returns:
-        list: The fully decoded sequence, with all merged tokens recursively expanded.
-    
-    The function constructs a reverse mapping that converts a merged token back into 
-    its constituent pair. Each token in the sequence is then recursively expanded.
-    """
-
-    if type(codes) == list:
-        codes = dict(codes)
-        
-    # Build the reverse mapping: key = merged token, value = tuple (original token pair)
-    reverse_mapping = {merged: pair for pair, merged in codes.items()}
-
-    def recursive_expand(token):
-        # If the token is a merged token, expand it recursively.
-        if token in reverse_mapping:
-            a, b = reverse_mapping[token]
-            return recursive_expand(a) + recursive_expand(b)
-        else:
-            return [token]
-
-    decoded_seq = []
-    for token in seq:
-        decoded_seq.extend(recursive_expand(token))
-    return decoded_seq
-
-###################################################################################
-
-def ensure_triplet(val: Any, name: str = "") -> Tuple[float, float, float]:
-    """
-    Ensure the given parameter is returned as a triplet.
-    If provided as a scalar, promote it to a triplet.
-    """
-    if np.isscalar(val):
-        return (float(val), float(val), float(val))
-    elif isinstance(val, (list, tuple)) and len(val) == 3:
-        return tuple(float(x) for x in val)
-    else:
-        raise ValueError(f"{name} must be a scalar or a sequence of 3 numbers.")
-
-###################################################################################
-
-REP_PENALTY = ensure_triplet(REPETITION_PENALTY, "REPETITION_PENALTY")
-SPIKE_STRENGTH = ensure_triplet(SPIKE_PENALTY_STRENGTH, "SPIKE_PENALTY_STRENGTH")
-SPIKE_SIG = ensure_triplet(SPIKE_SIGMA, "SPIKE_SIGMA")
-
-###################################################################################
-
-def sliding_window_view_alternative(a: np.ndarray, window_length: int) -> np.ndarray:
-    """
-    Create a sliding-window view (without copying) of an array.
-    Expected input shape: (n, L, d) and returns: (n, L - window_length + 1, window_length, d)
-    """
-    n, L, d = a.shape
-    new_shape = (n, L - window_length + 1, window_length, d)
-    new_strides = (a.strides[0], a.strides[1], a.strides[1], a.strides[2])
-    return np.lib.stride_tricks.as_strided(a, shape=new_shape, strides=new_strides)
-
-###################################################################################
-
-def build_ngram_mapping(data: np.ndarray, memory_len: int) -> Dict[Any, Dict[Any, int]]:
-    """
-    Build an n-gram mapping from a context (a sequence of triplets) to candidate triplets with frequencies.
-    """
-    n, L, d = data.shape
-    window_length = memory_len + 1  # context (memory) + candidate
-    windows = sliding_window_view_alternative(data, window_length)
-    # windows shape: (n, L - window_length + 1, window_length, d)
-
-    # Split windows into context (first memory_len triplets) and candidates (last triplet)
-    contexts = windows[:, :, :memory_len, :]   # shape: (n, num_windows, memory_len, d)
-    candidates = windows[:, :, memory_len, :]    # shape: (n, num_windows, d)
-
-    # Flatten the batch and window dimensions.
-    contexts_flat = contexts.reshape(-1, memory_len, d)
-    candidates_flat = candidates.reshape(-1, d)
-
-    mapping = defaultdict(lambda: defaultdict(int))
-    total_windows = contexts_flat.shape[0]
-    for context_arr, candidate_arr in tqdm.tqdm(
-            zip(contexts_flat, candidates_flat),
-            total=total_windows,
-            desc="Building n-gram mapping"):
-        context_key = tuple(map(tuple, context_arr))  # use a tuple of triplets as the key
-        candidate_val = tuple(candidate_arr)
-        mapping[context_key][candidate_val] += 1
-
-    return {context: dict(candidates) for context, candidates in mapping.items()}
-
-###################################################################################
-
-def precompute_mapping_lookup(mapping: Dict[Any, Dict[Any, int]]) -> Dict[Any, Tuple[Tuple[Any, ...], np.ndarray]]:
-    """
-    Converts the mapping into a lookup table: context -> (tuple(candidates), frequencies_array).
-    """
-    mapping_lookup = {}
-    for context, candidate_dict in tqdm.tqdm(mapping.items(), desc="Precomputing lookup"):
-        candidates = tuple(candidate_dict.keys())
-        frequencies = np.array(list(candidate_dict.values()), dtype=np.float64)
-        mapping_lookup[context] = (candidates, frequencies)
-    return mapping_lookup
-
-###################################################################################
-
-def build_training_sequences_set(data: np.ndarray) -> set:
-    """
-    Build a set of training sequences (each as a tuple of triplets) for uniqueness checking.
-    """
-    return {tuple(map(tuple, seq)) for seq in data}
-
-###################################################################################
-
-def generate_sequence_optimized(mapping_lookup: Dict[Any, Tuple[Tuple[Any, ...], np.ndarray]],
-                                training_set: set,
-                                memory_len: int,
-                                sequence_length: int = 24,
-                                max_attempts: int = 1000) -> Optional[Tuple[Tuple[float, float, float], ...]]:
-    """
-    Autoregressively generate a new, unique sequence using the precomputed mapping lookup.
-    The invariant maintained is: the second element of one triplet is never greater than the first element
-    of the following triplet.
-
-    Two dynamic adjustments are applied for candidate selection:
-    
-      1. **Dynamic Repetition Penalty:**  
-         For each candidate, count the occurrences of each element in the generated sequence.
-         Rather than a fixed penalty, this repetition penalty scales with the ratio
-         (current_length / sequence_length). In log-space, it subtracts:
-             (current_length / sequence_length) * sum_k(count[k] * log(REP_PENALTY[k])
-      2. **Dynamic Spike (Variance) Penalty:**  
-         For each candidate, compute the squared difference from the running average for each element.
-         Use a dynamic sigma that is the maximum between the running standard deviation and the baseline.
-         The penalty term for each element is:
-             SPIKE_STRENGTH[k] * ((cand[k] - running_avg[k])^2) / (2 * dynamic_sigma[k]^2)
-         The overall spike penalty is the sum of the three terms and is subtracted from the candidate’s log frequency.
-
-    The resulting candidate log score is computed as:
-         log(candidate_frequency) - rep_penalty_component - spike_penalty_component
-    A numerical stable softmax is then applied over these scores to determine the probability for drawing a candidate.
-
-    If no candidate passing the invariant is found, the attempt is aborted.
-
-    Parameters:
-      mapping_lookup: Precomputed lookup mapping (context → (candidates, frequencies)).
-      training_set: Set of training sequences to ensure uniqueness.
-      memory_len: Number of triplets used as context.
-      sequence_length: Desired length of the generated sequence.
-      max_attempts: Maximum number of generation attempts.
-
-    Returns:
-      A new unique sequence (tuple of triplets) that respects the invariant, or None if not found.
-    """
-    mapping_keys = list(mapping_lookup.keys())
-    num_keys = len(mapping_keys)
-
-    for attempt in range(max_attempts):
-        # Select a seed context randomly (from training data so that the invariant holds).
-        seed = mapping_keys[np.random.randint(0, num_keys)]
-        generated_sequence: List[Tuple[float, float, float]] = list(seed)
-        valid_generation = True
-
-        while len(generated_sequence) < sequence_length:
-            last_triplet = generated_sequence[-1]
-            current_context = tuple(generated_sequence[-memory_len:])  # context as tuple of triplets
-            candidate_found = False
-
-            if current_context in mapping_lookup:
-                candidates, frequencies = mapping_lookup[current_context]
-                # Filter candidates by invariant:
-                # Candidate's first element must be >= last triplet's second element.
-                valid_indices = [i for i, cand in enumerate(candidates) if cand[0] >= last_triplet[1]]
-                if valid_indices:
-                    # Filter candidates and their associated frequencies.
-                    filtered_freqs = frequencies[valid_indices]
-                    filtered_candidates = [candidates[i] for i in valid_indices]
-
-                    # Convert candidates into a NumPy array for vectorized operations.
-                    candidate_array = np.array(filtered_candidates, dtype=np.float64)  # shape: (n_candidates, 3)
-                    
-                    # Prepare generation history as array.
-                    generated_array = np.array(generated_sequence, dtype=np.float64)   # shape: (T, 3)
-                    current_length = generated_array.shape[0]
-                    
-                    # Running average and standard deviation for dynamic spike adjustment.
-                    running_avg = np.mean(generated_array, axis=0)       # shape: (3,)
-                    running_std = np.std(generated_array, axis=0)          # shape: (3,)
-                    # Dynamic sigma: ensure a minimum sigma value.
-                    dynamic_sigma = np.maximum(running_std, np.array(SPIKE_SIG))
-                    
-                    # --- Compute Repetition Penalty ---
-                    # For each candidate, count the number of occurrences for each element along the corresponding column.
-                    rep_counts = np.array([
-                        [np.sum(generated_array[:, k] == candidate_array[i, k]) for k in range(3)]
-                        for i in range(candidate_array.shape[0])
-                    ])  # shape: (n_candidates, 3)
-                    # The repetition penalty in log-space.
-                    rep_penalty_term = np.sum(rep_counts * np.log(np.array(REP_PENALTY)) *
-                                              (current_length / sequence_length), axis=1)  # shape: (n_candidates,)
-
-                    # --- Compute Spike (Variance) Penalty ---
-                    # Compute the difference per candidate from the running average.
-                    diff = candidate_array - running_avg  # shape: (n_candidates, 3)
-                    spike_penalty_term = np.sum(np.array(SPIKE_STRENGTH) * (diff**2) / (2 * (dynamic_sigma**2)),
-                                                axis=1)  # shape: (n_candidates,)
-
-                    # --- Compute Candidate Log-Scores ---
-                    # Use np.log on frequencies (they are positive by construction).
-                    log_freq = np.log(filtered_freqs)
-                    log_scores = log_freq - rep_penalty_term - spike_penalty_term
-
-                    # --- Softmax in Log-space (stable computation) ---
-                    max_log = np.max(log_scores)
-                    exp_scores = np.exp(log_scores - max_log)
-                    probabilities = exp_scores / np.sum(exp_scores)
-                    
-                    # Choose the next candidate using advanced probabilities.
-                    chosen_idx = np.random.choice(len(filtered_candidates), p=probabilities)
-                    next_triplet = filtered_candidates[chosen_idx]
-                    candidate_found = True
-
-            if not candidate_found:
-                # Abort this generation attempt if no valid candidate is available.
-                valid_generation = False
-                break
-
-            generated_sequence.append(next_triplet)
-
-        # Ensure the final sequence meets the invariant and is unique.
-        if valid_generation and len(generated_sequence) == sequence_length:
-            new_sequence = tuple(generated_sequence)
-            invariant_ok = all(a[1] <= b[0] for a, b in zip(new_sequence, new_sequence[1:]))
-            if invariant_ok and new_sequence not in training_set:
-                return new_sequence
-
-    return None
-
-###################################################################################
-
-def analyze_generated_sequence(sequence: tuple, mapping_lookup: dict, memory_len: int) -> tuple:
-    """
-    Analyze the generated sequence and return several useful statistics
-    as both a dictionary and as a nicely formatted string report.
-    
-    Statistics Computed:
-      - unigram_diversity: Ratio of unique triplets to total triplets.
-      - repetition_rate: Fraction of repeated triplets.
-      - bigram_diversity: Ratio of unique consecutive pairs to total pairs.
-      - max_consecutive_repetitions: Maximum number of identical consecutive triplets.
-      - avg_candidate_probability (overfit rate): For the transitions (using a sliding window of size
-          MEMORY_LEN as context followed by candidate), the average probability of the chosen candidate
-          as per the training mapping.
-      
-      Additional Analytics:
-      - element_stats: For each element (index 0, 1, 2) in a triplet, includes:
-            * mean, standard deviation, minimum, maximum, and average consecutive absolute difference.
-      - avg_transition_entropy: The average entropy of the candidate distributions (from mapping_lookup)
-          for each transition context.
-      - context_coverage: The fraction of transitions (based on context of length MEMORY_LEN) that are found 
-          in the mapping_lookup.
-    
-    Parameters:
-      sequence: Generated sequence (tuple of triplets).
-      mapping_lookup: Precomputed mapping lookup.
-      memory_len: The context length used.
-    
-    Returns:
-      A tuple containing:
-          (stats_dict, stats_report_string)
-    """
-    stats = {}
-    seq_len = len(sequence)
-    
-    # --- Basic Statistics ---
-    
-    # Unigram.
-    unique_triplets = len(set(sequence))
-    stats["unigram_diversity"] = unique_triplets / seq_len
-    stats["repetition_rate"] = 1 - (unique_triplets / seq_len)
-    
-    # Bigram.
-    bigrams = [(sequence[i], sequence[i+1]) for i in range(seq_len - 1)]
-    unique_bigrams = len(set(bigrams))
-    stats["bigram_diversity"] = unique_bigrams / (seq_len - 1)
-    
-    # Maximum consecutive repetitions.
-    max_consecutive = 1
-    current_consecutive = 1
-    for i in range(1, seq_len):
-        if sequence[i] == sequence[i-1]:
-            current_consecutive += 1
-            if current_consecutive > max_consecutive:
-                max_consecutive = current_consecutive
-        else:
-            current_consecutive = 1
-    stats["max_consecutive_repetitions"] = max_consecutive
-
-    # Avg Candidate Probability (Overfit Rate)
-    overfit_probs = []
-    for i in range(memory_len, seq_len):
-        context = tuple(sequence[i - memory_len: i])
-        candidate = sequence[i]
-        if context in mapping_lookup:
-            candidates, frequencies = mapping_lookup[context]
-            total_freq = np.sum(frequencies)
-            try:
-                idx = candidates.index(candidate)
-                cand_prob = frequencies[idx] / total_freq
-                overfit_probs.append(cand_prob)
-            except ValueError:
-                pass
-    stats["avg_candidate_probability"] = np.mean(overfit_probs) if overfit_probs else None
-
-    # --- Additional Analytics ---
-
-    # 1. Element-Level Statistics.
-    seq_arr = np.array(sequence)  # shape: (seq_len, 3)
-    element_stats = {}
-    for dim in range(seq_arr.shape[1]):
-        values = seq_arr[:, dim]
-        mean_val = np.mean(values)
-        std_val = np.std(values)
-        min_val = np.min(values)
-        max_val = np.max(values)
-        # Calculate average absolute difference between consecutive values:
-        diffs = np.abs(np.diff(values))
-        avg_diff = np.mean(diffs) if diffs.size > 0 else 0
-        element_stats[f"element_{dim}"] = {
-            "mean": mean_val,
-            "std": std_val,
-            "min": min_val,
-            "max": max_val,
-            "avg_consecutive_diff": avg_diff,
-        }
-    stats["element_stats"] = element_stats
-
-    # 2. Transition Entropy:
-    entropies = []
-    valid_transitions = 0
-    for i in range(memory_len, seq_len):
-        context = tuple(sequence[i - memory_len: i])
-        if context in mapping_lookup:
-            candidates, freqs = mapping_lookup[context]
-            total_freq = np.sum(freqs)
-            if total_freq > 0:
-                probs = freqs / total_freq
-                # Add a very small constant to avoid log(0)
-                epsilon = 1e-10
-                entropy = -np.sum(probs * np.log(probs + epsilon))
-                entropies.append(entropy)
-                valid_transitions += 1
-    stats["avg_transition_entropy"] = np.mean(entropies) if entropies else None
-
-    # 3. Context Coverage:
-    total_transitions = seq_len - memory_len
-    stats["context_coverage"] = (valid_transitions / total_transitions) if total_transitions > 0 else None
-
-    # --- Build a Pretty Report String ---
-    sep_line = "-" * 60
-    lines = []
-    lines.append(sep_line)
-    lines.append("Sequence Analytics Report:")
-    lines.append(sep_line)
-    lines.append("Overall Statistics:")
-    lines.append(f"  Unigram Diversity         : {stats['unigram_diversity']:.3f}")
-    lines.append(f"  Repetition Rate           : {stats['repetition_rate']:.3f}")
-    lines.append(f"  Bigram Diversity          : {stats['bigram_diversity']:.3f}")
-    lines.append(f"  Max Consecutive Repetitions: {stats['max_consecutive_repetitions']}")
-    cand_prob = stats["avg_candidate_probability"]
-    cand_prob_str = f"{cand_prob:.3f}" if cand_prob is not None else "N/A"
-    lines.append(f"  Avg Candidate Probability : {cand_prob_str}")
-    lines.append("")
-    
-    lines.append("Element-Level Statistics:")
-    for dim in sorted(element_stats.keys()):
-        ed = element_stats[dim]
-        lines.append(f"  {dim.capitalize()}:")
-        lines.append(f"    Mean                 : {ed['mean']:.3f}")
-        lines.append(f"    Std Dev              : {ed['std']:.3f}")
-        lines.append(f"    Min                  : {ed['min']:.3f}")
-        lines.append(f"    Max                  : {ed['max']:.3f}")
-        lines.append(f"    Avg Consecutive Diff : {ed['avg_consecutive_diff']:.3f}")
-    lines.append("")
-
-    lines.append("Transition Statistics:")
-    avg_entropy = stats["avg_transition_entropy"]
-    entropy_str = f"{avg_entropy:.3f}" if avg_entropy is not None else "N/A"
-    lines.append(f"  Average Transition Entropy: {entropy_str}")
-    cc = stats["context_coverage"]
-    cc_str = f"{cc:.3f}" if cc is not None else "N/A"
-    lines.append(f"  Context Coverage          : {cc_str}")
-    lines.append(sep_line)
-    
-    stats_report = "\n".join(lines)
-    
-    # Return both the dictionary and the formatted report string.
-    return stats, stats_report
-
-###################################################################################
-
-def autoregressive_generate(start_seq, mel_tones, trg_array, trg_matches_array, num_new_tokens, chunk_len=5):
-    
-    # Convert sequences to NumPy arrays.
-    current_seq = np.array(start_seq, dtype=int)  # Shape: (num_tokens, token_dim)
-    trg_array = np.array(trg_array, dtype=int)      # Shape: (num_candidates, 2, token_dim)
-    start_len = len(start_seq)
-
-    midx = start_len-1
-    
-    # Deque for sliding memory of candidate pairs (immutable tuples).
-    recent_candidates = deque(maxlen=5)
-
-    while (len(current_seq) - start_len) < num_new_tokens:
-
-        midx += 1
-
-        # Get the last two tokens as context.
-        context = current_seq[-(chunk_len-1):]  # Shape: (2, token_dim)
-
-        sli = 0
-        msize = 0
-
-        ctx = context[:, :-1].reshape(1, -1)
-        trg_mat_arr = trg_matches_array
-
-        while msize < 8:
-
-            print('=== Slice', sli)
-        
-            # Compare context with candidates in trg_array.
-            match_mask = np.all(ctx == trg_mat_arr, axis=1)
-            match_indices = np.where(match_mask)[0]
-
-            msize = match_indices.size
-
-            if msize < 8:
-                sli += 1
-                ctx = context[:, :-1].reshape(1, -1)[:, sli:]
-                trg_mat_arr = trg_matches_array[:, :-sli]
-                
-        if match_indices.size == 0:
-            if len(current_seq) > start_len:
-
-                #tones_chord = sorted([mel_tones[midx], (mel_tones[midx]+7) % 12])
-                tones_chord = sorted([mel_tones[midx]])
-                new_tuple = [[mel_tones[midx], TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)]]               
-                current_seq = np.concatenate((current_seq, new_tuple), axis=0)
-                print('Subbed', midx)
-                continue
-
-        # From the matching candidates, filter out those whose candidate pair is in recent memory.
-        available_candidates = []
-        cseen = []
-        for idx in match_indices:
-
-            if idx not in recent_candidates:
-                # Convert candidate pair to an immutable tuple
-                candidate_pair = tuple(trg_array[idx].tolist())
-                if candidate_pair[-1][0] == mel_tones[midx] and candidate_pair[-1][1] not in cseen:
-                    available_candidates.append((idx, candidate_pair))
-                    cseen.append(candidate_pair[-1][1])
-
-        # If all candidates have recently been used, backtrack.
-        if len(available_candidates) < 3:
-            if len(current_seq) >= start_len:
-                #tones_chord = sorted([mel_tones[midx], (mel_tones[midx]+7) % 12])
-                tones_chord = sorted([mel_tones[midx]])
-                new_tuple = [[mel_tones[midx], TMIDIX.ALL_CHORDS_SORTED.index(tones_chord)]]               
-                current_seq = np.concatenate((current_seq, new_tuple), axis=0)
-                #rev_val = random.choice([-1, -2])
-                #current_seq = current_seq[:rev_val]
-                #print(midx)
-                #midx = len(current_seq)
-                #print('Reverted', midx, len(current_seq))
-                continue
-
-        else:
-            print(len(available_candidates))        
-            # Choose one available candidate at random.
-            chosen_idx, chosen_pair = available_candidates[np.random.choice(len(available_candidates))]
-            new_token = trg_array[chosen_idx][-1]  # The second token of the candidate pair.
-            
-    
-            # Append the new token to the sequence.
-            current_seq = np.concatenate((current_seq, new_token[None, :]), axis=0)
-    
-            recent_candidates.append(chosen_idx)
-
-            print('Gen seq len', len(current_seq))
-
-    return current_seq
-
-###################################################################################
-
-def minkowski_distance_vector_to_matrix(x: cp.ndarray, X: cp.ndarray, p: float = 3) -> cp.ndarray:
-    
-    """
-    Computes the Minkowski distance between a 1D CuPy array 'x' and each row of a 2D CuPy array 'X'.
-    
-    Parameters:
-        x (cp.ndarray): A 1D array with shape (n_features,) representing a single vector.
-        X (cp.ndarray): A 2D array with shape (n_samples, n_features) where each row is a vector.
-        p (float): The order of the Minkowski distance.
-                   For instance:
-                     - p=1 yields the Manhattan distance,
-                     - p=2 yields the Euclidean distance,
-                     - p=3 yields the Minkowski distance and will use the cube-root implementation,
-                     - p=∞ (or cp.inf) gives the Chebyshev distance.
-    
-    Returns:
-        cp.ndarray: A 1D array of length n_samples containing the Minkowski distance between 'x' 
-                    and the corresponding row in 'X'.
-    """
-
-    # Compute the element-wise absolute differences between x and every row in X.
-    # Broadcasting x over the rows of X results in an array of shape (n_samples, n_features).
-    diff = cp.abs(X - x)
-    
-    if p == float('inf') or p == cp.inf:
-        # For the Chebyshev distance, use the maximum absolute difference along the feature axis.
-        distances = cp.max(diff, axis=1)
-    elif p == 3:
-        # Instead of using the generic power operation (sum(diff**3) ** (1/3)),
-        # we use cp.cbrt for cube-root calculation when p is exactly 3.
-        distances = cp.cbrt(cp.sum(diff ** 3, axis=1))
-    else:
-        # For general Minkowski distance with finite p,
-        # compute the p-th power of differences, sum them, then take the p-th root.
-        distances = cp.sum(diff ** p, axis=1) ** (1.0 / p)
-        
-    return distances
-
-###################################################################################
-
-def pairwise_minkowski_distance(X: cp.ndarray, p: float = 2) -> cp.ndarray:
-    
-    """
-    Computes pairwise Minkowski distances for a 2D CuPy array.
-    
-    Parameters:
-        X (cp.ndarray): A 2D array of shape (n_samples, n_features), where each row represents a vector.
-        p (float): The order of the Minkowski distance.
-                   For example:
-                     - p=1 is the Manhattan distance,
-                     - p=2 is the Euclidean distance,
-                     - p=∞ (e.g., float('inf') or cp.inf) is the Chebyshev distance.
-    
-    Returns:
-        cp.ndarray: A 2D array of shape (n_samples, n_samples) containing the pairwise Minkowski distances.
-    """
-    
-    # Use broadcasting to compute the absolute difference between every pair of vectors.
-    # The result of X[:, None, :] - X[None, :, :] will have shape (n_samples, n_samples, n_features).
-    if p == float('inf') or p == cp.inf:
-        # For the Chebyshev distance, take the maximum absolute difference along the feature axis.
-        return cp.max(cp.abs(X[:, None, :] - X[None, :, :]), axis=-1)
-    else:
-        # Raise the absolute differences to the power p.
-        diff_powered = cp.abs(X[:, None, :] - X[None, :, :]) ** p
-        # Sum over the features for each pair (i, j) and then take the p-th root.
-        distances = cp.sum(diff_powered, axis=-1) ** (1.0 / p)
-        
-        return distances
-    
-###################################################################################
-
-def pairwise_cosine_similarity(X: cp.ndarray, eps: float = 1e-10) -> cp.ndarray:
-    
-    """
-    Computes the pairwise cosine similarity for a 2D CuPy array.
-    
-    Parameters:
-        X (cp.ndarray): A 2D array of shape (n_samples, n_features) where each row represents a vector.
-        eps (float): A small constant added to the denominator to prevent division by zero.
-    
-    Returns:
-        cp.ndarray: A 2D array of shape (n_samples, n_samples) containing the pairwise cosine similarities.
-    """
-    
-    # Compute the dot product between every pair of rows.
-    # This results in a matrix where element (i, j) is the dot product of X[i] and X[j].
-    dot_product = cp.dot(X, X.T)
-    
-    # Compute the L2 norm (Euclidean norm) for each row vector.
-    norms = cp.linalg.norm(X, axis=1)
-    
-    # Compute the outer product of the norms to form the denominator.
-    # The element (i, j) in this matrix is norms[i] * norms[j].
-    norm_matrix = cp.outer(norms, norms)
-    
-    # Compute the cosine similarity matrix.
-    # Adding a small epsilon (eps) to the denominator prevents division by zero.
-    cosine_similarity = dot_product / (norm_matrix + eps)
-    
-    return cosine_similarity
-
-###################################################################################
-
-print('Module is loaded!')
-print('Enjoy! :)')
-print('=' * 70)
-
-###################################################################################
-# This is the end of the TCUPY Python module
-###################################################################################

app.py

@@ -1,53 +1,324 @@
+# =================================================================
+#
+# Merged and Integrated Script for Audio/MIDI Processing and Rendering
+#
+# This script combines two functionalities:
+# 1. Transcribing audio (WAV/MP3) to MIDI using two methods:
+#    a) A general-purpose model (basic-pitch by Spotify).
+#    b) A model specialized for solo piano (ByteDance).
+# 2. Applying advanced transformations and re-rendering MIDI files using:
+#    a) Standard SoundFonts via FluidSynth.
+#    b) A custom 8-bit style synthesizer for a chiptune sound.
+#
+# The user can upload a WAV, MP3, or MIDI file.
+# - If an audio file is uploaded, it is first transcribed to MIDI using the selected method.
+# - The resulting MIDI (or an uploaded MIDI) can then be processed
+#   with various effects and rendered into audio.
+#
 #================================================================
+# Original sources:
+# https://huggingface.co/spaces/asigalov61/ByteDance-Solo-Piano-Audio-to-MIDI-Transcription
 # https://huggingface.co/spaces/asigalov61/Advanced-MIDI-Renderer
 #================================================================
 # Packages:
 #
 #   sudo apt install fluidsynth
 #
-#================================================================
+# =================================================================
 # Requirements:
-#   
-#   pip install gradio
-#   pip install numpy
-#   pip install scipy
-#   pip install matplotlib
-#   pip install networkx
-#   pip install scikit-learn
 #
-#================================================================
-# Core modules:
+#   pip install gradio torch pytz numpy scipy matplotlib networkx scikit-learn
+#   pip install piano_transcription_inference huggingface_hub
+#   pip install basic-pitch pretty_midi librosa
 #
-# git clone --depth 1 https://github.com/asigalov61/tegridy-tools
+# =================================================================
+# Core modules:
 #
-# import TMIDIX
-# import TPLOTS
-# import midi_to_colab_audio
+#   git clone --depth 1 https://github.com/asigalov61/tegridy-tools
 #
-#================================================================
+# =================================================================
 
 import os
 import hashlib
-
-import time
-import datetime
-from pytz import timezone
-
+import time as reqtime
 import copy
-from collections import Counter
-import random
-import statistics
 
+import torch
 import gradio as gr
 
-import TMIDIX
-import TPLOTS
+from src.piano_transcription.utils import initialize_app
+
+from piano_transcription_inference  import PianoTranscription, utilities, sample_rate as transcription_sample_rate
+
+# --- Import core transcription and MIDI processing libraries ---
+from src import TMIDIX, TPLOTS
+from src import MIDI
+from src.midi_to_colab_audio import midi_to_colab_audio
+
+# --- Imports for General Purpose Transcription (basic-pitch) ---
+import basic_pitch
+from basic_pitch.inference import predict
+from basic_pitch import ICASSP_2022_MODEL_PATH
+
+# --- Imports for 8-bit Synthesizer ---
+import pretty_midi
+import numpy as np
+from scipy import signal
+
+# =================================================================================================
+# === Hugging Face SoundFont Downloader ===
+# =================================================================================================
+from huggingface_hub import hf_hub_download
+import glob
+
+# --- Define a constant for the 8-bit synthesizer option ---
+SYNTH_8_BIT_LABEL = "None (8-bit Synthesizer)"
+
+def prepare_soundfonts():
+    """
+    Ensures a default set of SoundFonts are downloaded, then scans the 'src/sf2'
+    directory recursively for all .sf2 files.
+    Returns a dictionary mapping a user-friendly name to its full file path, with
+    default soundfonts listed first in their specified order.
+
+    Downloads soundfont files from the specified Hugging Face Space repository
+    to a local 'src/sf2' directory if they don't already exist.
+    Returns a list of local paths to the soundfont files.
+    """
+    SF2_REPO_ID = "asigalov61/Advanced-MIDI-Renderer"
+    SF2_DIR = "src/sf2"
+    # This list is now just for ensuring default files exist
+    # {"Super GM": 0, "Orpheus GM": 1, "Live HQ GM": 2, "Nice Strings + Orchestra": 3, "Real Choir": 4, "Super Game Boy": 5, "Proto Square": 6}
+    DEFAULT_SF2_FILENAMES = [
+        "SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2",
+        "Orpheus_18.06.2020.sf2",
+        "Live HQ Natural SoundFont GM.sf2",
+        "Nice-Strings-PlusOrchestra-v1.6.sf2",
+        "KBH-Real-Choir-V2.5.sf2",
+        "SuperGameBoy.sf2",
+        "ProtoSquare.sf2"
+    ]
+
+    # Create the target directory if it doesn't exist
+    os.makedirs(SF2_DIR, exist_ok=True)
+    
+    # --- Step 1: Ensure default SoundFonts are available ---
+    print("Checking for SoundFont files...")
+    for filename in DEFAULT_SF2_FILENAMES:
+        local_path = os.path.join(SF2_DIR, filename)
+        
+        # Check if the file already exists locally to avoid re-downloading
+        if not os.path.exists(local_path):
+            print(f"Downloading '{filename}' from Hugging Face Hub...")
+            try:
+                # Use hf_hub_download to get the file
+                # It will be downloaded to the specified local directory
+                hf_hub_download(
+                    repo_id=SF2_REPO_ID,
+                    repo_type='space',  # Specify that the repository is a Space
+                    filename=f"{filename}",  # The path to the file within the repository
+                    local_dir=SF2_DIR,
+                    # local_dir_use_symlinks=False  # Copy file to the dir for a clean folder structure
+                )
+                print(f"'{filename}' downloaded successfully.")
+            except Exception as e:
+                print(f"Error downloading {filename}: {e}")
+                # If download fails, we might not be able to use this soundfont
+
+    # --- Step 2: Scan the entire directory for all .sf2 files ---
+    print(f"Scanning '{SF2_DIR}' for all .sf2 files...")
+    all_sfs_map = {}
+    # Use glob with recursive=True to find all .sf2 files in subdirectories
+    search_pattern = os.path.join(SF2_DIR, '**', '*.sf2')
+    for full_path in glob.glob(search_pattern, recursive=True):
+        # Create a user-friendly display name, including subfolder if it exists
+        relative_path = os.path.relpath(full_path, SF2_DIR)
+        display_name = os.path.splitext(relative_path)[0].replace("\\", "/") # Use forward slashes for consistency
+        all_sfs_map[display_name] = full_path
+        
+    # --- Step 3: Create the final ordered dictionary based on priority ---
+    ordered_soundfont_map = {}
+
+    # Create display names for default files (filename without extension)
+    default_display_names = [os.path.splitext(f)[0] for f in DEFAULT_SF2_FILENAMES]
+    
+    # Separate other files from the default ones
+    other_display_names = [name for name in all_sfs_map.keys() if name not in default_display_names]
+    other_display_names.sort() # Sort the rest alphabetically
+
+    # Add default soundfonts first, maintaining the order from DEFAULT_SF2_FILENAMES
+    for name in default_display_names:
+        if name in all_sfs_map: # Check if the file was actually found by the scanner
+            ordered_soundfont_map[name] = all_sfs_map[name]
+            
+    # Add all other soundfonts after the default ones
+    for name in other_display_names:
+        ordered_soundfont_map[name] = all_sfs_map[name]
+
+    return ordered_soundfont_map
+
+# =================================================================================================
+# === 8-bit Style Synthesizer ===
+# =================================================================================================
+def synthesize_8bit_style(midi_data, waveform_type, envelope_type, decay_time_s, pulse_width, vibrato_rate, vibrato_depth, fs=44100):
+    """
+    Synthesizes an 8-bit style audio waveform from a PrettyMIDI object.
+    This function generates waveforms manually instead of using a synthesizer like FluidSynth.
+    """
+    total_duration = midi_data.get_end_time()
+    waveform = np.zeros(int(total_duration * fs) + fs)
+
+    for instrument in midi_data.instruments:
+        for note in instrument.notes:
+            freq = pretty_midi.note_number_to_hz(note.pitch)
+            note_duration = note.end - note.start
+            num_samples = int(note_duration * fs)
+            if num_samples == 0:
+                continue
+
+            t = np.linspace(0., note_duration, num_samples, endpoint=False)
+            
+            # --- Vibrato LFO ---
+            vibrato_lfo = vibrato_depth * np.sin(2 * np.pi * vibrato_rate * t)
+
+            # --- Waveform Generation ---
+            if waveform_type == 'Square':
+                note_waveform = signal.square(2 * np.pi * (freq + vibrato_lfo) * t, duty=pulse_width)
+            elif waveform_type == 'Sawtooth':
+                note_waveform = signal.sawtooth(2 * np.pi * (freq + vibrato_lfo) * t)
+            elif waveform_type == 'Triangle':
+                note_waveform = signal.sawtooth(2 * np.pi * (freq + vibrato_lfo) * t, width=0.5)
+
+            # --- ADSR Envelope ---
+            start_amp = note.velocity / 127.0
+            envelope = np.zeros(num_samples)
+            
+            if envelope_type == 'Plucky (AD Envelope)' and num_samples > 0:
+                attack_time_s = 0.005
+                attack_samples = min(int(attack_time_s * fs), num_samples)
+                decay_samples = min(int(decay_time_s * fs), num_samples - attack_samples)
+                
+                envelope[:attack_samples] = np.linspace(0, start_amp, attack_samples)
+                if decay_samples > 0:
+                    envelope[attack_samples:attack_samples+decay_samples] = np.linspace(start_amp, 0, decay_samples)
+            elif envelope_type == 'Sustained (Full Decay)' and num_samples > 0:
+                envelope = np.linspace(start_amp, 0, num_samples)
+
+            note_waveform *= envelope
+
+            start_sample = int(note.start * fs)
+            end_sample = start_sample + num_samples
+            if end_sample > len(waveform):
+                end_sample = len(waveform)
+                note_waveform = note_waveform[:end_sample-start_sample]
+            
+            waveform[start_sample:end_sample] += note_waveform
+            
+    return waveform
+
+# =================================================================================================
+# === Stage 1: Audio to MIDI Transcription Functions ===
+# =================================================================================================
+
+def TranscribePianoAudio(input_file):
+    """
+    Transcribes a WAV or MP3 audio file of a SOLO PIANO performance into a MIDI file.
+    This uses the ByteDance model.
+    Args:
+        input_file_path (str): The path to the input audio file.
+    Returns:
+        str: The file path of the generated MIDI file.
+    """
+    print('=' * 70)
+    print('STAGE 1: Starting Piano-Specific Transcription')
+    print('=' * 70)
+
+    # Generate a unique output filename for the MIDI
+    fn = os.path.basename(input_file)
+    fn1 = fn.split('.')[0]
+
+    # Use os.path.join to create a platform-independent directory path
+    output_dir = os.path.join("output", "transcribed_piano_")
+    out_mid_path = os.path.join(output_dir, fn1 + '.mid')
+
+    # Check for the directory's existence and create it if necessary
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    print('-' * 70)
+    print(f'Input file name: {fn}')
+    print(f'Output MIDI path: {out_mid_path}')
+    print('-' * 70)
+    
+    # Load audio using the utility function
+    print('Loading audio...')
+    (audio, _) = utilities.load_audio(input_file, sr=transcription_sample_rate, mono=True)
+    print('Audio loaded successfully.')
+    print('-' * 70)
+    
+    # Initialize the transcription model
+    # Use 'cuda' if a GPU is available and configured, otherwise 'cpu'
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f'Loading transcriptor model... device= {device}')
+    transcriptor = PianoTranscription(device=device, checkpoint_path="src/models/CRNN_note_F1=0.9677_pedal_F1=0.9186.pth")
+    print('Transcriptor loaded.')
+    print('-' * 70)
+    
+    # Perform transcription
+    print('Transcribing audio to MIDI (Piano-Specific)...')
+    # This function call saves the MIDI file to the specified path
+    transcriptor.transcribe(audio, out_mid_path)
+    print('Piano transcription complete.')
+    print('=' * 70)
+    
+    # Return the path to the newly created MIDI file
+    return out_mid_path
+
+def TranscribeGeneralAudio(input_file, onset_thresh, frame_thresh, min_note_len, min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool):
+    """
+    Transcribes a general audio file (WAV/MP3) into a MIDI file using basic-pitch.
+    This is suitable for various instruments and vocals.
+    """
+    print('=' * 70)
+    print('STAGE 1: Starting General Purpose Transcription')
+    print('=' * 70)
+
+    fn = os.path.basename(input_file)
+    fn1 = fn.split('.')[0]
+    output_dir = os.path.join("output", "transcribed_general_")
+    out_mid_path = os.path.join(output_dir, fn1 + '.mid')
+    os.makedirs(output_dir, exist_ok=True)
 
-from midi_to_colab_audio import midi_to_colab_audio
+    print(f'Input file: {fn}\nOutput MIDI: {out_mid_path}')
+    
+    # --- Perform transcription using basic-pitch ---
+    print('Transcribing audio to MIDI (General Purpose)...')
+    # The predict function handles audio loading internally
+    model_output, midi_data, note_events = basic_pitch.inference.predict(
+        audio_path=input_file,
+        model_or_model_path=ICASSP_2022_MODEL_PATH,
+        onset_threshold=onset_thresh,
+        frame_threshold=frame_thresh,
+        minimum_note_length=min_note_len,
+        minimum_frequency=min_freq,
+        maximum_frequency=max_freq,
+        infer_onsets=infer_onsets_bool,
+        melodia_trick=melodia_trick_bool,
+        multiple_pitch_bends=multiple_bends_bool
+    )
+    
+    # --- Save the MIDI file ---
+    midi_data.write(out_mid_path)
+    print('General transcription complete.')
+    print('=' * 70)
+    
+    return out_mid_path
 
-#==========================================================================================================
+# =================================================================================================
+# === Stage 2: MIDI Transformation and Rendering Function ===
+# =================================================================================================
 
-def Render_MIDI(input_midi, 
+def Render_MIDI(input_midi_path, 
                 render_type, 
                 soundfont_bank, 
                 render_sample_rate,
@@ -58,70 +329,83 @@ def Render_MIDI(input_midi,
                 render_transpose_value,
                 render_transpose_to_C4,
                 render_output_as_solo_piano,
-                render_remove_drums 
+                render_remove_drums,
+                # --- 8-bit synth params ---
+                s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
+                s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth
                 ):
-    
+    """
+    Processes and renders a MIDI file according to user-defined settings.
+    Can render using SoundFonts or a custom 8-bit synthesizer.
+    Args:
+        input_midi_path (str): The path to the input MIDI file.
+        All other arguments are rendering options from the Gradio UI.
+    Returns:
+        A tuple containing all the output elements for the Gradio UI.
+    """
+    print('*' * 70)
+    print('STAGE 2: Starting MIDI Rendering')
     print('*' * 70)
-    print('Req start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-    start_time = time.time()
-    
-    print('=' * 70)
-    print('Loading MIDI...')
 
-    fn = os.path.basename(input_midi)
+    # --- File and Settings Setup ---
+    fn = os.path.basename(input_midi_path)
     fn1 = fn.split('.')[0]
-
-    fdata = open(input_midi, 'rb').read()
-
-    input_midi_md5hash = hashlib.md5(fdata).hexdigest()
     
+    # Use os.path.join to create a platform-independent directory path
+    output_dir = os.path.join("output", "rendered_midi")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    # Now, join the clean directory path with the filename
+    new_fn_path = os.path.join(output_dir, fn1 + '_rendered.mid')
+
+    try:
+        with open(input_midi_path, 'rb') as f:
+            fdata = f.read()
+        input_midi_md5hash = hashlib.md5(fdata).hexdigest()
+    except FileNotFoundError:
+        # Handle cases where the input file might not exist
+        print(f"Error: Input MIDI file not found at {input_midi_path}")
+        return [None] * 7 # Return empty values for all outputs
+
     print('=' * 70)
     print('Requested settings:')
-    print('=' * 70)
-    print('Input MIDI file name:', fn)
-    print('Input MIDI md5 hash', input_midi_md5hash)
+    print(f'Input MIDI file name: {fn}')
+    print(f'Input MIDI md5 hash: {input_midi_md5hash}')
     print('-' * 70)
-    print('Render type:', render_type)
-    print('Soudnfont bank', soundfont_bank)
-    print('Audio render sample rate', render_sample_rate)
-
-    if render_type != 'Render as-is':
-        print('Render with sustains:', render_with_sustains)
-        print('Merge misaligned notes:', merge_misaligned_notes)
-        print('Custom MIDI render patch', custom_render_patch)
-        print('Align to bars:', render_align)
-        print('Transpose value:', render_transpose_value)
-        print('Transpose to C4', render_transpose_to_C4)
-        print('Output as Solo Piano', render_output_as_solo_piano)
-        print('Remove drums:', render_remove_drums)
-
+    print(f'Render type: {render_type}')
+    print(f'Soundfont bank: {soundfont_bank}')
+    print(f'Audio render sample rate: {render_sample_rate}')
+    # ... (add other print statements for settings if needed)
     print('=' * 70)
-    print('Processing MIDI...Please wait...')
-    
-    #=======================================================
-    # START PROCESSING
-
-    raw_score = TMIDIX.midi2single_track_ms_score(fdata)
     
+    # --- MIDI Processing using TMIDIX ---
+    print('Processing MIDI... Please wait...')
+    raw_score = MIDI.midi2single_track_ms_score(fdata)
     escore = TMIDIX.advanced_score_processor(raw_score, 
                                              return_enhanced_score_notes=True, 
                                              apply_sustain=render_with_sustains
                                             )[0]
 
+    # Handle cases where the MIDI might not contain any notes
+    if not escore:
+        print("Warning: MIDI file contains no processable notes.")
+        return ("N/A", fn1, "MIDI file contains no notes.",None, None, None, "No notes found.")
+
+    # This line will now work correctly because merge_misaligned_notes is guaranteed to be an integer.
     if merge_misaligned_notes > 0:
         escore = TMIDIX.merge_escore_notes(escore, merge_threshold=merge_misaligned_notes)
-
+        
     escore = TMIDIX.augment_enhanced_score_notes(escore, timings_divider=1)
-
-    first_note_index = [e[0] for e in raw_score[1]].index('note')
     
+    first_note_index = [e[0] for e in raw_score[1]].index('note')
     cscore = TMIDIX.chordify_score([1000, escore])
 
     meta_data = raw_score[1][:first_note_index] + [escore[0]] + [escore[-1]] + [raw_score[1][-1]]
 
     aux_escore_notes = TMIDIX.augment_enhanced_score_notes(escore, sort_drums_last=True)
     song_description = TMIDIX.escore_notes_to_text_description(aux_escore_notes)
-    
+
     print('Done!')
     print('=' * 70)
     print('Input MIDI metadata:', meta_data[:5])
@@ -130,28 +414,24 @@ def Render_MIDI(input_midi,
     print('=' * 70)
     print('Processing...Please wait...')
 
+    # A deep copy of the score to be modified
     output_score = copy.deepcopy(escore)
 
+    # Apply transformations based on render_type
     if render_type == "Extract melody":
         output_score = TMIDIX.add_melody_to_enhanced_score_notes(escore, return_melody=True)
         output_score = TMIDIX.recalculate_score_timings(output_score)
-
     elif render_type == "Flip":
         output_score = TMIDIX.flip_enhanced_score_notes(escore)
-        
     elif render_type == "Reverse":
         output_score = TMIDIX.reverse_enhanced_score_notes(escore)
-
     elif render_type == 'Repair Durations':
         output_score = TMIDIX.fix_escore_notes_durations(escore, min_notes_gap=0)
-    
     elif render_type == 'Repair Chords':
         fixed_cscore = TMIDIX.advanced_check_and_fix_chords_in_chordified_score(cscore)[0]
         output_score = TMIDIX.flatten(fixed_cscore)
-
     elif render_type == 'Remove Duplicate Pitches':
         output_score = TMIDIX.remove_duplicate_pitches_from_escore_notes(escore)
-    
     elif render_type == "Add Drum Track":
         nd_escore = [e for e in escore if e[3] != 9]
         nd_escore = TMIDIX.augment_enhanced_score_notes(nd_escore)
@@ -161,38 +441,27 @@ def Render_MIDI(input_midi,
             e[1] *= 16
             e[2] *= 16
 
-    print('Done processing!')
-    print('=' * 70)
-    
-    print('Repatching if needed...')
-    print('=' * 70)
-
-    if -1 < custom_render_patch < 128:
-        for e in output_score:
-            if e[3] != 9:
-                e[6] = custom_render_patch
-        
-    print('Done repatching!')
-    print('=' * 70)
-    
-    print('Sample output events', output_score[:5])
+    print('MIDI processing complete.')
     print('=' * 70)
-    print('Final processing...')
-    
-    new_fn = fn1+'.mid'
 
+    # --- Final Processing and Patching ---
     if render_type != "Render as-is":
-
+        print('Applying final adjustments (transpose, align, patch)...')
+        if custom_render_patch != -1: # -1 indicates no change
+            for e in output_score:
+                if e[3] != 9: # not a drum channel
+                    e[6] = custom_render_patch
+    
         if render_transpose_value != 0:
             output_score = TMIDIX.transpose_escore_notes(output_score, render_transpose_value)
 
         if render_transpose_to_C4:
-            output_score = TMIDIX.transpose_escore_notes_to_pitch(output_score)
+            output_score = TMIDIX.transpose_escore_notes_to_pitch(output_score, 60) # C4 is MIDI pitch 60
 
         if render_align == "Start Times":
             output_score = TMIDIX.recalculate_score_timings(output_score)
             output_score = TMIDIX.align_escore_notes_to_bars(output_score)
-    
+
         elif render_align == "Start Times and Durations":
             output_score = TMIDIX.recalculate_score_timings(output_score)
             output_score = TMIDIX.align_escore_notes_to_bars(output_score, trim_durations=True)
@@ -204,38 +473,38 @@ def Render_MIDI(input_midi,
         if render_type == "Longest Repeating Phrase":
             zscore = TMIDIX.recalculate_score_timings(output_score)
             lrno_score = TMIDIX.escore_notes_lrno_pattern_fast(zscore)
-
+    
             if lrno_score is not None:
                 output_score = lrno_score
-
+    
             else:
                 output_score = TMIDIX.recalculate_score_timings(TMIDIX.escore_notes_middle(output_score, 50))
-
+    
         if render_type == "Multi-Instrumental Summary":
             zscore = TMIDIX.recalculate_score_timings(output_score)
             c_escore_notes = TMIDIX.compress_patches_in_escore_notes_chords(zscore)
-            
+        
             if len(c_escore_notes) > 128:
                 cmatrix = TMIDIX.escore_notes_to_image_matrix(c_escore_notes, filter_out_zero_rows=True, filter_out_duplicate_rows=True)
                 smatrix = TPLOTS.square_image_matrix(cmatrix, num_pca_components=max(1, min(5, len(c_escore_notes) // 128)))
                 output_score = TMIDIX.image_matrix_to_original_escore_notes(smatrix)
-                
+            
                 for o in output_score:
                     o[1] *= 250
-                    o[2] *= 250            
+                    o[2] *= 250
 
         if render_output_as_solo_piano:
-            output_score = TMIDIX.solo_piano_escore_notes(output_score, keep_drums=True)
-            
-        if render_remove_drums:
+            output_score = TMIDIX.solo_piano_escore_notes(output_score, keep_drums=(not render_remove_drums))
+        
+        if render_remove_drums and not render_output_as_solo_piano:
             output_score = TMIDIX.strip_drums_from_escore_notes(output_score)
-            
+          
         if render_type == "Solo Piano Summary":
             sp_escore_notes = TMIDIX.solo_piano_escore_notes(output_score, keep_drums=False)
             zscore = TMIDIX.recalculate_score_timings(sp_escore_notes)
-
+    
             if len(zscore) > 128:
-                
+            
                 bmatrix = TMIDIX.escore_notes_to_binary_matrix(zscore)
                 cmatrix = TMIDIX.compress_binary_matrix(bmatrix, only_compress_zeros=True)
                 smatrix = TPLOTS.square_binary_matrix(cmatrix, interpolation_order=max(1, min(5, len(zscore) // 128)))
@@ -244,221 +513,338 @@ def Render_MIDI(input_midi,
                 for o in output_score:
                     o[1] *= 200
                     o[2] *= 200
-            
-        SONG, patches, overflow_patches = TMIDIX.patch_enhanced_score_notes(output_score)
-                    
-        detailed_stats = TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(SONG,
-                                                                  output_signature = 'Advanced MIDI Renderer',
-                                                                  output_file_name = fn1,
-                                                                  track_name='Project Los Angeles',
-                                                                  list_of_MIDI_patches=patches
-                                                                  )
 
-    else:
-        with open(new_fn, 'wb') as f:
-            f.write(fdata)
-            f.close()
-            
-    if soundfont_bank in ["Super GM",
-                            "Orpheus GM",
-                            "Live HQ GM",
-                            "Nice Strings + Orchestra", 
-                            "Real Choir", 
-                            "Super Game Boy", 
-                            "Proto Square"
-                            ]:
+        print('Final adjustments complete.')
+        print('=' * 70)
         
-        sf2bank = ["Super GM",
-                    "Orpheus GM",
-                    "Live HQ GM",
-                    "Nice Strings + Orchestra", 
-                    "Real Choir", 
-                    "Super Game Boy", 
-                    "Proto Square"
-                    ].index(soundfont_bank)
-    
+    # --- Saving Processed MIDI File ---
+        # Save the transformed MIDI data
+        SONG, patches, _ = TMIDIX.patch_enhanced_score_notes(output_score)
+        
+        # The underlying function mistakenly adds a '.mid' extension.
+        # We must pass the path without the extension to compensate.
+        path_without_ext = new_fn_path.rsplit('.mid', 1)[0]
+
+        TMIDIX.Tegridy_ms_SONG_to_MIDI_Converter(SONG,
+                                                  output_signature = 'Integrated-MIDI-Processor',
+                                                  output_file_name = path_without_ext,
+                                                  track_name='Processed Track',
+                                                  list_of_MIDI_patches=patches
+                                                  )
+        midi_to_render_path = new_fn_path
     else:
-        sf2bank = 0
+        # If "Render as-is", use the original MIDI data
+        with open(new_fn_path, 'wb') as f:
+            f.write(fdata)
+        midi_to_render_path = new_fn_path
+
+    # --- Audio Rendering ---
+    print('Rendering final audio...')
 
-    if render_sample_rate in ["16000", "32000", "44100"]:
-        srate = int(render_sample_rate)
+    # Select sample rate
+    srate = int(render_sample_rate)
     
+    # --- Conditional Rendering Logic ---
+    if soundfont_bank == SYNTH_8_BIT_LABEL:
+        print("Using 8-bit style synthesizer...")
+        try:
+            # Load the MIDI file with pretty_midi for manual synthesis
+            midi_data_for_synth = pretty_midi.PrettyMIDI(midi_to_render_path)
+            # Synthesize the waveform
+            audio = synthesize_8bit_style(
+                midi_data_for_synth,
+                s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
+                s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth,
+                fs=srate
+            )
+            # Normalize audio
+            peak_val = np.max(np.abs(audio))
+            if peak_val > 0:
+                audio /= peak_val
+            audio = (audio * 32767).astype(np.int16)
+        except Exception as e:
+            print(f"Error during 8-bit synthesis: {e}")
+            return [None] * 7
     else:
-        srate = 16000
+        print(f"Using SoundFont: {soundfont_bank}")
+        # Get the full path from the global dictionary
+        soundfont_path = soundfonts_dict.get(soundfont_bank)
+
+        # Select soundfont
+        if not soundfont_path or not os.path.exists(soundfont_path):
+            # Error handling in case the selected file is not found
+            error_msg = f"SoundFont '{soundfont_bank}' not found!"
+            print(f"ERROR: {error_msg}")
+            # Fallback to the first available soundfont if possible
+            if soundfonts_dict:
+                fallback_key = list(soundfonts_dict.keys())[0]
+                soundfont_path = soundfonts_dict[fallback_key]
+                print(f"Falling back to '{fallback_key}'.")
+            else:
+                # If no soundfonts are available at all, raise an error
+                raise gr.Error("No SoundFonts are available for rendering!")
 
-    print('-' * 70)
-    print('Generating audio with SF2 bank', sf2bank, 'and', srate, 'Hz sample rate')
-    
-    audio = midi_to_colab_audio(new_fn, 
-                        soundfont_path=soundfonts[sf2bank],
-                        sample_rate=srate,
-                        output_for_gradio=True
-                        )
+        with open(midi_to_render_path, 'rb') as f:
+            midi_file_content = f.read()
 
-    print('-' * 70)
-
-    new_md5_hash = hashlib.md5(open(new_fn,'rb').read()).hexdigest()
+        audio = midi_to_colab_audio(midi_file_content, 
+                                    soundfont_path=soundfont_path, # Use the dynamically found path
+                                    sample_rate=srate,
+                                    output_for_gradio=True
+                                    )
     
-    print('Done!')
+    print('Audio rendering complete.')
     print('=' * 70)
 
-    #========================================================
+    # --- Preparing Outputs for Gradio ---
+    with open(midi_to_render_path, 'rb') as f:
+        new_md5_hash = hashlib.md5(f.read()).hexdigest()
+    output_plot = TPLOTS.plot_ms_SONG(output_score, plot_title=f"Score of {fn1}", return_plt=True)
 
-    output_midi_md5 = str(new_md5_hash)
-    output_midi_title = str(fn1)
     output_midi_summary = str(meta_data)
-    output_midi = str(new_fn)
-    output_audio = (srate, audio)
     
-    output_plot = TMIDIX.plot_ms_SONG(output_score, plot_title=output_midi, return_plt=True)
-
-    print('Output MIDI file name:', output_midi)
-    print('Output MIDI title:', output_midi_title)
-    print('Output MIDI hash:', output_midi_md5)
-    print('Output MIDI summary:', output_midi_summary[:5])
-    print('=' * 70) 
+    return new_md5_hash, fn1, output_midi_summary, midi_to_render_path, (srate, audio), output_plot, song_description
+
+# =================================================================================================
+# === Main Application Logic ===
+# =================================================================================================
+
+def process_and_render_file(input_file, 
+                            # --- Transcription params ---
+                            transcription_method,
+                            onset_thresh, frame_thresh, min_note_len, min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool,
+                            # --- MIDI rendering params ---
+                            render_type, soundfont_bank, render_sample_rate,
+                            render_with_sustains, merge_misaligned_notes, custom_render_patch, render_align,
+                            render_transpose_value, render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
+                            # --- 8-bit synth params ---
+                            s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
+                            s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth
+                           ):
+    """
+    Main function to handle file processing. It determines the file type and calls the
+    appropriate functions for transcription and/or rendering based on user selections.
+    """
+    start_time = reqtime.time()
+    if input_file is None:
+        # Return a list of updates to clear all output fields
+        num_outputs = 7 
+        return [gr.update(value=None)] * num_outputs
+
+    # The input_file from gr.Audio(type="filepath") is now the direct path (a string),
+    # not a temporary file object. We no longer need to access the .name attribute.
+    input_file_path = input_file
+    filename = os.path.basename(input_file_path)
+    print(f"Processing new file: {filename}")
+
+    # --- Step 1: Check file type and transcribe if necessary ---
+    if filename.lower().endswith(('.mid', '.midi', '.kar')):
+        print("MIDI file detected. Proceeding directly to rendering.")
+        midi_path_for_rendering = input_file_path
+    else: #if filename.lower().endswith(('.wav', '.mp3'))
+        print("Audio file detected. Starting transcription...")
+        try:
+            if transcription_method == "General Purpose":
+                midi_path_for_rendering = TranscribeGeneralAudio(
+                    input_file_path, onset_thresh, frame_thresh, min_note_len, 
+                    min_freq, max_freq, infer_onsets_bool, melodia_trick_bool, multiple_bends_bool
+                )
+            else: # Piano-Specific
+                midi_path_for_rendering = TranscribePianoAudio(input_file_path)
+        except Exception as e:
+            print(f"An error occurred during transcription: {e}")
+            raise gr.Error(f"Transcription Failed: {e}")
+
+    # --- Step 2: Render the MIDI file with selected options ---
+    print(f"Proceeding to render MIDI file: {os.path.basename(midi_path_for_rendering)}")
+    results = Render_MIDI(midi_path_for_rendering,
+                          render_type, soundfont_bank, render_sample_rate,
+                          render_with_sustains, merge_misaligned_notes, custom_render_patch, render_align,
+                          render_transpose_value, render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
+                          s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
+                          s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth)
     
-    #========================================================
-
-    print('Req end time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-    print('-' * 70)
-    print('Req execution time:', (time.time() - start_time), 'sec')
+    print(f'Total processing time: {(reqtime.time() - start_time):.2f} sec')
     print('*' * 70)
     
-    #========================================================
-    
-    return output_midi_md5, output_midi_title, output_midi_summary, output_midi, output_audio, output_plot, song_description
+    return results
+
+# =================================================================================================
+# === Gradio UI Setup ===
+# =================================================================================================
+
+def update_ui_visibility(transcription_method, soundfont_choice):
+    """
+    Dynamically updates the visibility of UI components based on user selections.
+    """
+    is_general = (transcription_method == "General Purpose")
+    is_8bit = (soundfont_choice == SYNTH_8_BIT_LABEL)
     
-#==========================================================================================================
+    return {
+        general_transcription_settings: gr.update(visible=is_general),
+        synth_8bit_settings: gr.update(visible=is_8bit),
+    }
 
 if __name__ == "__main__":
-
-    PDT = timezone('US/Pacific')
+    # Initialize the app: download model (if needed) and apply patches
+    # Set to False if you don't have 'requests' or 'tqdm' installed
+    initialize_app()
     
-    print('=' * 70)
-    print('App start time: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now(PDT)))
-    print('=' * 70)
+    # --- Prepare soundfonts and make the map globally accessible ---
+    global soundfonts_dict
+    # On application start, download SoundFonts from Hugging Face Hub if they don't exist.
+    soundfonts_dict = prepare_soundfonts()
+    print(f"Found {len(soundfonts_dict)} local SoundFonts.")
 
-    soundfonts = ["SGM-v2.01-YamahaGrand-Guit-Bass-v2.7.sf2",
-                  "Orpheus_18.06.2020.sf2",
-                  "Live HQ Natural SoundFont GM.sf2",
-                  "Nice-Strings-PlusOrchestra-v1.6.sf2", 
-                  "KBH-Real-Choir-V2.5.sf2", 
-                  "SuperGameBoy.sf2", 
-                  "ProtoSquare.sf2"
-                 ]
+    if not soundfonts_dict:
+        print("\nWARNING: No SoundFonts were found or could be downloaded.")
+        print("Rendering with SoundFonts will fail. Only the 8-bit synthesizer will be available.")
 
-    app = gr.Blocks()
+    app = gr.Blocks(theme=gr.themes.Base())
     
     with app:
+        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Audio-to-MIDI & Advanced Renderer</h1>")
+        gr.Markdown(
+            "**Upload a WAV/MP3 for transcription-then-rendering, or a MIDI for rendering-only.**\n\n"
+            "This application combines piano audio transcription with a powerful MIDI transformation and rendering toolkit. "
+            "Based on the work of [asigalov61](https://github.com/asigalov61)."
+        )
         
-        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Advanced MIDI Renderer</h1>")
-        gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>Transform and render any MIDI</h1>")
-        
-        gr.Markdown("![Visitors](https://api.visitorbadge.io/api/visitors?path=asigalov61.Advanced-MIDI-Renderer&style=flat)\n\n"
-                    "This is a demo for tegridy-tools\n\n"
-                    "Please see [tegridy-tools](https://github.com/asigalov61/tegridy-tools) GitHub repo for more information\n\n"
-                   )
-        
-        gr.Markdown("## Upload your MIDI")
-        
-        input_midi = gr.File(label="Input MIDI", file_types=[".midi", ".mid", ".kar"], type="filepath")
-
-        gr.Markdown("## Select desired Sound Font bank and render sample rate")
-
-        soundfont_bank = gr.Radio(["Super GM",
-                                   "Orpheus GM",
-                                   "Live HQ GM",
-                                   "Nice Strings + Orchestra", 
-                                   "Real Choir", 
-                                   "Super Game Boy", 
-                                   "Proto Square"
-                                  ], 
-                                  label="SoundFont bank", 
-                                  value="Super GM"
-                                 )
-
-        render_sample_rate = gr.Radio(["16000", 
-                                       "32000", 
-                                       "44100"
-                                      ], 
-                                      label="MIDI audio render sample rate", 
-                                      value="16000"
-                                     )
-
-        gr.Markdown("## Select desired render type")
-
-        render_type = gr.Radio(["Render as-is", 
-                                "Custom render", 
-                                "Extract melody", 
-                                "Flip", 
-                                "Reverse",
-                                "Repair Durations",
-                                "Repair Chords",
-                                "Remove Duplicate Pitches",
-                                "Longest Repeating Phrase",
-                                "Multi-Instrumental Summary",
-                                "Solo Piano Summary",
-                                "Add Drum Track"
-                               ], 
-                               label="Render type", 
-                               value="Render as-is"
-                              )
-
-        gr.Markdown("## Select custom render options")
-
-        render_with_sustains = gr.Checkbox(label="Render with sustains (if present)", value=True)
-        merge_misaligned_notes = gr.Slider(-1, 127, value=-1, label="Merge misaligned notes")
-        custom_render_patch = gr.Slider(-1, 127, value=-1, label="Custom render MIDI patch")
-        
-        render_align = gr.Radio(["Do not align", 
-                                 "Start Times", 
-                                 "Start Times and Durations", 
-                                 "Start Times and Split Durations"
-                                ], 
-                                label="Align output to bars", 
-                                value="Do not align"
-                               )        
-        
-        render_transpose_value = gr.Slider(-12, 12, value=0, step=1, label="Transpose value")
-        render_transpose_to_C4 = gr.Checkbox(label="Transpose to C4", value=False)
-
-
-        render_output_as_solo_piano = gr.Checkbox(label="Output as Solo Piano", value=False)
-        render_remove_drums = gr.Checkbox(label="Remove drums", value=False)
-        
-        submit = gr.Button("Render MIDI", variant="primary")
-
-        gr.Markdown("## Render results")
-        
-        output_midi_md5 = gr.Textbox(label="Output MIDI md5 hash")
-        output_midi_title = gr.Textbox(label="Output MIDI title")
-        output_song_description = gr.Textbox(label="Output MIDI description")
-        output_midi_summary = gr.Textbox(label="Output MIDI summary")
-        output_audio = gr.Audio(label="Output MIDI audio", format="wav", elem_id="midi_audio")
-        output_plot = gr.Plot(label="Output MIDI score plot")
-        output_midi = gr.File(label="Output MIDI file", file_types=[".mid"])
+        with gr.Row():
+            waveform_options = gr.WaveformOptions(show_recording_waveform=False)
+            with gr.Column(scale=1):
+                # --- INPUT COLUMN ---
+                gr.Markdown("## 1. Upload File")
+                
+                # Changed from gr.File to gr.Audio to allow for audio preview.
+                # type="filepath" ensures the component returns a string path to the uploaded file.
+                # The component will show a player for supported audio types (e.g., WAV, MP3).
+                input_file = gr.Audio(
+                    label="Input Audio (WAV, MP3) or MIDI File",
+                    type="filepath",
+                    sources=["upload"], waveform_options=waveform_options
+                )
+                
+                gr.Markdown("## 2. Configure Processing")
+
+                # --- Transcription Method Selector ---
+                transcription_method = gr.Radio(
+                    ["General Purpose", "Piano-Specific"],
+                    label="Audio Transcription Method",
+                    value="General Purpose",
+                    info="Choose 'General Purpose' for most music (vocals, etc.). Choose 'Piano-Specific' only for solo piano recordings."
+                )
+
+                # --- General Purpose (basic-pitch) Settings ---
+                with gr.Accordion("General Purpose Transcription Settings", open=True) as general_transcription_settings:
+                    onset_threshold = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="On-set Threshold", info="Sensitivity for detecting note beginnings. Higher is stricter.")
+                    frame_threshold = gr.Slider(0.0, 1.0, value=0.3, step=0.05, label="Frame Threshold", info="Sensitivity for detecting active notes. Higher is stricter.")
+                    minimum_note_length = gr.Slider(10, 500, value=128, step=1, label="Minimum Note Length (ms)", info="Filters out very short, noisy notes.")
+                    minimum_frequency = gr.Slider(0, 500, value=60, step=5, label="Minimum Frequency (Hz)", info="Ignores pitches below this frequency.")
+                    maximum_frequency = gr.Slider(501, 10000, value=4000, step=10, label="Maximum Frequency (Hz)", info="Ignores pitches above this frequency.")
+                    infer_onsets = gr.Checkbox(value=True, label="Infer Onsets (Boost Onsets)")
+                    melodia_trick = gr.Checkbox(value=True, label="Melodia Trick (Contour Optimization)")
+                    multiple_pitch_bends = gr.Checkbox(value=False, label="Allow Multiple Pitch Bends")
+
+                # --- Rendering Settings ---
+                render_type = gr.Radio(
+                    ["Render as-is", "Custom render", "Extract melody", "Flip", "Reverse", "Repair Durations", "Repair Chords", "Remove Duplicate Pitches", "Longest Repeating Phrase", "Multi-Instrumental Summary", "Solo Piano Summary", "Add Drum Track"],
+                    label="MIDI Transformation Render Type",
+                    value="Render as-is",
+                    info="Apply transformations to the MIDI before rendering. Select 'Render as-is' for basic rendering or other options for transformations."
+                )
+                
+                # --- SoundFont Bank with 8-bit option ---
+                # --- Dynamically create the list of choices ---
+                soundfont_choices = [SYNTH_8_BIT_LABEL] + list(soundfonts_dict.keys())
+                # Set a safe default value
+                default_sf_choice = "SGM-v2.01-YamahaGrand-Guit-Bass-v2.7" if "SGM-v2.01-YamahaGrand-Guit-Bass-v2.7" in soundfonts_dict else soundfont_choices[0]
+                
+                soundfont_bank = gr.Dropdown(
+                    soundfont_choices,
+                    label="SoundFont / Synthesizer",
+                    value=default_sf_choice
+                )
+
+                render_sample_rate = gr.Radio(
+                    ["16000", "32000", "44100"],
+                    label="Audio Sample Rate",
+                    value="44100"
+                )
+
+                # --- NEW: 8-bit Synthesizer Settings ---
+                with gr.Accordion("8-bit Synthesizer Settings", open=False, visible=False) as synth_8bit_settings:
+                    s8bit_waveform_type = gr.Dropdown(['Square', 'Sawtooth', 'Triangle'], value='Square', label="Waveform Type")
+                    s8bit_envelope_type = gr.Dropdown(['Plucky (AD Envelope)', 'Sustained (Full Decay)'], value='Plucky (AD Envelope)', label="Envelope Type")
+                    s8bit_decay_time_s = gr.Slider(0.01, 0.5, value=0.1, step=0.01, label="Decay Time (s)")
+                    s8bit_pulse_width = gr.Slider(0.01, 0.99, value=0.5, step=0.01, label="Pulse Width")
+                    s8bit_vibrato_rate = gr.Slider(0, 20, value=5, label="Vibrato Rate (Hz)")
+                    s8bit_vibrato_depth = gr.Slider(0, 50, value=0, label="Vibrato Depth (Hz)")
+                
+                # --- Original Advanced Options (Now tied to Piano-Specific) ---
+                with gr.Accordion("Advanced MIDI Rendering Options", open=False) as advanced_rendering_options:
+                    render_with_sustains = gr.Checkbox(label="Apply sustain pedal effects (if present)", value=True)
+                    render_output_as_solo_piano = gr.Checkbox(label="Convert to Solo Piano (Grand Piano patch)", value=False)
+                    render_remove_drums = gr.Checkbox(label="Remove drum track", value=False)
+                    render_transpose_to_C4 = gr.Checkbox(label="Transpose entire score to center around C4", value=False)
+                    render_transpose_value = gr.Slider(-12, 12, value=0, step=1, label="Transpose (semitones)")
+                    custom_render_patch = gr.Slider(-1, 127, value=-1, step=1, label="Force MIDI Patch (-1 to disable)")
+                    merge_misaligned_notes = gr.Slider(-1, 127, value=-1, info="Time to merge notes in ms (-1 to disable)")
+                    render_align = gr.Radio(
+                        ["Do not align", "Start Times", "Start Times and Durations", "Start Times and Split Durations"],
+                        label="Align notes to musical bars",
+                        value="Do not align"
+                    )
+
+                submit_btn = gr.Button("Process and Render", variant="primary")
+                
+            with gr.Column(scale=2):
+                # --- OUTPUT COLUMN ---
+                gr.Markdown("## 3. Results")
+                output_midi_title = gr.Textbox(label="MIDI Title")
+                output_song_description = gr.Textbox(label="MIDI Description", lines=3)
+                output_audio = gr.Audio(label="Rendered Audio Output", format="wav", waveform_options=waveform_options)
+                output_plot = gr.Plot(label="MIDI Score Plot")
+                with gr.Row():
+                    output_midi = gr.File(label="Download Processed MIDI File", file_types=[".mid"])
+                    output_midi_md5 = gr.Textbox(label="Output MIDI MD5 Hash")
+                output_midi_summary = gr.Textbox(label="MIDI metadata summary", lines=4)
+
+        # --- Define all input components for the click event ---
+        all_inputs = [
+            input_file, 
+            transcription_method,
+            onset_threshold, frame_threshold, minimum_note_length, minimum_frequency, maximum_frequency,
+            infer_onsets, melodia_trick, multiple_pitch_bends,
+            render_type, soundfont_bank, render_sample_rate,
+            render_with_sustains, merge_misaligned_notes, custom_render_patch, render_align,
+            render_transpose_value, render_transpose_to_C4, render_output_as_solo_piano, render_remove_drums,
+            s8bit_waveform_type, s8bit_envelope_type, s8bit_decay_time_s, 
+            s8bit_pulse_width, s8bit_vibrato_rate, s8bit_vibrato_depth
+        ]
+        all_outputs = [
+            output_midi_md5, output_midi_title, output_midi_summary, 
+            output_midi, output_audio, output_plot, output_song_description
+        ]
         
-        run_event = submit.click(Render_MIDI, [input_midi, 
-                                               render_type, 
-                                               soundfont_bank, 
-                                               render_sample_rate,
-                                               render_with_sustains,
-                                               merge_misaligned_notes,
-                                               custom_render_patch,
-                                               render_align,
-                                               render_transpose_value,
-                                               render_transpose_to_C4,
-                                               render_output_as_solo_piano,
-                                               render_remove_drums                                              
-                                              ],
-                                                [output_midi_md5, 
-                                                 output_midi_title, 
-                                                 output_midi_summary, 
-                                                 output_midi, 
-                                                 output_audio, 
-                                                 output_plot,
-                                                 output_song_description
-                                                ])
+        # --- Event Handling ---
+        submit_btn.click(
+            process_and_render_file, 
+            inputs=all_inputs,
+            outputs=all_outputs
+        )
         
-    app.queue().launch()
+        # --- Listeners for dynamic UI updates ---
+        transcription_method.change(
+            fn=update_ui_visibility,
+            inputs=[transcription_method, soundfont_bank],
+            outputs=[general_transcription_settings, synth_8bit_settings]
+        )
+        soundfont_bank.change(
+            fn=update_ui_visibility,
+            inputs=[transcription_method, soundfont_bank],
+            outputs=[general_transcription_settings, synth_8bit_settings]
+        )
+
+    # Launch the Gradio app
+    app.queue().launch(inbrowser=True, debug=True)

packages.txt

@@ -1 +1,3 @@
-fluidsynth
+fluidsynth
+portaudio19-dev
+libportaudio2

requirements.txt

@@ -1,6 +1,24 @@
-gradio
+--extra-index-url https://download.pytorch.org/whl/cu128
+
+torch
 numpy
-scipy
+gradio
+mido
+librosa
+torchlibrosa
+resampy
 matplotlib
+
+huggingface_hub
+
+scipy
 networkx
-scikit-learn
+scikit-learn
+psutil
+pretty_midi
+piano_transcription_inference
+
+basic-pitch @ git+https://github.com/avan06/basic-pitch; sys_platform != 'linux'
+basic-pitch[tf] @ git+https://github.com/avan06/basic-pitch; sys_platform == 'linux'
+
+git+https://github.com/avan06/pyfluidsynth

MIDI.py → src/MIDI.py

@@ -1,4 +1,52 @@
 #! /usr/bin/python3
+
+r'''###############################################################################
+###################################################################################
+#
+#
+#	Tegridy MIDI X Module (TMIDI X / tee-midi eks)
+#
+#   NOTE: TMIDI X Module starts after the partial MIDI.py module @ line 1450
+#
+#	Based upon MIDI.py module v.6.7. by Peter Billam / pjb.com.au
+#
+#	Project Los Angeles
+#
+#	Tegridy Code 2025
+#
+#   https://github.com/Tegridy-Code/Project-Los-Angeles
+#
+#
+###################################################################################
+###################################################################################
+#   Copyright 2025 Project Los Angeles / Tegridy Code
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+###################################################################################
+###################################################################################
+#
+#	PARTIAL MIDI.py Module v.6.7. by Peter Billam
+#   Please see TMIDI 2.3/tegridy-tools repo for full MIDI.py module code
+# 
+#   Or you can always download the latest full version from:
+#
+#   https://pjb.com.au/
+#   https://peterbillam.gitlab.io/miditools/
+#	
+#	Copyright 2020 Peter Billam
+#
+###################################################################################
+###################################################################################
 # unsupported 20091104 ...
 #     ['set_sequence_number', dtime, sequence]
 #     ['raw_data', dtime, raw]
@@ -12,7 +60,6 @@
 # could break compatiblity, but there's not much else you can do to fix the bug
 # https://en.wikipedia.org/wiki/Shift_JIS
 
-r'''
 This module offers functions:  concatenate_scores(), grep(),
 merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(),
 opus2score(), play_score(), score2midi(), score2opus(), score2stats(),
@@ -121,8 +168,20 @@ event, with a duration:
 
 '''
 
+###################################################################################
+
+__version__ = "25.7.8"
+
+print('=' * 70)
+print('TMIDIX Python module')
+print('Version:', __version__)
+print('=' * 70)
+print('Loading module...')
+
+###################################################################################
+
 import sys, struct, copy
-# sys.stdout = os.fdopen(sys.stdout.fileno(), 'wb')
+
 Version = '6.7'
 VersionDate = '20201120'
 # 20201120 6.7 call to bytest() removed, and protect _unshift_ber_int
@@ -179,9 +238,11 @@ VersionDate = '20201120'
 
 _previous_warning = ''  # 5.4
 _previous_times = 0     # 5.4
+_no_warning = False
+
 #------------------------------- Encoding stuff --------------------------
 
-def opus2midi(opus=[]):
+def opus2midi(opus=[], text_encoding='ISO-8859-1'):
     r'''The argument is a list: the first item in the list is the "ticks"
 parameter, the others are the tracks. Each track is a list
 of midi-events, and each event is itself a list; see above.
@@ -214,13 +275,13 @@ sys.stdout.buffer.write(my_midi)
 
     my_midi = b"MThd\x00\x00\x00\x06"+struct.pack('>HHH',format,ntracks,ticks)
     for track in tracks:
-        events = _encode(track)
+        events = _encode(track, text_encoding=text_encoding)
         my_midi += b'MTrk' + struct.pack('>I',len(events)) + events
     _clean_up_warnings()
     return my_midi
 
 
-def score2opus(score=None):
+def score2opus(score=None, text_encoding='ISO-8859-1'):
     r'''
 The argument is a list: the first item in the list is the "ticks"
 parameter, the others are the tracks. Each track is a list
@@ -289,15 +350,15 @@ my_opus = score2opus(my_score)
     _clean_up_warnings()
     return opus_tracks
 
-def score2midi(score=None):
+def score2midi(score=None, text_encoding='ISO-8859-1'):
     r'''
 Translates a "score" into MIDI, using score2opus() then opus2midi()
 '''
-    return opus2midi(score2opus(score))
+    return opus2midi(score2opus(score, text_encoding), text_encoding)
 
 #--------------------------- Decoding stuff ------------------------
 
-def midi2opus(midi=b''):
+def midi2opus(midi=b'', do_not_check_MIDI_signature=False):
     r'''Translates MIDI into a "opus".  For a description of the
 "opus" format, see opus2midi()
 '''
@@ -309,7 +370,8 @@ def midi2opus(midi=b''):
     if id != b'MThd':
         _warn("midi2opus: midi starts with "+str(id)+" instead of 'MThd'")
         _clean_up_warnings()
-        return [1000,[],]
+        if do_not_check_MIDI_signature == False:
+          return [1000,[],]
     [length, format, tracks_expected, ticks] = struct.unpack(
      '>IHHH', bytes(my_midi[4:14]))
     if length != 6:
@@ -322,7 +384,8 @@ def midi2opus(midi=b''):
     while len(my_midi) >= 8:
         track_type   = bytes(my_midi[0:4])
         if track_type != b'MTrk':
-            _warn('midi2opus: Warning: track #'+str(track_num)+' type is '+str(track_type)+" instead of b'MTrk'")
+            #_warn('midi2opus: Warning: track #'+str(track_num)+' type is '+str(track_type)+" instead of b'MTrk'")
+            pass
         [track_length] = struct.unpack('>I', my_midi[4:8])
         my_midi = my_midi[8:]
         if track_length > len(my_midi):
@@ -388,36 +451,114 @@ see opus2midi() and score2opus().
     _clean_up_warnings()
     return score
 
-def midi2score(midi=b''):
+def midi2score(midi=b'', do_not_check_MIDI_signature=False):
     r'''
 Translates MIDI into a "score", using midi2opus() then opus2score()
 '''
-    return opus2score(midi2opus(midi))
+    return opus2score(midi2opus(midi, do_not_check_MIDI_signature))
 
-def midi2ms_score(midi=b''):
+def midi2ms_score(midi=b'', do_not_check_MIDI_signature=False):
     r'''
 Translates MIDI into a "score" with one beat per second and one
 tick per millisecond, using midi2opus() then to_millisecs()
 then opus2score()
 '''
-    return opus2score(to_millisecs(midi2opus(midi)))
+    return opus2score(to_millisecs(midi2opus(midi, do_not_check_MIDI_signature)))
+
+def midi2single_track_ms_score(midi_path_or_bytes, 
+                                recalculate_channels = False, 
+                                pass_old_timings_events= False, 
+                                verbose = False, 
+                                do_not_check_MIDI_signature=False
+                                ):
+    r'''
+Translates MIDI into a single track "score" with 16 instruments and one beat per second and one
+tick per millisecond
+'''
+
+    if type(midi_path_or_bytes) == bytes:
+      midi_data = midi_path_or_bytes
+
+    elif type(midi_path_or_bytes) == str:
+      midi_data = open(midi_path_or_bytes, 'rb').read() 
+
+    score = midi2score(midi_data, do_not_check_MIDI_signature)
+
+    if recalculate_channels:
+
+      events_matrixes = []
+
+      itrack = 1
+      events_matrixes_channels = []
+      while itrack < len(score):
+          events_matrix = []
+          for event in score[itrack]:
+              if event[0] == 'note' and event[3] != 9:
+                event[3] = (16 * (itrack-1)) + event[3]
+                if event[3] not in events_matrixes_channels:
+                  events_matrixes_channels.append(event[3])
+
+              events_matrix.append(event)
+          events_matrixes.append(events_matrix)
+          itrack += 1
+
+      events_matrix1 = []
+      for e in events_matrixes:
+        events_matrix1.extend(e)
+
+      if verbose:
+        if len(events_matrixes_channels) > 16:
+          print('MIDI has', len(events_matrixes_channels), 'instruments!', len(events_matrixes_channels) - 16, 'instrument(s) will be removed!')
+
+      for e in events_matrix1:
+        if e[0] == 'note' and e[3] != 9:
+          if e[3] in events_matrixes_channels[:15]:
+            if events_matrixes_channels[:15].index(e[3]) < 9:
+              e[3] = events_matrixes_channels[:15].index(e[3])
+            else:
+              e[3] = events_matrixes_channels[:15].index(e[3])+1
+          else:
+            events_matrix1.remove(e)
+        
+        if e[0] in ['patch_change', 'control_change', 'channel_after_touch', 'key_after_touch', 'pitch_wheel_change'] and e[2] != 9:
+          if e[2] in [e % 16 for e in events_matrixes_channels[:15]]:
+            if [e % 16 for e in events_matrixes_channels[:15]].index(e[2]) < 9:
+              e[2] = [e % 16 for e in events_matrixes_channels[:15]].index(e[2])
+            else:
+              e[2] = [e % 16 for e in events_matrixes_channels[:15]].index(e[2])+1
+          else:
+            events_matrix1.remove(e)
+    
+    else:
+      events_matrix1 = []
+      itrack = 1
+     
+      while itrack < len(score):
+          for event in score[itrack]:
+            events_matrix1.append(event)
+          itrack += 1    
+
+    opus = score2opus([score[0], events_matrix1])
+    ms_score = opus2score(to_millisecs(opus, pass_old_timings_events=pass_old_timings_events))
+
+    return ms_score
 
 #------------------------ Other Transformations ---------------------
 
-def to_millisecs(old_opus=None):
+def to_millisecs(old_opus=None, desired_time_in_ms=1, pass_old_timings_events = False):
     r'''Recallibrates all the times in an "opus" to use one beat
 per second and one tick per millisecond.  This makes it
 hard to retrieve any information about beats or barlines,
 but it does make it easy to mix different scores together.
 '''
     if old_opus == None:
-        return [1000,[],]
+        return [1000 * desired_time_in_ms,[],]
     try:
         old_tpq  = int(old_opus[0])
     except IndexError:   # 5.0
         _warn('to_millisecs: the opus '+str(type(old_opus))+' has no elements')
-        return [1000,[],]
-    new_opus = [1000,]
+        return [1000 * desired_time_in_ms,[],]
+    new_opus = [1000 * desired_time_in_ms,]
     # 6.7 first go through building a table of set_tempos by absolute-tick
     ticks2tempo = {}
     itrack = 1
@@ -439,30 +580,44 @@ but it does make it easy to mix different scores together.
     # set_tempo lies before the next track-event, and using it if so.
     itrack = 1
     while itrack < len(old_opus):
-        ms_per_old_tick = 500.0 / old_tpq  # float: will round later 6.3
+        ms_per_old_tick = 400 / old_tpq  # float: will round later 6.3
         i_tempo_ticks = 0
         ticks_so_far = 0
         ms_so_far = 0.0
         previous_ms_so_far = 0.0
-        new_track = [['set_tempo',0,1000000],]  # new "crochet" is 1 sec
+
+        if pass_old_timings_events:
+          new_track = [['set_tempo',0,1000000 * desired_time_in_ms],['old_tpq', 0, old_tpq]]  # new "crochet" is 1 sec
+        else:
+          new_track = [['set_tempo',0,1000000 * desired_time_in_ms],]  # new "crochet" is 1 sec
         for old_event in old_opus[itrack]:
             # detect if ticks2tempo has something before this event
             # 20160702 if ticks2tempo is at the same time, leave it
-            event_delta_ticks = old_event[1]
+            event_delta_ticks = old_event[1] * desired_time_in_ms
             if (i_tempo_ticks < len(tempo_ticks) and
-              tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[1])):
+              tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[1]) * desired_time_in_ms):
                 delta_ticks = tempo_ticks[i_tempo_ticks] - ticks_so_far
-                ms_so_far += (ms_per_old_tick * delta_ticks)
+                ms_so_far += (ms_per_old_tick * delta_ticks * desired_time_in_ms)
                 ticks_so_far = tempo_ticks[i_tempo_ticks]
-                ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq)
+                ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq * desired_time_in_ms)
                 i_tempo_ticks += 1
                 event_delta_ticks -= delta_ticks
             new_event = copy.deepcopy(old_event)  # now handle the new event
-            ms_so_far += (ms_per_old_tick * old_event[1])
+            ms_so_far += (ms_per_old_tick * old_event[1] * desired_time_in_ms)
             new_event[1] = round(ms_so_far - previous_ms_so_far)
-            if old_event[0] != 'set_tempo':
-                previous_ms_so_far = ms_so_far
-                new_track.append(new_event)
+
+            if pass_old_timings_events:
+              if old_event[0] != 'set_tempo':
+                  previous_ms_so_far = ms_so_far
+                  new_track.append(new_event)
+              else:
+                  new_event[0] = 'old_set_tempo'
+                  previous_ms_so_far = ms_so_far
+                  new_track.append(new_event)
+            else:
+              if old_event[0] != 'set_tempo':
+                  previous_ms_so_far = ms_so_far
+                  new_track.append(new_event)
             ticks_so_far += event_delta_ticks
         new_opus.append(new_track)
         itrack += 1
@@ -500,285 +655,6 @@ def grep(score=None, channels=None):
         itrack += 1
     return new_score
 
-def play_score(score=None):
-    r'''Converts the "score" to midi, and feeds it into 'aplaymidi -'
-'''
-    if score == None:
-        return
-    import subprocess
-    pipe = subprocess.Popen(['aplaymidi','-'], stdin=subprocess.PIPE)
-    if score_type(score) == 'opus':
-        pipe.stdin.write(opus2midi(score))
-    else:
-        pipe.stdin.write(score2midi(score))
-    pipe.stdin.close()
-
-def timeshift(score=None, shift=None, start_time=None, from_time=0, tracks={0,1,2,3,4,5,6,7,8,10,12,13,14,15}):
-    r'''Returns a "score" shifted in time by "shift" ticks, or shifted
-so that the first event starts at "start_time" ticks.
-
-If "from_time" is specified, only those events in the score
-that begin after it are shifted. If "start_time" is less than
-"from_time" (or "shift" is negative), then the intermediate
-notes are deleted, though patch-change events are preserved.
-
-If "tracks" are specified, then only those tracks get shifted.
-"tracks" can be a list, tuple or set; it gets converted to set
-internally.
-
-It is deprecated to specify both "shift" and "start_time".
-If this does happen, timeshift() will print a warning to
-stderr and ignore the "shift" argument.
-
-If "shift" is negative and sufficiently large that it would
-leave some event with a negative tick-value, then the score
-is shifted so that the first event occurs at time 0. This
-also occurs if "start_time" is negative, and is also the
-default if neither "shift" nor "start_time" are specified.
-'''
-    #_warn('tracks='+str(tracks))
-    if score == None or len(score) < 2:
-        return [1000, [],]
-    new_score = [score[0],]
-    my_type = score_type(score)
-    if my_type == '':
-        return new_score
-    if my_type == 'opus':
-        _warn("timeshift: opus format is not supported\n")
-        # _clean_up_scores()  6.2; doesn't exist! what was it supposed to do?
-        return new_score
-    if not (shift == None) and not (start_time == None):
-        _warn("timeshift: shift and start_time specified: ignoring shift\n")
-        shift = None
-    if shift == None:
-        if (start_time == None) or (start_time < 0):
-            start_time = 0
-        # shift = start_time - from_time
-
-    i = 1   # ignore first element (ticks)
-    tracks = set(tracks)  # defend against tuples and lists
-    earliest = 1000000000
-    if not (start_time == None) or shift < 0:  # first find the earliest event
-        while i < len(score):
-            if len(tracks) and not ((i-1) in tracks):
-                i += 1
-                continue
-            for event in score[i]:
-                 if event[1] < from_time:
-                     continue  # just inspect the to_be_shifted events
-                 if event[1] < earliest:
-                     earliest = event[1]
-            i += 1
-    if earliest > 999999999:
-        earliest = 0
-    if shift == None:
-        shift = start_time - earliest
-    elif (earliest + shift) < 0:
-        start_time = 0
-        shift = 0 - earliest
-
-    i = 1   # ignore first element (ticks)
-    while i < len(score):
-        if len(tracks) == 0 or not ((i-1) in tracks):  # 3.8
-            new_score.append(score[i])
-            i += 1
-            continue
-        new_track = []
-        for event in score[i]:
-            new_event = list(event)
-            #if new_event[1] == 0 and shift > 0 and new_event[0] != 'note':
-            #    pass
-            #elif new_event[1] >= from_time:
-            if new_event[1] >= from_time:
-                # 4.1 must not rightshift set_tempo
-                if new_event[0] != 'set_tempo' or shift<0:
-                    new_event[1] += shift
-            elif (shift < 0) and (new_event[1] >= (from_time+shift)):
-                continue
-            new_track.append(new_event)
-        if len(new_track) > 0:
-            new_score.append(new_track)
-        i += 1
-    _clean_up_warnings()
-    return new_score
-
-def segment(score=None, start_time=None, end_time=None, start=0, end=100000000,
- tracks={0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}):
-    r'''Returns a "score" which is a segment of the one supplied
-as the argument, beginning at "start_time" ticks and ending
-at "end_time" ticks (or at the end if "end_time" is not supplied).
-If the set "tracks" is specified, only those tracks will
-be returned.
-'''
-    if score == None or len(score) < 2:
-        return [1000, [],]
-    if start_time == None:  # as of 4.2 start_time is recommended
-        start_time = start  # start is legacy usage
-    if end_time == None:    # likewise
-        end_time = end
-    new_score = [score[0],]
-    my_type = score_type(score)
-    if my_type == '':
-        return new_score
-    if my_type == 'opus':
-        # more difficult (disconnecting note_on's from their note_off's)...
-        _warn("segment: opus format is not supported\n")
-        _clean_up_warnings()
-        return new_score
-    i = 1   # ignore first element (ticks); we count in ticks anyway
-    tracks = set(tracks)  # defend against tuples and lists
-    while i < len(score):
-        if len(tracks) and not ((i-1) in tracks):
-            i += 1
-            continue
-        new_track = []
-        channel2cc_num  = {}     # most recent controller change before start
-        channel2cc_val  = {}
-        channel2cc_time = {}
-        channel2patch_num  = {}  # keep most recent patch change before start
-        channel2patch_time = {}
-        set_tempo_num  = 500000 # most recent tempo change before start 6.3
-        set_tempo_time = 0
-        earliest_note_time = end_time
-        for event in score[i]:
-            if event[0] == 'control_change':  # 6.5
-                cc_time = channel2cc_time.get(event[2]) or 0
-                if (event[1] <= start_time) and (event[1] >= cc_time):
-                    channel2cc_num[event[2]]  = event[3]
-                    channel2cc_val[event[2]]  = event[4]
-                    channel2cc_time[event[2]] = event[1]
-            elif event[0] == 'patch_change':
-                patch_time = channel2patch_time.get(event[2]) or 0
-                if (event[1]<=start_time) and (event[1] >= patch_time):  # 2.0
-                    channel2patch_num[event[2]]  = event[3]
-                    channel2patch_time[event[2]] = event[1]
-            elif event[0] == 'set_tempo':
-                if (event[1]<=start_time) and (event[1]>=set_tempo_time): #6.4
-                    set_tempo_num  = event[2]
-                    set_tempo_time = event[1]
-            if (event[1] >= start_time) and (event[1] <= end_time):
-                new_track.append(event)
-                if (event[0] == 'note') and (event[1] < earliest_note_time):
-                    earliest_note_time = event[1]
-        if len(new_track) > 0:
-            new_track.append(['set_tempo', start_time, set_tempo_num])
-            for c in channel2patch_num:
-                new_track.append(['patch_change',start_time,c,channel2patch_num[c]],)
-            for c in channel2cc_num:   # 6.5
-                new_track.append(['control_change',start_time,c,channel2cc_num[c],channel2cc_val[c]])
-            new_score.append(new_track)
-        i += 1
-    _clean_up_warnings()
-    return new_score
-
-def score_type(opus_or_score=None):
-    r'''Returns a string, either 'opus' or 'score' or ''
-'''
-    if opus_or_score == None or str(type(opus_or_score)).find('list')<0 or len(opus_or_score) < 2:
-        return ''
-    i = 1   # ignore first element
-    while i < len(opus_or_score):
-        for event in opus_or_score[i]:
-            if event[0] == 'note':
-                return 'score'
-            elif event[0] == 'note_on':
-                return 'opus'
-        i += 1
-    return ''
-
-def concatenate_scores(scores):
-    r'''Concatenates a list of scores into one score.
-If the scores differ in their "ticks" parameter,
-they will all get converted to millisecond-tick format.
-'''
-    # the deepcopys are needed if the input_score's are refs to the same obj
-    # e.g. if invoked by midisox's repeat()
-    input_scores = _consistentise_ticks(scores)  # 3.7
-    output_score = copy.deepcopy(input_scores[0])
-    for input_score in input_scores[1:]:
-        output_stats = score2stats(output_score)
-        delta_ticks = output_stats['nticks']
-        itrack = 1
-        while itrack < len(input_score):
-            if itrack >= len(output_score): # new output track if doesn't exist
-                output_score.append([])
-            for event in input_score[itrack]:
-                output_score[itrack].append(copy.deepcopy(event))
-                output_score[itrack][-1][1] += delta_ticks
-            itrack += 1
-    return output_score
-
-def merge_scores(scores):
-    r'''Merges a list of scores into one score.  A merged score comprises
-all of the tracks from all of the input scores; un-merging is possible
-by selecting just some of the tracks.  If the scores differ in their
-"ticks" parameter, they will all get converted to millisecond-tick
-format.  merge_scores attempts to resolve channel-conflicts,
-but there are of course only 15 available channels...
-'''
-    input_scores = _consistentise_ticks(scores)  # 3.6
-    output_score = [1000]
-    channels_so_far = set()
-    all_channels = {0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}
-    global Event2channelindex
-    for input_score in input_scores:
-        new_channels = set(score2stats(input_score).get('channels_total', []))
-        new_channels.discard(9)  # 2.8 cha9 must remain cha9 (in GM)
-        for channel in channels_so_far & new_channels:
-            # consistently choose lowest avaiable, to ease testing
-            free_channels = list(all_channels - (channels_so_far|new_channels))
-            if len(free_channels) > 0:
-                free_channels.sort()
-                free_channel = free_channels[0]
-            else:
-                free_channel = None
-                break
-            itrack = 1
-            while itrack < len(input_score):
-                for input_event in input_score[itrack]:
-                    channel_index=Event2channelindex.get(input_event[0],False)
-                    if channel_index and input_event[channel_index]==channel:
-                        input_event[channel_index] = free_channel
-                itrack += 1
-            channels_so_far.add(free_channel)
-
-        channels_so_far |= new_channels
-        output_score.extend(input_score[1:])
-    return output_score
-
-def _ticks(event):
-    return event[1]
-def mix_opus_tracks(input_tracks):   # 5.5
-    r'''Mixes an array of tracks into one track.  A mixed track
-cannot be un-mixed.  It is assumed that the tracks share the same
-ticks parameter and the same tempo.
-Mixing score-tracks is trivial (just insert all events into one array).
-Mixing opus-tracks is only slightly harder, but it's common enough
-that a dedicated function is useful.
-'''
-    output_score = [1000, []]
-    for input_track in input_tracks:   # 5.8
-        input_score = opus2score([1000, input_track])
-        for event in input_score[1]:
-            output_score[1].append(event)
-    output_score[1].sort(key=_ticks) 
-    output_opus = score2opus(output_score)
-    return output_opus[1]
-
-def mix_scores(scores):
-    r'''Mixes a list of scores into one one-track score.
-A mixed score cannot be un-mixed.  Hopefully the scores
-have no undesirable channel-conflicts between them.
-If the scores differ in their "ticks" parameter,
-they will all get converted to millisecond-tick format.
-'''
-    input_scores = _consistentise_ticks(scores)  # 3.6
-    output_score = [1000, []]
-    for input_score in input_scores:
-        for input_track in input_score[1:]:
-            output_score[1].extend(input_track)
-    return output_score
-
 def score2stats(opus_or_score=None):
     r'''Returns a dict of some basic stats about the score, like
 bank_select (list of tuples (msb,lsb)),
@@ -1153,10 +1029,11 @@ def _unshift_ber_int(ba):
     r'''Given a bytearray, returns a tuple of (the ber-integer at the
 start, and the remainder of the bytearray).
 '''
-    if not len(ba):   # 6.7
+    if not len(ba):  # 6.7
         _warn('_unshift_ber_int: no integer found')
         return ((0, b""))
-    byte = ba.pop(0)
+    byte = ba[0]
+    ba = ba[1:]
     integer = 0
     while True:
         integer += (byte & 0x7F)
@@ -1165,13 +1042,17 @@ start, and the remainder of the bytearray).
         if not len(ba):
             _warn('_unshift_ber_int: no end-of-integer found')
             return ((0, ba))
-        byte = ba.pop(0)
+        byte = ba[0]
+        ba = ba[1:]
         integer <<= 7
 
+
 def _clean_up_warnings():  # 5.4
     # Call this before returning from any publicly callable function
     # whenever there's a possibility that a warning might have been printed
     # by the function, or by any private functions it might have called.
+    if _no_warning:
+        return
     global _previous_times
     global _previous_warning
     if _previous_times > 1:
@@ -1184,27 +1065,32 @@ def _clean_up_warnings():  # 5.4
     _previous_times = 0
     _previous_warning = ''
 
+
 def _warn(s=''):
+    if _no_warning:
+        return
     global _previous_times
     global _previous_warning
     if s == _previous_warning:  # 5.4
         _previous_times = _previous_times + 1
     else:
         _clean_up_warnings()
-        sys.stderr.write(str(s)+"\n")
+        sys.stderr.write(str(s) + "\n")
         _previous_warning = s
 
-def _some_text_event(which_kind=0x01, text=b'some_text'):
-    if str(type(text)).find("'str'") >= 0:   # 6.4 test for back-compatibility
-        data = bytes(text, encoding='ISO-8859-1')
+
+def _some_text_event(which_kind=0x01, text=b'some_text', text_encoding='ISO-8859-1'):
+    if str(type(text)).find("'str'") >= 0:  # 6.4 test for back-compatibility
+        data = bytes(text, encoding=text_encoding)
     else:
         data = bytes(text)
-    return b'\xFF'+bytes((which_kind,))+_ber_compressed_int(len(data))+data
+    return b'\xFF' + bytes((which_kind,)) + _ber_compressed_int(len(data)) + data
+
 
 def _consistentise_ticks(scores):  # 3.6
     # used by mix_scores, merge_scores, concatenate_scores
     if len(scores) == 1:
-         return copy.deepcopy(scores)
+        return copy.deepcopy(scores)
     are_consistent = True
     ticks = scores[0][0]
     iscore = 1
@@ -1225,9 +1111,8 @@ def _consistentise_ticks(scores):  # 3.6
 
 
 ###########################################################################
-
 def _decode(trackdata=b'', exclude=None, include=None,
- event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
+            event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
     r'''Decodes MIDI track data into an opus-style list of events.
 The options:
   'exclude' is a list of event types which will be ignored SHOULD BE A SET
@@ -1247,24 +1132,24 @@ The options:
     exclude = set(exclude)
 
     # Pointer = 0;  not used here; we eat through the bytearray instead.
-    event_code = -1; # used for running status
+    event_code = -1;  # used for running status
     event_count = 0;
     events = []
 
-    while(len(trackdata)):
+    while (len(trackdata)):
         # loop while there's anything to analyze ...
-        eot = False   # When True, the event registrar aborts this loop
+        eot = False  # When True, the event registrar aborts this loop
         event_count += 1
 
         E = []
         # E for events - we'll feed it to the event registrar at the end.
 
         # Slice off the delta time code, and analyze it
-        [time, remainder] = _unshift_ber_int(trackdata)
+        [time, trackdata] = _unshift_ber_int(trackdata)
 
         # Now let's see what we can make of the command
-        first_byte = trackdata.pop(0) & 0xFF
-
+        first_byte = trackdata[0] & 0xFF
+        trackdata = trackdata[1:]
         if (first_byte < 0xF0):  # It's a MIDI event
             if (first_byte & 0x80):
                 event_code = first_byte
@@ -1278,17 +1163,19 @@ The options:
             command = event_code & 0xF0
             channel = event_code & 0x0F
 
-            if (command == 0xF6):  #  0-byte argument
+            if (command == 0xF6):  # 0-byte argument
                 pass
-            elif (command == 0xC0 or command == 0xD0):  #  1-byte argument
-                parameter = trackdata.pop(0)  # could be B
-            else: # 2-byte argument could be BB or 14-bit
-                parameter = (trackdata.pop(0), trackdata.pop(0))
+            elif (command == 0xC0 or command == 0xD0):  # 1-byte argument
+                parameter = trackdata[0]  # could be B
+                trackdata = trackdata[1:]
+            else:  # 2-byte argument could be BB or 14-bit
+                parameter = (trackdata[0], trackdata[1])
+                trackdata = trackdata[2:]
 
             #################################################################
             # MIDI events
 
-            if (command      == 0x80):
+            if (command == 0x80):
                 if 'note_off' in exclude:
                     continue
                 E = ['note_off', time, channel, parameter[0], parameter[1]]
@@ -1299,11 +1186,11 @@ The options:
             elif (command == 0xA0):
                 if 'key_after_touch' in exclude:
                     continue
-                E = ['key_after_touch',time,channel,parameter[0],parameter[1]]
+                E = ['key_after_touch', time, channel, parameter[0], parameter[1]]
             elif (command == 0xB0):
                 if 'control_change' in exclude:
                     continue
-                E = ['control_change',time,channel,parameter[0],parameter[1]]
+                E = ['control_change', time, channel, parameter[0], parameter[1]]
             elif (command == 0xC0):
                 if 'patch_change' in exclude:
                     continue
@@ -1316,93 +1203,94 @@ The options:
                 if 'pitch_wheel_change' in exclude:
                     continue
                 E = ['pitch_wheel_change', time, channel,
-                 _read_14_bit(parameter)-0x2000]
+                     _read_14_bit(parameter) - 0x2000]
             else:
-                _warn("Shouldn't get here; command="+hex(command))
+                _warn("Shouldn't get here; command=" + hex(command))
 
         elif (first_byte == 0xFF):  # It's a Meta-Event! ##################
-            #[command, length, remainder] =
+            # [command, length, remainder] =
             #    unpack("xCwa*", substr(trackdata, $Pointer, 6));
-            #Pointer += 6 - len(remainder);
+            # Pointer += 6 - len(remainder);
             #    # Move past JUST the length-encoded.
-            command = trackdata.pop(0) & 0xFF
+            command = trackdata[0] & 0xFF
+            trackdata = trackdata[1:]
             [length, trackdata] = _unshift_ber_int(trackdata)
-            if (command      == 0x00):
-                 if (length == 2):
-                     E = ['set_sequence_number',time,_twobytes2int(trackdata)]
-                 else:
-                     _warn('set_sequence_number: length must be 2, not '+str(length))
-                     E = ['set_sequence_number', time, 0]
-
-            elif command >= 0x01 and command <= 0x0f:   # Text events
+            if (command == 0x00):
+                if (length == 2):
+                    E = ['set_sequence_number', time, _twobytes2int(trackdata)]
+                else:
+                    _warn('set_sequence_number: length must be 2, not ' + str(length))
+                    E = ['set_sequence_number', time, 0]
+
+            elif command >= 0x01 and command <= 0x0f:  # Text events
                 # 6.2 take it in bytes; let the user get the right encoding.
                 # text_str = trackdata[0:length].decode('ascii','ignore')
                 # text_str = trackdata[0:length].decode('ISO-8859-1')
                 # 6.4 take it in bytes; let the user get the right encoding.
-                text_data = bytes(trackdata[0:length])   # 6.4
+                text_data = bytes(trackdata[0:length])  # 6.4
                 # Defined text events
                 if (command == 0x01):
-                     E = ['text_event', time, text_data]
+                    E = ['text_event', time, text_data]
                 elif (command == 0x02):
-                     E = ['copyright_text_event', time, text_data]
+                    E = ['copyright_text_event', time, text_data]
                 elif (command == 0x03):
-                     E = ['track_name', time, text_data]
+                    E = ['track_name', time, text_data]
                 elif (command == 0x04):
-                     E = ['instrument_name', time, text_data]
+                    E = ['instrument_name', time, text_data]
                 elif (command == 0x05):
-                     E = ['lyric', time, text_data]
+                    E = ['lyric', time, text_data]
                 elif (command == 0x06):
-                     E = ['marker', time, text_data]
+                    E = ['marker', time, text_data]
                 elif (command == 0x07):
-                     E = ['cue_point', time, text_data]
+                    E = ['cue_point', time, text_data]
                 # Reserved but apparently unassigned text events
                 elif (command == 0x08):
-                     E = ['text_event_08', time, text_data]
+                    E = ['text_event_08', time, text_data]
                 elif (command == 0x09):
-                     E = ['text_event_09', time, text_data]
+                    E = ['text_event_09', time, text_data]
                 elif (command == 0x0a):
-                     E = ['text_event_0a', time, text_data]
+                    E = ['text_event_0a', time, text_data]
                 elif (command == 0x0b):
-                     E = ['text_event_0b', time, text_data]
+                    E = ['text_event_0b', time, text_data]
                 elif (command == 0x0c):
-                     E = ['text_event_0c', time, text_data]
+                    E = ['text_event_0c', time, text_data]
                 elif (command == 0x0d):
-                     E = ['text_event_0d', time, text_data]
+                    E = ['text_event_0d', time, text_data]
                 elif (command == 0x0e):
-                     E = ['text_event_0e', time, text_data]
+                    E = ['text_event_0e', time, text_data]
                 elif (command == 0x0f):
-                     E = ['text_event_0f', time, text_data]
+                    E = ['text_event_0f', time, text_data]
 
             # Now the sticky events -------------------------------------
             elif (command == 0x2F):
-                 E = ['end_track', time]
-                     # The code for handling this, oddly, comes LATER,
-                     # in the event registrar.
-            elif (command == 0x51): # DTime, Microseconds/Crochet
-                 if length != 3:
-                     _warn('set_tempo event, but length='+str(length))
-                 E = ['set_tempo', time,
-                      struct.unpack(">I", b'\x00'+trackdata[0:3])[0]]
+                E = ['end_track', time]
+                # The code for handling this, oddly, comes LATER,
+                # in the event registrar.
+            elif (command == 0x51):  # DTime, Microseconds/Crochet
+                if length != 3:
+                    _warn('set_tempo event, but length=' + str(length))
+                E = ['set_tempo', time,
+                     struct.unpack(">I", b'\x00' + trackdata[0:3])[0]]
             elif (command == 0x54):
-                 if length != 5:   # DTime, HR, MN, SE, FR, FF
-                     _warn('smpte_offset event, but length='+str(length))
-                 E = ['smpte_offset',time] + list(struct.unpack(">BBBBB",trackdata[0:5]))
+                if length != 5:  # DTime, HR, MN, SE, FR, FF
+                    _warn('smpte_offset event, but length=' + str(length))
+                E = ['smpte_offset', time] + list(struct.unpack(">BBBBB", trackdata[0:5]))
             elif (command == 0x58):
-                 if length != 4:   # DTime, NN, DD, CC, BB
-                     _warn('time_signature event, but length='+str(length))
-                 E = ['time_signature', time]+list(trackdata[0:4])
+                if length != 4:  # DTime, NN, DD, CC, BB
+                    _warn('time_signature event, but length=' + str(length))
+                E = ['time_signature', time] + list(trackdata[0:4])
             elif (command == 0x59):
-                 if length != 2:   # DTime, SF(signed), MI
-                     _warn('key_signature event, but length='+str(length))
-                 E = ['key_signature',time] + list(struct.unpack(">bB",trackdata[0:2]))
-            elif (command == 0x7F):   # 6.4
-                 E = ['sequencer_specific',time, bytes(trackdata[0:length])]
+                if length != 2:  # DTime, SF(signed), MI
+                    _warn('key_signature event, but length=' + str(length))
+                E = ['key_signature', time] + list(struct.unpack(">bB", trackdata[0:2]))
+            elif (command == 0x7F):  # 6.4
+                E = ['sequencer_specific', time, bytes(trackdata[0:length])]
             else:
-                 E = ['raw_meta_event', time, command,
-                   bytes(trackdata[0:length])]   # 6.0
-                 #"[uninterpretable meta-event command of length length]"
-                 # DTime, Command, Binary Data
-                 # It's uninterpretable; record it as raw_data.
+                E = ['raw_meta_event', time, command,
+                     bytes(trackdata[0:length])]  # 6.0
+                # "[uninterpretable meta-event command of length length]"
+                # DTime, Command, Binary Data
+                # It's uninterpretable; record it as raw_data.
 
             # Pointer += length; #  Now move Pointer
             trackdata = trackdata[length:]
@@ -1419,7 +1307,7 @@ The options:
             # is omitted if this is a non-final block in a multiblock sysex;
             # but the F7 (if there) is counted in the message's declared
             # length, so we don't have to think about it anyway.)
-            #command = trackdata.pop(0)
+            # command = trackdata.pop(0)
             [length, trackdata] = _unshift_ber_int(trackdata)
             if first_byte == 0xF0:
                 # 20091008 added ISO-8859-1 to get an 8-bit str
@@ -1443,32 +1331,32 @@ The options:
         # from the MIDI file spec.  So, I'm going to assume that
         # they CAN, in practice, occur.  I don't know whether it's
         # proper for you to actually emit these into a MIDI file.
-        
-        elif (first_byte == 0xF2):   # DTime, Beats
+
+        elif (first_byte == 0xF2):  # DTime, Beats
             #  <song position msg> ::=     F2 <data pair>
             E = ['song_position', time, _read_14_bit(trackdata[:2])]
             trackdata = trackdata[2:]
 
-        elif (first_byte == 0xF3):   # <song select msg> ::= F3 <data singlet>
+        elif (first_byte == 0xF3):  # <song select msg> ::= F3 <data singlet>
             # E = ['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]]
             E = ['song_select', time, trackdata[0]]
             trackdata = trackdata[1:]
             # DTime, Thing (what?! song number?  whatever ...)
 
-        elif (first_byte == 0xF6):   # DTime
+        elif (first_byte == 0xF6):  # DTime
             E = ['tune_request', time]
             # What would a tune request be doing in a MIDI /file/?
 
-        #########################################################
-        # ADD MORE META-EVENTS HERE.  TODO:
-        # f1 -- MTC Quarter Frame Message. One data byte follows
-        #     the Status; it's the time code value, from 0 to 127.
-        # f8 -- MIDI clock.    no data.
-        # fa -- MIDI start.    no data.
-        # fb -- MIDI continue. no data.
-        # fc -- MIDI stop.     no data.
-        # fe -- Active sense.  no data.
-        # f4 f5 f9 fd -- unallocated
+            #########################################################
+            # ADD MORE META-EVENTS HERE.  TODO:
+            # f1 -- MTC Quarter Frame Message. One data byte follows
+            #     the Status; it's the time code value, from 0 to 127.
+            # f8 -- MIDI clock.    no data.
+            # fa -- MIDI start.    no data.
+            # fb -- MIDI continue. no data.
+            # fc -- MIDI stop.     no data.
+            # fe -- Active sense.  no data.
+            # f4 f5 f9 fd -- unallocated
 
             r'''
         elif (first_byte > 0xF0) { # Some unknown kinda F-series event ####
@@ -1483,31 +1371,30 @@ The options:
         elif first_byte > 0xF0:  # Some unknown F-series event
             # Here we only produce a one-byte piece of raw data.
             # E = ['raw_data', time, bytest(trackdata[0])]   # 6.4
-            E = ['raw_data', time, trackdata[0]]   # 6.4 6.7
+            E = ['raw_data', time, trackdata[0]]  # 6.4 6.7
             trackdata = trackdata[1:]
         else:  # Fallthru.
-            _warn("Aborting track.  Command-byte first_byte="+hex(first_byte))
+            _warn("Aborting track.  Command-byte first_byte=" + hex(first_byte))
             break
         # End of the big if-group
 
-
         ######################################################################
         #  THE EVENT REGISTRAR...
-        if E and  (E[0] == 'end_track'):
+        if E and (E[0] == 'end_track'):
             # This is the code for exceptional handling of the EOT event.
             eot = True
             if not no_eot_magic:
                 if E[1] > 0:  # a null text-event to carry the delta-time
                     E = ['text_event', E[1], '']
                 else:
-                    E = []   # EOT with a delta-time of 0; ignore it.
-        
+                    E = []  # EOT with a delta-time of 0; ignore it.
+
         if E and not (E[0] in exclude):
-            #if ( $exclusive_event_callback ):
+            # if ( $exclusive_event_callback ):
             #    &{ $exclusive_event_callback }( @E );
-            #else:
+            # else:
             #    &{ $event_callback }( @E ) if $event_callback;
-                events.append(E)
+            events.append(E)
         if eot:
             break
 
@@ -1518,7 +1405,7 @@ The options:
 
 ###########################################################################
 def _encode(events_lol, unknown_callback=None, never_add_eot=False,
-  no_eot_magic=False, no_running_status=False):
+  no_eot_magic=False, no_running_status=False, text_encoding='ISO-8859-1'):
     # encode an event structure, presumably for writing to a file
     # Calling format:
     #   $data_r = MIDI::Event::encode( \@event_lol, { options } );
@@ -1630,42 +1517,42 @@ def _encode(events_lol, unknown_callback=None, never_add_eot=False,
             last_status = -1
 
             if event == 'raw_meta_event':
-                event_data = _some_text_event(int(E[0]), E[1])
+                event_data = _some_text_event(int(E[0]), E[1], text_encoding)
             elif (event == 'set_sequence_number'):  # 3.9
                 event_data = b'\xFF\x00\x02'+_int2twobytes(E[0])
 
             # Text meta-events...
             # a case for a dict, I think (pjb) ...
             elif (event == 'text_event'):
-                event_data = _some_text_event(0x01, E[0])
+                event_data = _some_text_event(0x01, E[0], text_encoding)
             elif (event == 'copyright_text_event'):
-                event_data = _some_text_event(0x02, E[0])
+                event_data = _some_text_event(0x02, E[0], text_encoding)
             elif (event == 'track_name'):
-                event_data = _some_text_event(0x03, E[0])
+                event_data = _some_text_event(0x03, E[0], text_encoding)
             elif (event == 'instrument_name'):
-                event_data = _some_text_event(0x04, E[0])
+                event_data = _some_text_event(0x04, E[0], text_encoding)
             elif (event == 'lyric'):
-                event_data = _some_text_event(0x05, E[0])
+                event_data = _some_text_event(0x05, E[0], text_encoding)
             elif (event == 'marker'):
-                event_data = _some_text_event(0x06, E[0])
+                event_data = _some_text_event(0x06, E[0], text_encoding)
             elif (event == 'cue_point'):
-                event_data = _some_text_event(0x07, E[0])
+                event_data = _some_text_event(0x07, E[0], text_encoding)
             elif (event == 'text_event_08'):
-                event_data = _some_text_event(0x08, E[0])
+                event_data = _some_text_event(0x08, E[0], text_encoding)
             elif (event == 'text_event_09'):
-                event_data = _some_text_event(0x09, E[0])
+                event_data = _some_text_event(0x09, E[0], text_encoding)
             elif (event == 'text_event_0a'):
-                event_data = _some_text_event(0x0A, E[0])
+                event_data = _some_text_event(0x0A, E[0], text_encoding)
             elif (event == 'text_event_0b'):
-                event_data = _some_text_event(0x0B, E[0])
+                event_data = _some_text_event(0x0B, E[0], text_encoding)
             elif (event == 'text_event_0c'):
-                event_data = _some_text_event(0x0C, E[0])
+                event_data = _some_text_event(0x0C, E[0], text_encoding)
             elif (event == 'text_event_0d'):
-                event_data = _some_text_event(0x0D, E[0])
+                event_data = _some_text_event(0x0D, E[0], text_encoding)
             elif (event == 'text_event_0e'):
-                event_data = _some_text_event(0x0E, E[0])
+                event_data = _some_text_event(0x0E, E[0], text_encoding)
             elif (event == 'text_event_0f'):
-                event_data = _some_text_event(0x0F, E[0])
+                event_data = _some_text_event(0x0F, E[0], text_encoding)
             # End of text meta-events
 
             elif (event == 'end_track'):
@@ -1685,7 +1572,7 @@ def _encode(events_lol, unknown_callback=None, never_add_eot=False,
                 event_data = struct.pack(">BBBbB", 0xFF, 0x59, 0x02, E[0],E[1])
             elif (event == 'sequencer_specific'):
                 # event_data = struct.pack(">BBwa*", 0xFF,0x7F, len(E[0]), E[0])
-                event_data = _some_text_event(0x7F, E[0])
+                event_data = _some_text_event(0x7F, E[0], text_encoding)
             # End of Meta-events
 
             # Other Things...
@@ -1730,3 +1617,517 @@ def _encode(events_lol, unknown_callback=None, never_add_eot=False,
 
     return b''.join(data)
 
+###################################################################################
+###################################################################################
+###################################################################################
+#
+#	Tegridy MIDI X Module (TMIDI X / tee-midi eks)
+#
+#	Based upon and includes the amazing MIDI.py module v.6.7. by Peter Billam
+#	pjb.com.au
+#
+#	Project Los Angeles
+#	Tegridy Code 2025
+#
+#   https://github.com/Tegridy-Code/Project-Los-Angeles
+#
+###################################################################################
+###################################################################################
+###################################################################################
+
+import os
+
+import datetime
+
+from datetime import datetime
+
+import pickle
+
+import matplotlib.pyplot as plt
+
+###################################################################################
+#
+# Original TMIDI Tegridy helper functions
+#
+###################################################################################
+
+def Tegridy_TXT_to_INT_Converter(input_TXT_string, line_by_line_INT_string=True, max_INT = 0):
+
+    '''Tegridy TXT to Intergers Converter
+     
+    Input: Input TXT string in the TMIDI-TXT format
+
+           Type of output TXT INT string: line-by-line or one long string
+
+           Maximum absolute integer to process. Maximum is inclusive 
+           Default = process all integers. This helps to remove outliers/unwanted ints
+
+    Output: List of pure intergers
+            String of intergers in the specified format: line-by-line or one long string
+            Number of processed integers
+            Number of skipped integers
+    
+    Project Los Angeles
+    Tegridy Code 2021'''
+
+    print('Tegridy TXT to Intergers Converter')
+
+    output_INT_list = []
+
+    npi = 0
+    nsi = 0
+
+    TXT_List = list(input_TXT_string)
+    for char in TXT_List:
+      if max_INT != 0:
+        if abs(ord(char)) <= max_INT:
+          output_INT_list.append(ord(char))
+          npi += 1
+        else:
+          nsi += 1  
+      else:
+        output_INT_list.append(ord(char))
+        npi += 1    
+    
+    if line_by_line_INT_string:
+      output_INT_string = '\n'.join([str(elem) for elem in output_INT_list])
+    else:
+      output_INT_string = ' '.join([str(elem) for elem in output_INT_list])  
+
+    print('Converted TXT to INTs:', npi, ' / ', nsi)
+
+    return output_INT_list, output_INT_string, npi, nsi
+
+###################################################################################
+
+def Tegridy_INT_to_TXT_Converter(input_INT_list):
+
+    '''Tegridy Intergers to TXT Converter
+     
+    Input: List of intergers in TMIDI-TXT-INT format
+    Output: Decoded TXT string in TMIDI-TXT format
+    Project Los Angeles
+    Tegridy Code 2020'''
+
+    output_TXT_string = ''
+
+    for i in input_INT_list:
+      output_TXT_string += chr(int(i))
+    
+    return output_TXT_string
+
+###################################################################################
+
+def Tegridy_INT_String_to_TXT_Converter(input_INT_String, line_by_line_input=True):
+
+    '''Tegridy Intergers String to TXT Converter
+     
+    Input: List of intergers in TMIDI-TXT-INT-String format
+    Output: Decoded TXT string in TMIDI-TXT format
+    Project Los Angeles
+    Tegridy Code 2020'''
+    
+    print('Tegridy Intergers String to TXT Converter')
+
+    if line_by_line_input:
+      input_string = input_INT_String.split('\n')
+    else:
+      input_string = input_INT_String.split(' ')  
+
+    output_TXT_string = ''
+
+    for i in input_string:
+      try:
+        output_TXT_string += chr(abs(int(i)))
+      except:
+        print('Bad note:', i)
+        continue  
+    
+    print('Done!')
+
+    return output_TXT_string
+
+###################################################################################
+
+def Tegridy_SONG_to_MIDI_Converter(SONG,
+                                  output_signature = 'Tegridy TMIDI Module', 
+                                  track_name = 'Composition Track',
+                                  number_of_ticks_per_quarter = 425,
+                                  list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0],
+                                  output_file_name = 'TMIDI-Composition',
+                                  text_encoding='ISO-8859-1',
+                                  verbose=True):
+
+    '''Tegridy SONG to MIDI Converter
+     
+    Input: Input SONG in TMIDI SONG/MIDI.py Score format
+           Output MIDI Track 0 name / MIDI Signature
+           Output MIDI Track 1 name / Composition track name
+           Number of ticks per quarter for the output MIDI
+           List of 16 MIDI patch numbers for output MIDI. Def. is MuseNet compatible patches.
+           Output file name w/o .mid extension.
+           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
+
+    Output: MIDI File
+            Detailed MIDI stats
+
+    Project Los Angeles
+    Tegridy Code 2020'''                                  
+    
+    if verbose:
+        print('Converting to MIDI. Please stand-by...')
+    
+    output_header = [number_of_ticks_per_quarter, 
+                    [['track_name', 0, bytes(output_signature, text_encoding)]]]                                                    
+
+    patch_list = [['patch_change', 0, 0, list_of_MIDI_patches[0]], 
+                    ['patch_change', 0, 1, list_of_MIDI_patches[1]],
+                    ['patch_change', 0, 2, list_of_MIDI_patches[2]],
+                    ['patch_change', 0, 3, list_of_MIDI_patches[3]],
+                    ['patch_change', 0, 4, list_of_MIDI_patches[4]],
+                    ['patch_change', 0, 5, list_of_MIDI_patches[5]],
+                    ['patch_change', 0, 6, list_of_MIDI_patches[6]],
+                    ['patch_change', 0, 7, list_of_MIDI_patches[7]],
+                    ['patch_change', 0, 8, list_of_MIDI_patches[8]],
+                    ['patch_change', 0, 9, list_of_MIDI_patches[9]],
+                    ['patch_change', 0, 10, list_of_MIDI_patches[10]],
+                    ['patch_change', 0, 11, list_of_MIDI_patches[11]],
+                    ['patch_change', 0, 12, list_of_MIDI_patches[12]],
+                    ['patch_change', 0, 13, list_of_MIDI_patches[13]],
+                    ['patch_change', 0, 14, list_of_MIDI_patches[14]],
+                    ['patch_change', 0, 15, list_of_MIDI_patches[15]],
+                    ['track_name', 0, bytes(track_name, text_encoding)]]
+
+    output = output_header + [patch_list + SONG]
+
+    midi_data = score2midi(output, text_encoding)
+    detailed_MIDI_stats = score2stats(output)
+
+    with open(output_file_name + '.mid', 'wb') as midi_file:
+        midi_file.write(midi_data)
+        midi_file.close()
+    
+    if verbose:    
+        print('Done! Enjoy! :)')
+    
+    return detailed_MIDI_stats
+
+###################################################################################
+
+def Tegridy_ms_SONG_to_MIDI_Converter(ms_SONG,
+                                      output_signature = 'Tegridy TMIDI Module', 
+                                      track_name = 'Composition Track',
+                                      list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0],
+                                      output_file_name = 'TMIDI-Composition',
+                                      text_encoding='ISO-8859-1',
+                                      timings_multiplier=1,
+                                      verbose=True
+                                      ):
+
+    '''Tegridy milisecond SONG to MIDI Converter
+     
+    Input: Input ms SONG in TMIDI ms SONG/MIDI.py ms Score format
+           Output MIDI Track 0 name / MIDI Signature
+           Output MIDI Track 1 name / Composition track name
+           List of 16 MIDI patch numbers for output MIDI. Def. is MuseNet compatible patches.
+           Output file name w/o .mid extension.
+           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
+           Optional timings multiplier
+           Optional verbose output
+
+    Output: MIDI File
+            Detailed MIDI stats
+
+    Project Los Angeles
+    Tegridy Code 2024'''                                  
+    
+    if verbose:
+        print('Converting to MIDI. Please stand-by...')
+
+    output_header = [1000,
+                    [['set_tempo', 0, 1000000],
+                     ['time_signature', 0, 4, 2, 24, 8],
+                     ['track_name', 0, bytes(output_signature, text_encoding)]]]
+
+    patch_list = [['patch_change', 0, 0, list_of_MIDI_patches[0]], 
+                    ['patch_change', 0, 1, list_of_MIDI_patches[1]],
+                    ['patch_change', 0, 2, list_of_MIDI_patches[2]],
+                    ['patch_change', 0, 3, list_of_MIDI_patches[3]],
+                    ['patch_change', 0, 4, list_of_MIDI_patches[4]],
+                    ['patch_change', 0, 5, list_of_MIDI_patches[5]],
+                    ['patch_change', 0, 6, list_of_MIDI_patches[6]],
+                    ['patch_change', 0, 7, list_of_MIDI_patches[7]],
+                    ['patch_change', 0, 8, list_of_MIDI_patches[8]],
+                    ['patch_change', 0, 9, list_of_MIDI_patches[9]],
+                    ['patch_change', 0, 10, list_of_MIDI_patches[10]],
+                    ['patch_change', 0, 11, list_of_MIDI_patches[11]],
+                    ['patch_change', 0, 12, list_of_MIDI_patches[12]],
+                    ['patch_change', 0, 13, list_of_MIDI_patches[13]],
+                    ['patch_change', 0, 14, list_of_MIDI_patches[14]],
+                    ['patch_change', 0, 15, list_of_MIDI_patches[15]],
+                    ['track_name', 0, bytes(track_name, text_encoding)]]
+
+    SONG = copy.deepcopy(ms_SONG)
+
+    if timings_multiplier != 1:
+      for S in SONG:
+        S[1] = S[1] * timings_multiplier
+        if S[0] == 'note':
+          S[2] = S[2] * timings_multiplier
+
+    output = output_header + [patch_list + SONG]
+
+    midi_data = score2midi(output, text_encoding)
+    detailed_MIDI_stats = score2stats(output)
+
+    with open(output_file_name + '.mid', 'wb') as midi_file:
+        midi_file.write(midi_data)
+        midi_file.close()
+    
+    if verbose:    
+        print('Done! Enjoy! :)')
+    
+    return detailed_MIDI_stats
+
+###################################################################################
+
+def hsv_to_rgb(h, s, v):
+    if s == 0.0:
+        return v, v, v
+    i = int(h*6.0)
+    f = (h*6.0) - i
+    p = v*(1.0 - s)
+    q = v*(1.0 - s*f)
+    t = v*(1.0 - s*(1.0-f))
+    i = i%6
+    return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
+
+def generate_colors(n):
+    return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
+
+def add_arrays(a, b):
+    return [sum(pair) for pair in zip(a, b)]
+
+#-------------------------------------------------------------------------------
+
+def plot_ms_SONG(ms_song,
+                  preview_length_in_notes=0,
+                  block_lines_times_list = None,
+                  plot_title='ms Song',
+                  max_num_colors=129, 
+                  drums_color_num=128, 
+                  plot_size=(11,4), 
+                  note_height = 0.75,
+                  show_grid_lines=False,
+                  return_plt = False,
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
+                  ):
+
+  '''Tegridy ms SONG plotter/vizualizer'''
+
+  notes = [s for s in ms_song if s[0] == 'note']
+
+  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
+    print('The song notes do not have patches information')
+    print('Ploease add patches to the notes in the song')
+
+  else:
+
+    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
+    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
+    pitches = [s[4] for s in notes]
+    patches = [s[6] for s in notes]
+
+    colors = generate_colors(max_num_colors)
+    colors[drums_color_num] = (1, 1, 1)
+
+    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
+
+    fig, ax = plt.subplots(figsize=plot_size)
+    #fig, ax = plt.subplots()
+
+    # Create a rectangle for each note with color based on patch number
+    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
+        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
+        ax.add_patch(rect)
+
+    # Set the limits of the plot
+    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
+    ax.set_ylim([min(pitches)-1, max(pitches)+1])
+
+    # Set the background color to black
+    ax.set_facecolor('black')
+    fig.patch.set_facecolor('white')
+
+    if preview_length_in_notes > 0:
+      ax.axvline(x=pbl, c='white')
+
+    if block_lines_times_list:
+      for bl in block_lines_times_list:
+        ax.axvline(x=bl, c='white')
+           
+    if show_grid_lines:
+      ax.grid(color='white')
+
+    plt.xlabel('Time (s)', c='black')
+    plt.ylabel('MIDI Pitch', c='black')
+
+    plt.title(plot_title)
+
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, transparent=save_transparent, bbox_inches='tight', pad_inches=0, facecolor='black')
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
+    if return_plt:
+      plt.close(fig)
+      return fig
+
+    plt.show()
+    plt.close()
+
+###################################################################################
+
+def Tegridy_SONG_to_Full_MIDI_Converter(SONG,
+                                        output_signature = 'Tegridy TMIDI Module', 
+                                        track_name = 'Composition Track',
+                                        number_of_ticks_per_quarter = 1000,
+                                        output_file_name = 'TMIDI-Composition',
+                                        text_encoding='ISO-8859-1',
+                                        verbose=True):
+
+    '''Tegridy SONG to Full MIDI Converter
+     
+    Input: Input SONG in Full TMIDI SONG/MIDI.py Score format
+           Output MIDI Track 0 name / MIDI Signature
+           Output MIDI Track 1 name / Composition track name
+           Number of ticks per quarter for the output MIDI
+           Output file name w/o .mid extension.
+           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
+
+    Output: MIDI File
+            Detailed MIDI stats
+
+    Project Los Angeles
+    Tegridy Code 2023'''                                  
+    
+    if verbose:
+        print('Converting to MIDI. Please stand-by...')
+    
+    output_header = [number_of_ticks_per_quarter,
+                    [['set_tempo', 0, 1000000],
+                      ['track_name', 0, bytes(output_signature, text_encoding)]]]                                                    
+
+    song_track = [['track_name', 0, bytes(track_name, text_encoding)]]
+
+    output = output_header + [song_track + SONG]
+
+    midi_data = score2midi(output, text_encoding)
+    detailed_MIDI_stats = score2stats(output)
+
+    with open(output_file_name + '.mid', 'wb') as midi_file:
+        midi_file.write(midi_data)
+        midi_file.close()
+    
+    if verbose:    
+        print('Done! Enjoy! :)')
+    
+    return detailed_MIDI_stats
+
+###################################################################################
+
+def Tegridy_File_Time_Stamp(input_file_name='File_Created_on_', ext = ''):
+
+  '''Tegridy File Time Stamp
+     
+  Input: Full path and file name without extention
+         File extension
+          
+  Output: File name string with time-stamp and extension (time-stamped file name)
+
+  Project Los Angeles
+  Tegridy Code 2021'''       
+
+  print('Time-stamping output file...')
+
+  now = ''
+  now_n = str(datetime.now())
+  now_n = now_n.replace(' ', '_')
+  now_n = now_n.replace(':', '_')
+  now = now_n.replace('.', '_')
+      
+  fname = input_file_name + str(now) + ext
+
+  return(fname)
+
+###################################################################################
+
+def Tegridy_Any_Pickle_File_Writer(Data, input_file_name='TMIDI_Pickle_File'):
+
+  '''Tegridy Pickle File Writer
+     
+  Input: Data to write (I.e. a list)
+         Full path and file name without extention
+         
+  Output: Named Pickle file
+
+  Project Los Angeles
+  Tegridy Code 2021'''
+
+  print('Tegridy Pickle File Writer')
+
+  full_path_to_output_dataset_to = input_file_name + '.pickle'
+
+  if os.path.exists(full_path_to_output_dataset_to):
+    os.remove(full_path_to_output_dataset_to)
+    print('Removing old Dataset...')
+  else:
+    print("Creating new Dataset file...")
+
+  with open(full_path_to_output_dataset_to, 'wb') as filehandle:
+    # store the data as binary data stream
+    pickle.dump(Data, filehandle, protocol=pickle.HIGHEST_PROTOCOL)
+
+  print('Dataset was saved as:', full_path_to_output_dataset_to)
+  print('Task complete. Enjoy! :)')
+
+###################################################################################
+
+def Tegridy_Any_Pickle_File_Reader(input_file_name='TMIDI_Pickle_File', ext='.pickle', verbose=True):
+
+  '''Tegridy Pickle File Loader
+     
+  Input: Full path and file name with or without extention
+         File extension if different from default .pickle
+       
+  Output: Standard Python 3 unpickled data object
+
+  Project Los Angeles
+  Tegridy Code 2021'''
+
+  if verbose:
+    print('Tegridy Pickle File Loader')
+    print('Loading the pickle file. Please wait...')
+
+  if os.path.basename(input_file_name).endswith(ext):
+    fname = input_file_name
+  
+  else:
+    fname = input_file_name + ext
+
+  with open(fname, 'rb') as pickle_file:
+    content = pickle.load(pickle_file)
+
+  if verbose:
+    print('Done!')
+
+  return content

TMIDIX.py → src/TMIDIX.py

@@ -1,2007 +1,29 @@
 #! /usr/bin/python3
 
-r'''###############################################################################
-###################################################################################
-#
-#
-#	Tegridy MIDI X Module (TMIDI X / tee-midi eks)
-#
-#   NOTE: TMIDI X Module starts after the partial MIDI.py module @ line 1450
-#
-#	Based upon MIDI.py module v.6.7. by Peter Billam / pjb.com.au
-#
-#	Project Los Angeles
-#
-#	Tegridy Code 2025
-#
-#   https://github.com/Tegridy-Code/Project-Los-Angeles
-#
-#
-###################################################################################
-###################################################################################
-#   Copyright 2025 Project Los Angeles / Tegridy Code
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-###################################################################################
-###################################################################################
-#
-#	PARTIAL MIDI.py Module v.6.7. by Peter Billam
-#   Please see TMIDI 2.3/tegridy-tools repo for full MIDI.py module code
-# 
-#   Or you can always download the latest full version from:
-#
-#   https://pjb.com.au/
-#   https://peterbillam.gitlab.io/miditools/
-#	
-#	Copyright 2020 Peter Billam
-#
-###################################################################################
-###################################################################################
-'''
-
-###################################################################################
-
-__version__ = "25.7.8"
-
-print('=' * 70)
-print('TMIDIX Python module')
-print('Version:', __version__)
-print('=' * 70)
-print('Loading module...')
-
-###################################################################################
-
-import sys, struct, copy
-
-Version = '6.7'
-VersionDate = '20201120'
-
-_previous_warning = ''  # 5.4
-_previous_times = 0     # 5.4
-_no_warning = False
-
-#------------------------------- Encoding stuff --------------------------
-
-def opus2midi(opus=[], text_encoding='ISO-8859-1'):
-    r'''The argument is a list: the first item in the list is the "ticks"
-parameter, the others are the tracks. Each track is a list
-of midi-events, and each event is itself a list; see above.
-opus2midi() returns a bytestring of the MIDI, which can then be
-written either to a file opened in binary mode (mode='wb'),
-or to stdout by means of:   sys.stdout.buffer.write()
-
-my_opus = [
-    96, 
-    [   # track 0:
-        ['patch_change', 0, 1, 8],   # and these are the events...
-        ['note_on',   5, 1, 25, 96],
-        ['note_off', 96, 1, 25, 0],
-        ['note_on',   0, 1, 29, 96],
-        ['note_off', 96, 1, 29, 0],
-    ],   # end of track 0
-]
-my_midi = opus2midi(my_opus)
-sys.stdout.buffer.write(my_midi)
-'''
-    if len(opus) < 2:
-        opus=[1000, [],]
-    tracks = copy.deepcopy(opus)
-    ticks = int(tracks.pop(0))
-    ntracks = len(tracks)
-    if ntracks == 1:
-        format = 0
-    else:
-        format = 1
-
-    my_midi = b"MThd\x00\x00\x00\x06"+struct.pack('>HHH',format,ntracks,ticks)
-    for track in tracks:
-        events = _encode(track, text_encoding=text_encoding)
-        my_midi += b'MTrk' + struct.pack('>I',len(events)) + events
-    _clean_up_warnings()
-    return my_midi
-
-
-def score2opus(score=None, text_encoding='ISO-8859-1'):
-    r'''
-The argument is a list: the first item in the list is the "ticks"
-parameter, the others are the tracks. Each track is a list
-of score-events, and each event is itself a list.  A score-event
-is similar to an opus-event (see above), except that in a score:
- 1) the times are expressed as an absolute number of ticks
-    from the track's start time
- 2) the pairs of 'note_on' and 'note_off' events in an "opus"
-    are abstracted into a single 'note' event in a "score":
-    ['note', start_time, duration, channel, pitch, velocity]
-score2opus() returns a list specifying the equivalent "opus".
-
-my_score = [
-    96,
-    [   # track 0:
-        ['patch_change', 0, 1, 8],
-        ['note', 5, 96, 1, 25, 96],
-        ['note', 101, 96, 1, 29, 96]
-    ],   # end of track 0
-]
-my_opus = score2opus(my_score)
-'''
-    if len(score) < 2:
-        score=[1000, [],]
-    tracks = copy.deepcopy(score)
-    ticks = int(tracks.pop(0))
-    opus_tracks = []
-    for scoretrack in tracks:
-        time2events = dict([])
-        for scoreevent in scoretrack:
-            if scoreevent[0] == 'note':
-                note_on_event = ['note_on',scoreevent[1],
-                 scoreevent[3],scoreevent[4],scoreevent[5]]
-                note_off_event = ['note_off',scoreevent[1]+scoreevent[2],
-                 scoreevent[3],scoreevent[4],scoreevent[5]]
-                if time2events.get(note_on_event[1]):
-                   time2events[note_on_event[1]].append(note_on_event)
-                else:
-                   time2events[note_on_event[1]] = [note_on_event,]
-                if time2events.get(note_off_event[1]):
-                   time2events[note_off_event[1]].append(note_off_event)
-                else:
-                   time2events[note_off_event[1]] = [note_off_event,]
-                continue
-            if time2events.get(scoreevent[1]):
-               time2events[scoreevent[1]].append(scoreevent)
-            else:
-               time2events[scoreevent[1]] = [scoreevent,]
-
-        sorted_times = []  # list of keys
-        for k in time2events.keys():
-            sorted_times.append(k)
-        sorted_times.sort()
-
-        sorted_events = []  # once-flattened list of values sorted by key
-        for time in sorted_times:
-            sorted_events.extend(time2events[time])
-
-        abs_time = 0
-        for event in sorted_events:  # convert abs times => delta times
-            delta_time = event[1] - abs_time
-            abs_time = event[1]
-            event[1] = delta_time
-        opus_tracks.append(sorted_events)
-    opus_tracks.insert(0,ticks)
-    _clean_up_warnings()
-    return opus_tracks
-
-def score2midi(score=None, text_encoding='ISO-8859-1'):
-    r'''
-Translates a "score" into MIDI, using score2opus() then opus2midi()
-'''
-    return opus2midi(score2opus(score, text_encoding), text_encoding)
-
-#--------------------------- Decoding stuff ------------------------
-
-def midi2opus(midi=b'', do_not_check_MIDI_signature=False):
-    r'''Translates MIDI into a "opus".  For a description of the
-"opus" format, see opus2midi()
-'''
-    my_midi=bytearray(midi)
-    if len(my_midi) < 4:
-        _clean_up_warnings()
-        return [1000,[],]
-    id = bytes(my_midi[0:4])
-    if id != b'MThd':
-        _warn("midi2opus: midi starts with "+str(id)+" instead of 'MThd'")
-        _clean_up_warnings()
-        if do_not_check_MIDI_signature == False:
-          return [1000,[],]
-    [length, format, tracks_expected, ticks] = struct.unpack(
-     '>IHHH', bytes(my_midi[4:14]))
-    if length != 6:
-        _warn("midi2opus: midi header length was "+str(length)+" instead of 6")
-        _clean_up_warnings()
-        return [1000,[],]
-    my_opus = [ticks,]
-    my_midi = my_midi[14:]
-    track_num = 1   # 5.1
-    while len(my_midi) >= 8:
-        track_type   = bytes(my_midi[0:4])
-        if track_type != b'MTrk':
-            #_warn('midi2opus: Warning: track #'+str(track_num)+' type is '+str(track_type)+" instead of b'MTrk'")
-            pass
-        [track_length] = struct.unpack('>I', my_midi[4:8])
-        my_midi = my_midi[8:]
-        if track_length > len(my_midi):
-            _warn('midi2opus: track #'+str(track_num)+' length '+str(track_length)+' is too large')
-            _clean_up_warnings()
-            return my_opus   # 5.0
-        my_midi_track = my_midi[0:track_length]
-        my_track = _decode(my_midi_track)
-        my_opus.append(my_track)
-        my_midi = my_midi[track_length:]
-        track_num += 1   # 5.1
-    _clean_up_warnings()
-    return my_opus
-
-def opus2score(opus=[]):
-    r'''For a description of the "opus" and "score" formats,
-see opus2midi() and score2opus().
-'''
-    if len(opus) < 2:
-        _clean_up_warnings()
-        return [1000,[],]
-    tracks = copy.deepcopy(opus)  # couple of slices probably quicker...
-    ticks = int(tracks.pop(0))
-    score = [ticks,]
-    for opus_track in tracks:
-        ticks_so_far = 0
-        score_track = []
-        chapitch2note_on_events = dict([])   # 4.0
-        for opus_event in opus_track:
-            ticks_so_far += opus_event[1]
-            if opus_event[0] == 'note_off' or (opus_event[0] == 'note_on' and opus_event[4] == 0):  # 4.8
-                cha = opus_event[2]
-                pitch = opus_event[3]
-                key = cha*128 + pitch
-                if chapitch2note_on_events.get(key):
-                    new_event = chapitch2note_on_events[key].pop(0)
-                    new_event[2] = ticks_so_far - new_event[1]
-                    score_track.append(new_event)
-                elif pitch > 127:
-                    pass #_warn('opus2score: note_off with no note_on, bad pitch='+str(pitch))
-                else:
-                    pass #_warn('opus2score: note_off with no note_on cha='+str(cha)+' pitch='+str(pitch))
-            elif opus_event[0] == 'note_on':
-                cha = opus_event[2]
-                pitch = opus_event[3]
-                key = cha*128 + pitch
-                new_event = ['note',ticks_so_far,0,cha,pitch, opus_event[4]]
-                if chapitch2note_on_events.get(key):
-                    chapitch2note_on_events[key].append(new_event)
-                else:
-                    chapitch2note_on_events[key] = [new_event,]
-            else:
-                opus_event[1] = ticks_so_far
-                score_track.append(opus_event)
-        # check for unterminated notes (Oisín) -- 5.2
-        for chapitch in chapitch2note_on_events:
-            note_on_events = chapitch2note_on_events[chapitch]
-            for new_e in note_on_events:
-                new_e[2] = ticks_so_far - new_e[1]
-                score_track.append(new_e)
-                pass #_warn("opus2score: note_on with no note_off cha="+str(new_e[3])+' pitch='+str(new_e[4])+'; adding note_off at end')
-        score.append(score_track)
-    _clean_up_warnings()
-    return score
-
-def midi2score(midi=b'', do_not_check_MIDI_signature=False):
-    r'''
-Translates MIDI into a "score", using midi2opus() then opus2score()
-'''
-    return opus2score(midi2opus(midi, do_not_check_MIDI_signature))
-
-def midi2ms_score(midi=b'', do_not_check_MIDI_signature=False):
-    r'''
-Translates MIDI into a "score" with one beat per second and one
-tick per millisecond, using midi2opus() then to_millisecs()
-then opus2score()
-'''
-    return opus2score(to_millisecs(midi2opus(midi, do_not_check_MIDI_signature)))
-
-def midi2single_track_ms_score(midi_path_or_bytes, 
-                                recalculate_channels = False, 
-                                pass_old_timings_events= False, 
-                                verbose = False, 
-                                do_not_check_MIDI_signature=False
-                                ):
-    r'''
-Translates MIDI into a single track "score" with 16 instruments and one beat per second and one
-tick per millisecond
-'''
-
-    if type(midi_path_or_bytes) == bytes:
-      midi_data = midi_path_or_bytes
-
-    elif type(midi_path_or_bytes) == str:
-      midi_data = open(midi_path_or_bytes, 'rb').read() 
-
-    score = midi2score(midi_data, do_not_check_MIDI_signature)
-
-    if recalculate_channels:
-
-      events_matrixes = []
-
-      itrack = 1
-      events_matrixes_channels = []
-      while itrack < len(score):
-          events_matrix = []
-          for event in score[itrack]:
-              if event[0] == 'note' and event[3] != 9:
-                event[3] = (16 * (itrack-1)) + event[3]
-                if event[3] not in events_matrixes_channels:
-                  events_matrixes_channels.append(event[3])
-
-              events_matrix.append(event)
-          events_matrixes.append(events_matrix)
-          itrack += 1
-
-      events_matrix1 = []
-      for e in events_matrixes:
-        events_matrix1.extend(e)
-
-      if verbose:
-        if len(events_matrixes_channels) > 16:
-          print('MIDI has', len(events_matrixes_channels), 'instruments!', len(events_matrixes_channels) - 16, 'instrument(s) will be removed!')
-
-      for e in events_matrix1:
-        if e[0] == 'note' and e[3] != 9:
-          if e[3] in events_matrixes_channels[:15]:
-            if events_matrixes_channels[:15].index(e[3]) < 9:
-              e[3] = events_matrixes_channels[:15].index(e[3])
-            else:
-              e[3] = events_matrixes_channels[:15].index(e[3])+1
-          else:
-            events_matrix1.remove(e)
-        
-        if e[0] in ['patch_change', 'control_change', 'channel_after_touch', 'key_after_touch', 'pitch_wheel_change'] and e[2] != 9:
-          if e[2] in [e % 16 for e in events_matrixes_channels[:15]]:
-            if [e % 16 for e in events_matrixes_channels[:15]].index(e[2]) < 9:
-              e[2] = [e % 16 for e in events_matrixes_channels[:15]].index(e[2])
-            else:
-              e[2] = [e % 16 for e in events_matrixes_channels[:15]].index(e[2])+1
-          else:
-            events_matrix1.remove(e)
-    
-    else:
-      events_matrix1 = []
-      itrack = 1
-     
-      while itrack < len(score):
-          for event in score[itrack]:
-            events_matrix1.append(event)
-          itrack += 1    
-
-    opus = score2opus([score[0], events_matrix1])
-    ms_score = opus2score(to_millisecs(opus, pass_old_timings_events=pass_old_timings_events))
-
-    return ms_score
-
-#------------------------ Other Transformations ---------------------
-
-def to_millisecs(old_opus=None, desired_time_in_ms=1, pass_old_timings_events = False):
-    r'''Recallibrates all the times in an "opus" to use one beat
-per second and one tick per millisecond.  This makes it
-hard to retrieve any information about beats or barlines,
-but it does make it easy to mix different scores together.
-'''
-    if old_opus == None:
-        return [1000 * desired_time_in_ms,[],]
-    try:
-        old_tpq  = int(old_opus[0])
-    except IndexError:   # 5.0
-        _warn('to_millisecs: the opus '+str(type(old_opus))+' has no elements')
-        return [1000 * desired_time_in_ms,[],]
-    new_opus = [1000 * desired_time_in_ms,]
-    # 6.7 first go through building a table of set_tempos by absolute-tick
-    ticks2tempo = {}
-    itrack = 1
-    while itrack < len(old_opus):
-        ticks_so_far = 0
-        for old_event in old_opus[itrack]:
-            if old_event[0] == 'note':
-                raise TypeError('to_millisecs needs an opus, not a score')
-            ticks_so_far += old_event[1]
-            if old_event[0] == 'set_tempo':
-                ticks2tempo[ticks_so_far] = old_event[2]
-        itrack += 1
-    # then get the sorted-array of their keys
-    tempo_ticks = []  # list of keys
-    for k in ticks2tempo.keys():
-        tempo_ticks.append(k)
-    tempo_ticks.sort()
-    # then go through converting to millisec, testing if the next
-    # set_tempo lies before the next track-event, and using it if so.
-    itrack = 1
-    while itrack < len(old_opus):
-        ms_per_old_tick = 400 / old_tpq  # float: will round later 6.3
-        i_tempo_ticks = 0
-        ticks_so_far = 0
-        ms_so_far = 0.0
-        previous_ms_so_far = 0.0
-
-        if pass_old_timings_events:
-          new_track = [['set_tempo',0,1000000 * desired_time_in_ms],['old_tpq', 0, old_tpq]]  # new "crochet" is 1 sec
-        else:
-          new_track = [['set_tempo',0,1000000 * desired_time_in_ms],]  # new "crochet" is 1 sec
-        for old_event in old_opus[itrack]:
-            # detect if ticks2tempo has something before this event
-            # 20160702 if ticks2tempo is at the same time, leave it
-            event_delta_ticks = old_event[1] * desired_time_in_ms
-            if (i_tempo_ticks < len(tempo_ticks) and
-              tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[1]) * desired_time_in_ms):
-                delta_ticks = tempo_ticks[i_tempo_ticks] - ticks_so_far
-                ms_so_far += (ms_per_old_tick * delta_ticks * desired_time_in_ms)
-                ticks_so_far = tempo_ticks[i_tempo_ticks]
-                ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq * desired_time_in_ms)
-                i_tempo_ticks += 1
-                event_delta_ticks -= delta_ticks
-            new_event = copy.deepcopy(old_event)  # now handle the new event
-            ms_so_far += (ms_per_old_tick * old_event[1] * desired_time_in_ms)
-            new_event[1] = round(ms_so_far - previous_ms_so_far)
-
-            if pass_old_timings_events:
-              if old_event[0] != 'set_tempo':
-                  previous_ms_so_far = ms_so_far
-                  new_track.append(new_event)
-              else:
-                  new_event[0] = 'old_set_tempo'
-                  previous_ms_so_far = ms_so_far
-                  new_track.append(new_event)
-            else:
-              if old_event[0] != 'set_tempo':
-                  previous_ms_so_far = ms_so_far
-                  new_track.append(new_event)
-            ticks_so_far += event_delta_ticks
-        new_opus.append(new_track)
-        itrack += 1
-    _clean_up_warnings()
-    return new_opus
-
-def event2alsaseq(event=None):   # 5.5
-    r'''Converts an event into the format needed by the alsaseq module,
-http://pp.com.mx/python/alsaseq
-The type of track (opus or score) is autodetected.
-'''
-    pass
-
-def grep(score=None, channels=None):
-    r'''Returns a "score" containing only the channels specified
-'''
-    if score == None:
-        return [1000,[],]
-    ticks = score[0]
-    new_score = [ticks,]
-    if channels == None:
-        return new_score
-    channels = set(channels)
-    global Event2channelindex
-    itrack = 1
-    while itrack < len(score):
-        new_score.append([])
-        for event in score[itrack]:
-            channel_index = Event2channelindex.get(event[0], False)
-            if channel_index:
-                if event[channel_index] in channels:
-                    new_score[itrack].append(event)
-            else:
-                new_score[itrack].append(event)
-        itrack += 1
-    return new_score
-
-def score2stats(opus_or_score=None):
-    r'''Returns a dict of some basic stats about the score, like
-bank_select (list of tuples (msb,lsb)),
-channels_by_track (list of lists), channels_total (set),
-general_midi_mode (list),
-ntracks, nticks, patch_changes_by_track (list of dicts),
-num_notes_by_channel (list of numbers),
-patch_changes_total (set),
-percussion (dict histogram of channel 9 events),
-pitches (dict histogram of pitches on channels other than 9),
-pitch_range_by_track (list, by track, of two-member-tuples),
-pitch_range_sum (sum over tracks of the pitch_ranges),
-'''
-    bank_select_msb = -1
-    bank_select_lsb = -1
-    bank_select = []
-    channels_by_track = []
-    channels_total    = set([])
-    general_midi_mode = []
-    num_notes_by_channel = dict([])
-    patches_used_by_track  = []
-    patches_used_total     = set([])
-    patch_changes_by_track = []
-    patch_changes_total    = set([])
-    percussion = dict([]) # histogram of channel 9 "pitches"
-    pitches    = dict([]) # histogram of pitch-occurrences channels 0-8,10-15
-    pitch_range_sum = 0   # u pitch-ranges of each track
-    pitch_range_by_track = []
-    is_a_score = True
-    if opus_or_score == None:
-        return {'bank_select':[], 'channels_by_track':[], 'channels_total':[],
-         'general_midi_mode':[], 'ntracks':0, 'nticks':0,
-         'num_notes_by_channel':dict([]),
-         'patch_changes_by_track':[], 'patch_changes_total':[],
-         'percussion':{}, 'pitches':{}, 'pitch_range_by_track':[],
-         'ticks_per_quarter':0, 'pitch_range_sum':0}
-    ticks_per_quarter = opus_or_score[0]
-    i = 1   # ignore first element, which is ticks
-    nticks = 0
-    while i < len(opus_or_score):
-        highest_pitch = 0
-        lowest_pitch = 128
-        channels_this_track = set([])
-        patch_changes_this_track = dict({})
-        for event in opus_or_score[i]:
-            if event[0] == 'note':
-                num_notes_by_channel[event[3]] = num_notes_by_channel.get(event[3],0) + 1
-                if event[3] == 9:
-                    percussion[event[4]] = percussion.get(event[4],0) + 1
-                else:
-                    pitches[event[4]]    = pitches.get(event[4],0) + 1
-                    if event[4] > highest_pitch:
-                        highest_pitch = event[4]
-                    if event[4] < lowest_pitch:
-                        lowest_pitch = event[4]
-                channels_this_track.add(event[3])
-                channels_total.add(event[3])
-                finish_time = event[1] + event[2]
-                if finish_time > nticks:
-                    nticks = finish_time
-            elif event[0] == 'note_off' or (event[0] == 'note_on' and event[4] == 0):  # 4.8
-                finish_time = event[1]
-                if finish_time > nticks:
-                    nticks = finish_time
-            elif event[0] == 'note_on':
-                is_a_score = False
-                num_notes_by_channel[event[2]] = num_notes_by_channel.get(event[2],0) + 1
-                if event[2] == 9:
-                    percussion[event[3]] = percussion.get(event[3],0) + 1
-                else:
-                    pitches[event[3]]    = pitches.get(event[3],0) + 1
-                    if event[3] > highest_pitch:
-                        highest_pitch = event[3]
-                    if event[3] < lowest_pitch:
-                        lowest_pitch = event[3]
-                channels_this_track.add(event[2])
-                channels_total.add(event[2])
-            elif event[0] == 'patch_change':
-                patch_changes_this_track[event[2]] = event[3]
-                patch_changes_total.add(event[3])
-            elif event[0] == 'control_change':
-                if event[3] == 0:  # bank select MSB
-                    bank_select_msb = event[4]
-                elif event[3] == 32:  # bank select LSB
-                    bank_select_lsb = event[4]
-                if bank_select_msb >= 0 and bank_select_lsb >= 0:
-                    bank_select.append((bank_select_msb,bank_select_lsb))
-                    bank_select_msb = -1
-                    bank_select_lsb = -1
-            elif event[0] == 'sysex_f0':
-                if _sysex2midimode.get(event[2], -1) >= 0:
-                    general_midi_mode.append(_sysex2midimode.get(event[2]))
-            if is_a_score:
-                if event[1] > nticks:
-                    nticks = event[1]
-            else:
-                nticks += event[1]
-        if lowest_pitch == 128:
-            lowest_pitch = 0
-        channels_by_track.append(channels_this_track)
-        patch_changes_by_track.append(patch_changes_this_track)
-        pitch_range_by_track.append((lowest_pitch,highest_pitch))
-        pitch_range_sum += (highest_pitch-lowest_pitch)
-        i += 1
-
-    return {'bank_select':bank_select,
-            'channels_by_track':channels_by_track,
-            'channels_total':channels_total,
-            'general_midi_mode':general_midi_mode,
-            'ntracks':len(opus_or_score)-1,
-            'nticks':nticks,
-            'num_notes_by_channel':num_notes_by_channel,
-            'patch_changes_by_track':patch_changes_by_track,
-            'patch_changes_total':patch_changes_total,
-            'percussion':percussion,
-            'pitches':pitches,
-            'pitch_range_by_track':pitch_range_by_track,
-            'pitch_range_sum':pitch_range_sum,
-            'ticks_per_quarter':ticks_per_quarter}
-
-#----------------------------- Event stuff --------------------------
-
-_sysex2midimode = {
-    "\x7E\x7F\x09\x01\xF7": 1,
-    "\x7E\x7F\x09\x02\xF7": 0,
-    "\x7E\x7F\x09\x03\xF7": 2,
-}
-
-# Some public-access tuples:
-MIDI_events = tuple('''note_off note_on key_after_touch
-control_change patch_change channel_after_touch
-pitch_wheel_change'''.split())
-
-Text_events = tuple('''text_event copyright_text_event
-track_name instrument_name lyric marker cue_point text_event_08
-text_event_09 text_event_0a text_event_0b text_event_0c
-text_event_0d text_event_0e text_event_0f'''.split())
-
-Nontext_meta_events = tuple('''end_track set_tempo
-smpte_offset time_signature key_signature sequencer_specific
-raw_meta_event sysex_f0 sysex_f7 song_position song_select
-tune_request'''.split())
-# unsupported: raw_data
-
-# Actually, 'tune_request' is is F-series event, not strictly a meta-event...
-Meta_events = Text_events + Nontext_meta_events
-All_events  = MIDI_events + Meta_events
-
-# And three dictionaries:
-Number2patch = {   # General MIDI patch numbers:
-0:'Acoustic Grand',
-1:'Bright Acoustic',
-2:'Electric Grand',
-3:'Honky-Tonk',
-4:'Electric Piano 1',
-5:'Electric Piano 2',
-6:'Harpsichord',
-7:'Clav',
-8:'Celesta',
-9:'Glockenspiel',
-10:'Music Box',
-11:'Vibraphone',
-12:'Marimba',
-13:'Xylophone',
-14:'Tubular Bells',
-15:'Dulcimer',
-16:'Drawbar Organ',
-17:'Percussive Organ',
-18:'Rock Organ',
-19:'Church Organ',
-20:'Reed Organ',
-21:'Accordion',
-22:'Harmonica',
-23:'Tango Accordion',
-24:'Acoustic Guitar(nylon)',
-25:'Acoustic Guitar(steel)',
-26:'Electric Guitar(jazz)',
-27:'Electric Guitar(clean)',
-28:'Electric Guitar(muted)',
-29:'Overdriven Guitar',
-30:'Distortion Guitar',
-31:'Guitar Harmonics',
-32:'Acoustic Bass',
-33:'Electric Bass(finger)',
-34:'Electric Bass(pick)',
-35:'Fretless Bass',
-36:'Slap Bass 1',
-37:'Slap Bass 2',
-38:'Synth Bass 1',
-39:'Synth Bass 2',
-40:'Violin',
-41:'Viola',
-42:'Cello',
-43:'Contrabass',
-44:'Tremolo Strings',
-45:'Pizzicato Strings',
-46:'Orchestral Harp',
-47:'Timpani',
-48:'String Ensemble 1',
-49:'String Ensemble 2',
-50:'SynthStrings 1',
-51:'SynthStrings 2',
-52:'Choir Aahs',
-53:'Voice Oohs',
-54:'Synth Voice',
-55:'Orchestra Hit',
-56:'Trumpet',
-57:'Trombone',
-58:'Tuba',
-59:'Muted Trumpet',
-60:'French Horn',
-61:'Brass Section',
-62:'SynthBrass 1',
-63:'SynthBrass 2',
-64:'Soprano Sax',
-65:'Alto Sax',
-66:'Tenor Sax',
-67:'Baritone Sax',
-68:'Oboe',
-69:'English Horn',
-70:'Bassoon',
-71:'Clarinet',
-72:'Piccolo',
-73:'Flute',
-74:'Recorder',
-75:'Pan Flute',
-76:'Blown Bottle',
-77:'Skakuhachi',
-78:'Whistle',
-79:'Ocarina',
-80:'Lead 1 (square)',
-81:'Lead 2 (sawtooth)',
-82:'Lead 3 (calliope)',
-83:'Lead 4 (chiff)',
-84:'Lead 5 (charang)',
-85:'Lead 6 (voice)',
-86:'Lead 7 (fifths)',
-87:'Lead 8 (bass+lead)',
-88:'Pad 1 (new age)',
-89:'Pad 2 (warm)',
-90:'Pad 3 (polysynth)',
-91:'Pad 4 (choir)',
-92:'Pad 5 (bowed)',
-93:'Pad 6 (metallic)',
-94:'Pad 7 (halo)',
-95:'Pad 8 (sweep)',
-96:'FX 1 (rain)',
-97:'FX 2 (soundtrack)',
-98:'FX 3 (crystal)',
-99:'FX 4 (atmosphere)',
-100:'FX 5 (brightness)',
-101:'FX 6 (goblins)',
-102:'FX 7 (echoes)',
-103:'FX 8 (sci-fi)',
-104:'Sitar',
-105:'Banjo',
-106:'Shamisen',
-107:'Koto',
-108:'Kalimba',
-109:'Bagpipe',
-110:'Fiddle',
-111:'Shanai',
-112:'Tinkle Bell',
-113:'Agogo',
-114:'Steel Drums',
-115:'Woodblock',
-116:'Taiko Drum',
-117:'Melodic Tom',
-118:'Synth Drum',
-119:'Reverse Cymbal',
-120:'Guitar Fret Noise',
-121:'Breath Noise',
-122:'Seashore',
-123:'Bird Tweet',
-124:'Telephone Ring',
-125:'Helicopter',
-126:'Applause',
-127:'Gunshot',
-}
-Notenum2percussion = {   # General MIDI Percussion (on Channel 9):
-35:'Acoustic Bass Drum',
-36:'Bass Drum 1',
-37:'Side Stick',
-38:'Acoustic Snare',
-39:'Hand Clap',
-40:'Electric Snare',
-41:'Low Floor Tom',
-42:'Closed Hi-Hat',
-43:'High Floor Tom',
-44:'Pedal Hi-Hat',
-45:'Low Tom',
-46:'Open Hi-Hat',
-47:'Low-Mid Tom',
-48:'Hi-Mid Tom',
-49:'Crash Cymbal 1',
-50:'High Tom',
-51:'Ride Cymbal 1',
-52:'Chinese Cymbal',
-53:'Ride Bell',
-54:'Tambourine',
-55:'Splash Cymbal',
-56:'Cowbell',
-57:'Crash Cymbal 2',
-58:'Vibraslap',
-59:'Ride Cymbal 2',
-60:'Hi Bongo',
-61:'Low Bongo',
-62:'Mute Hi Conga',
-63:'Open Hi Conga',
-64:'Low Conga',
-65:'High Timbale',
-66:'Low Timbale',
-67:'High Agogo',
-68:'Low Agogo',
-69:'Cabasa',
-70:'Maracas',
-71:'Short Whistle',
-72:'Long Whistle',
-73:'Short Guiro',
-74:'Long Guiro',
-75:'Claves',
-76:'Hi Wood Block',
-77:'Low Wood Block',
-78:'Mute Cuica',
-79:'Open Cuica',
-80:'Mute Triangle',
-81:'Open Triangle',
-}
-
-Event2channelindex = { 'note':3, 'note_off':2, 'note_on':2,
- 'key_after_touch':2, 'control_change':2, 'patch_change':2,
- 'channel_after_touch':2, 'pitch_wheel_change':2
-}
-
-################################################################
-# The code below this line is full of frightening things, all to
-# do with the actual encoding and decoding of binary MIDI data.
-
-def _twobytes2int(byte_a):
-    r'''decode a 16 bit quantity from two bytes,'''
-    return (byte_a[1] | (byte_a[0] << 8))
-
-def _int2twobytes(int_16bit):
-    r'''encode a 16 bit quantity into two bytes,'''
-    return bytes([(int_16bit>>8) & 0xFF, int_16bit & 0xFF])
-
-def _read_14_bit(byte_a):
-    r'''decode a 14 bit quantity from two bytes,'''
-    return (byte_a[0] | (byte_a[1] << 7))
-
-def _write_14_bit(int_14bit):
-    r'''encode a 14 bit quantity into two bytes,'''
-    return bytes([int_14bit & 0x7F, (int_14bit>>7) & 0x7F])
-
-def _ber_compressed_int(integer):
-    r'''BER compressed integer (not an ASN.1 BER, see perlpacktut for
-details).  Its bytes represent an unsigned integer in base 128,
-most significant digit first, with as few digits as possible.
-Bit eight (the high bit) is set on each byte except the last.
-'''
-    ber = bytearray(b'')
-    seven_bits = 0x7F & integer
-    ber.insert(0, seven_bits)  # XXX surely should convert to a char ?
-    integer >>= 7
-    while integer > 0:
-        seven_bits = 0x7F & integer
-        ber.insert(0, 0x80|seven_bits)  # XXX surely should convert to a char ?
-        integer >>= 7
-    return ber
-
-def _unshift_ber_int(ba):
-    r'''Given a bytearray, returns a tuple of (the ber-integer at the
-start, and the remainder of the bytearray).
-'''
-    if not len(ba):  # 6.7
-        _warn('_unshift_ber_int: no integer found')
-        return ((0, b""))
-    byte = ba[0]
-    ba = ba[1:]
-    integer = 0
-    while True:
-        integer += (byte & 0x7F)
-        if not (byte & 0x80):
-            return ((integer, ba))
-        if not len(ba):
-            _warn('_unshift_ber_int: no end-of-integer found')
-            return ((0, ba))
-        byte = ba[0]
-        ba = ba[1:]
-        integer <<= 7
-
-
-def _clean_up_warnings():  # 5.4
-    # Call this before returning from any publicly callable function
-    # whenever there's a possibility that a warning might have been printed
-    # by the function, or by any private functions it might have called.
-    if _no_warning:
-        return
-    global _previous_times
-    global _previous_warning
-    if _previous_times > 1:
-        # E:1176, 0: invalid syntax (<string>, line 1176) (syntax-error) ???
-        # print('  previous message repeated '+str(_previous_times)+' times', file=sys.stderr)
-        # 6.7
-        sys.stderr.write('  previous message repeated {0} times\n'.format(_previous_times))
-    elif _previous_times > 0:
-        sys.stderr.write('  previous message repeated\n')
-    _previous_times = 0
-    _previous_warning = ''
-
-
-def _warn(s=''):
-    if _no_warning:
-        return
-    global _previous_times
-    global _previous_warning
-    if s == _previous_warning:  # 5.4
-        _previous_times = _previous_times + 1
-    else:
-        _clean_up_warnings()
-        sys.stderr.write(str(s) + "\n")
-        _previous_warning = s
-
-
-def _some_text_event(which_kind=0x01, text=b'some_text', text_encoding='ISO-8859-1'):
-    if str(type(text)).find("'str'") >= 0:  # 6.4 test for back-compatibility
-        data = bytes(text, encoding=text_encoding)
-    else:
-        data = bytes(text)
-    return b'\xFF' + bytes((which_kind,)) + _ber_compressed_int(len(data)) + data
-
-
-def _consistentise_ticks(scores):  # 3.6
-    # used by mix_scores, merge_scores, concatenate_scores
-    if len(scores) == 1:
-        return copy.deepcopy(scores)
-    are_consistent = True
-    ticks = scores[0][0]
-    iscore = 1
-    while iscore < len(scores):
-        if scores[iscore][0] != ticks:
-            are_consistent = False
-            break
-        iscore += 1
-    if are_consistent:
-        return copy.deepcopy(scores)
-    new_scores = []
-    iscore = 0
-    while iscore < len(scores):
-        score = scores[iscore]
-        new_scores.append(opus2score(to_millisecs(score2opus(score))))
-        iscore += 1
-    return new_scores
-
-
-###########################################################################
-def _decode(trackdata=b'', exclude=None, include=None,
-            event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
-    r'''Decodes MIDI track data into an opus-style list of events.
-The options:
-  'exclude' is a list of event types which will be ignored SHOULD BE A SET
-  'include' (and no exclude), makes exclude a list
-       of all possible events, /minus/ what include specifies
-  'event_callback' is a coderef
-  'exclusive_event_callback' is a coderef
-'''
-    trackdata = bytearray(trackdata)
-    if exclude == None:
-        exclude = []
-    if include == None:
-        include = []
-    if include and not exclude:
-        exclude = All_events
-    include = set(include)
-    exclude = set(exclude)
-
-    # Pointer = 0;  not used here; we eat through the bytearray instead.
-    event_code = -1;  # used for running status
-    event_count = 0;
-    events = []
-
-    while (len(trackdata)):
-        # loop while there's anything to analyze ...
-        eot = False  # When True, the event registrar aborts this loop
-        event_count += 1
-
-        E = []
-        # E for events - we'll feed it to the event registrar at the end.
-
-        # Slice off the delta time code, and analyze it
-        [time, trackdata] = _unshift_ber_int(trackdata)
-
-        # Now let's see what we can make of the command
-        first_byte = trackdata[0] & 0xFF
-        trackdata = trackdata[1:]
-        if (first_byte < 0xF0):  # It's a MIDI event
-            if (first_byte & 0x80):
-                event_code = first_byte
-            else:
-                # It wants running status; use last event_code value
-                trackdata.insert(0, first_byte)
-                if (event_code == -1):
-                    _warn("Running status not set; Aborting track.")
-                    return []
-
-            command = event_code & 0xF0
-            channel = event_code & 0x0F
-
-            if (command == 0xF6):  # 0-byte argument
-                pass
-            elif (command == 0xC0 or command == 0xD0):  # 1-byte argument
-                parameter = trackdata[0]  # could be B
-                trackdata = trackdata[1:]
-            else:  # 2-byte argument could be BB or 14-bit
-                parameter = (trackdata[0], trackdata[1])
-                trackdata = trackdata[2:]
-
-            #################################################################
-            # MIDI events
-
-            if (command == 0x80):
-                if 'note_off' in exclude:
-                    continue
-                E = ['note_off', time, channel, parameter[0], parameter[1]]
-            elif (command == 0x90):
-                if 'note_on' in exclude:
-                    continue
-                E = ['note_on', time, channel, parameter[0], parameter[1]]
-            elif (command == 0xA0):
-                if 'key_after_touch' in exclude:
-                    continue
-                E = ['key_after_touch', time, channel, parameter[0], parameter[1]]
-            elif (command == 0xB0):
-                if 'control_change' in exclude:
-                    continue
-                E = ['control_change', time, channel, parameter[0], parameter[1]]
-            elif (command == 0xC0):
-                if 'patch_change' in exclude:
-                    continue
-                E = ['patch_change', time, channel, parameter]
-            elif (command == 0xD0):
-                if 'channel_after_touch' in exclude:
-                    continue
-                E = ['channel_after_touch', time, channel, parameter]
-            elif (command == 0xE0):
-                if 'pitch_wheel_change' in exclude:
-                    continue
-                E = ['pitch_wheel_change', time, channel,
-                     _read_14_bit(parameter) - 0x2000]
-            else:
-                _warn("Shouldn't get here; command=" + hex(command))
-
-        elif (first_byte == 0xFF):  # It's a Meta-Event! ##################
-            # [command, length, remainder] =
-            #    unpack("xCwa*", substr(trackdata, $Pointer, 6));
-            # Pointer += 6 - len(remainder);
-            #    # Move past JUST the length-encoded.
-            command = trackdata[0] & 0xFF
-            trackdata = trackdata[1:]
-            [length, trackdata] = _unshift_ber_int(trackdata)
-            if (command == 0x00):
-                if (length == 2):
-                    E = ['set_sequence_number', time, _twobytes2int(trackdata)]
-                else:
-                    _warn('set_sequence_number: length must be 2, not ' + str(length))
-                    E = ['set_sequence_number', time, 0]
-
-            elif command >= 0x01 and command <= 0x0f:  # Text events
-                # 6.2 take it in bytes; let the user get the right encoding.
-                # text_str = trackdata[0:length].decode('ascii','ignore')
-                # text_str = trackdata[0:length].decode('ISO-8859-1')
-                # 6.4 take it in bytes; let the user get the right encoding.
-                text_data = bytes(trackdata[0:length])  # 6.4
-                # Defined text events
-                if (command == 0x01):
-                    E = ['text_event', time, text_data]
-                elif (command == 0x02):
-                    E = ['copyright_text_event', time, text_data]
-                elif (command == 0x03):
-                    E = ['track_name', time, text_data]
-                elif (command == 0x04):
-                    E = ['instrument_name', time, text_data]
-                elif (command == 0x05):
-                    E = ['lyric', time, text_data]
-                elif (command == 0x06):
-                    E = ['marker', time, text_data]
-                elif (command == 0x07):
-                    E = ['cue_point', time, text_data]
-                # Reserved but apparently unassigned text events
-                elif (command == 0x08):
-                    E = ['text_event_08', time, text_data]
-                elif (command == 0x09):
-                    E = ['text_event_09', time, text_data]
-                elif (command == 0x0a):
-                    E = ['text_event_0a', time, text_data]
-                elif (command == 0x0b):
-                    E = ['text_event_0b', time, text_data]
-                elif (command == 0x0c):
-                    E = ['text_event_0c', time, text_data]
-                elif (command == 0x0d):
-                    E = ['text_event_0d', time, text_data]
-                elif (command == 0x0e):
-                    E = ['text_event_0e', time, text_data]
-                elif (command == 0x0f):
-                    E = ['text_event_0f', time, text_data]
-
-            # Now the sticky events -------------------------------------
-            elif (command == 0x2F):
-                E = ['end_track', time]
-                # The code for handling this, oddly, comes LATER,
-                # in the event registrar.
-            elif (command == 0x51):  # DTime, Microseconds/Crochet
-                if length != 3:
-                    _warn('set_tempo event, but length=' + str(length))
-                E = ['set_tempo', time,
-                     struct.unpack(">I", b'\x00' + trackdata[0:3])[0]]
-            elif (command == 0x54):
-                if length != 5:  # DTime, HR, MN, SE, FR, FF
-                    _warn('smpte_offset event, but length=' + str(length))
-                E = ['smpte_offset', time] + list(struct.unpack(">BBBBB", trackdata[0:5]))
-            elif (command == 0x58):
-                if length != 4:  # DTime, NN, DD, CC, BB
-                    _warn('time_signature event, but length=' + str(length))
-                E = ['time_signature', time] + list(trackdata[0:4])
-            elif (command == 0x59):
-                if length != 2:  # DTime, SF(signed), MI
-                    _warn('key_signature event, but length=' + str(length))
-                E = ['key_signature', time] + list(struct.unpack(">bB", trackdata[0:2]))
-            elif (command == 0x7F):  # 6.4
-                E = ['sequencer_specific', time, bytes(trackdata[0:length])]
-            else:
-                E = ['raw_meta_event', time, command,
-                     bytes(trackdata[0:length])]  # 6.0
-                # "[uninterpretable meta-event command of length length]"
-                # DTime, Command, Binary Data
-                # It's uninterpretable; record it as raw_data.
-
-            # Pointer += length; #  Now move Pointer
-            trackdata = trackdata[length:]
-
-        ######################################################################
-        elif (first_byte == 0xF0 or first_byte == 0xF7):
-            # Note that sysexes in MIDI /files/ are different than sysexes
-            # in MIDI transmissions!! The vast majority of system exclusive
-            # messages will just use the F0 format. For instance, the
-            # transmitted message F0 43 12 00 07 F7 would be stored in a
-            # MIDI file as F0 05 43 12 00 07 F7. As mentioned above, it is
-            # required to include the F7 at the end so that the reader of the
-            # MIDI file knows that it has read the entire message. (But the F7
-            # is omitted if this is a non-final block in a multiblock sysex;
-            # but the F7 (if there) is counted in the message's declared
-            # length, so we don't have to think about it anyway.)
-            # command = trackdata.pop(0)
-            [length, trackdata] = _unshift_ber_int(trackdata)
-            if first_byte == 0xF0:
-                # 20091008 added ISO-8859-1 to get an 8-bit str
-                # 6.4 return bytes instead
-                E = ['sysex_f0', time, bytes(trackdata[0:length])]
-            else:
-                E = ['sysex_f7', time, bytes(trackdata[0:length])]
-            trackdata = trackdata[length:]
-
-        ######################################################################
-        # Now, the MIDI file spec says:
-        #  <track data> = <MTrk event>+
-        #  <MTrk event> = <delta-time> <event>
-        #  <event> = <MIDI event> | <sysex event> | <meta-event>
-        # I know that, on the wire, <MIDI event> can include note_on,
-        # note_off, and all the other 8x to Ex events, AND Fx events
-        # other than F0, F7, and FF -- namely, <song position msg>,
-        # <song select msg>, and <tune request>.
-        #
-        # Whether these can occur in MIDI files is not clear specified
-        # from the MIDI file spec.  So, I'm going to assume that
-        # they CAN, in practice, occur.  I don't know whether it's
-        # proper for you to actually emit these into a MIDI file.
-
-        elif (first_byte == 0xF2):  # DTime, Beats
-            #  <song position msg> ::=     F2 <data pair>
-            E = ['song_position', time, _read_14_bit(trackdata[:2])]
-            trackdata = trackdata[2:]
-
-        elif (first_byte == 0xF3):  # <song select msg> ::= F3 <data singlet>
-            # E = ['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]]
-            E = ['song_select', time, trackdata[0]]
-            trackdata = trackdata[1:]
-            # DTime, Thing (what?! song number?  whatever ...)
-
-        elif (first_byte == 0xF6):  # DTime
-            E = ['tune_request', time]
-            # What would a tune request be doing in a MIDI /file/?
-
-            #########################################################
-            # ADD MORE META-EVENTS HERE.  TODO:
-            # f1 -- MTC Quarter Frame Message. One data byte follows
-            #     the Status; it's the time code value, from 0 to 127.
-            # f8 -- MIDI clock.    no data.
-            # fa -- MIDI start.    no data.
-            # fb -- MIDI continue. no data.
-            # fc -- MIDI stop.     no data.
-            # fe -- Active sense.  no data.
-            # f4 f5 f9 fd -- unallocated
-
-            r'''
-        elif (first_byte > 0xF0) { # Some unknown kinda F-series event ####
-            # Here we only produce a one-byte piece of raw data.
-            # But the encoder for 'raw_data' accepts any length of it.
-            E = [ 'raw_data',
-                         time, substr(trackdata,Pointer,1) ]
-            # DTime and the Data (in this case, the one Event-byte)
-            ++Pointer;  # itself
-
-'''
-        elif first_byte > 0xF0:  # Some unknown F-series event
-            # Here we only produce a one-byte piece of raw data.
-            # E = ['raw_data', time, bytest(trackdata[0])]   # 6.4
-            E = ['raw_data', time, trackdata[0]]  # 6.4 6.7
-            trackdata = trackdata[1:]
-        else:  # Fallthru.
-            _warn("Aborting track.  Command-byte first_byte=" + hex(first_byte))
-            break
-        # End of the big if-group
-
-        ######################################################################
-        #  THE EVENT REGISTRAR...
-        if E and (E[0] == 'end_track'):
-            # This is the code for exceptional handling of the EOT event.
-            eot = True
-            if not no_eot_magic:
-                if E[1] > 0:  # a null text-event to carry the delta-time
-                    E = ['text_event', E[1], '']
-                else:
-                    E = []  # EOT with a delta-time of 0; ignore it.
-
-        if E and not (E[0] in exclude):
-            # if ( $exclusive_event_callback ):
-            #    &{ $exclusive_event_callback }( @E );
-            # else:
-            #    &{ $event_callback }( @E ) if $event_callback;
-            events.append(E)
-        if eot:
-            break
-
-    # End of the big "Event" while-block
-
-    return events
-
-
-###########################################################################
-def _encode(events_lol, unknown_callback=None, never_add_eot=False,
-  no_eot_magic=False, no_running_status=False, text_encoding='ISO-8859-1'):
-    # encode an event structure, presumably for writing to a file
-    # Calling format:
-    #   $data_r = MIDI::Event::encode( \@event_lol, { options } );
-    # Takes a REFERENCE to an event structure (a LoL)
-    # Returns an (unblessed) REFERENCE to track data.
-
-    # If you want to use this to encode a /single/ event,
-    # you still have to do it as a reference to an event structure (a LoL)
-    # that just happens to have just one event.  I.e.,
-    #   encode( [ $event ] ) or encode( [ [ 'note_on', 100, 5, 42, 64] ] )
-    # If you're doing this, consider the never_add_eot track option, as in
-    #   print MIDI ${ encode( [ $event], { 'never_add_eot' => 1} ) };
-
-    data = [] # what I'll store the chunks of byte-data in
-
-    # This is so my end_track magic won't corrupt the original
-    events = copy.deepcopy(events_lol)
-
-    if not never_add_eot:
-        # One way or another, tack on an 'end_track'
-        if events:
-            last = events[-1]
-            if not (last[0] == 'end_track'):  # no end_track already
-                if (last[0] == 'text_event' and len(last[2]) == 0):
-                    # 0-length text event at track-end.
-                    if no_eot_magic:
-                        # Exceptional case: don't mess with track-final
-                        # 0-length text_events; just peg on an end_track
-                        events.append(['end_track', 0])
-                    else:
-                        # NORMAL CASE: replace with an end_track, leaving DTime
-                        last[0] = 'end_track'
-                else:
-                    # last event was neither 0-length text_event nor end_track
-                    events.append(['end_track', 0])
-        else:  # an eventless track!
-            events = [['end_track', 0],]
-
-    # maybe_running_status = not no_running_status # unused? 4.7
-    last_status = -1
-
-    for event_r in (events):
-        E = copy.deepcopy(event_r)
-        # otherwise the shifting'd corrupt the original
-        if not E:
-            continue
-
-        event = E.pop(0)
-        if not len(event):
-            continue
-
-        dtime = int(E.pop(0))
-        # print('event='+str(event)+' dtime='+str(dtime))
-
-        event_data = ''
-
-        if (   # MIDI events -- eligible for running status
-             event    == 'note_on'
-             or event == 'note_off'
-             or event == 'control_change'
-             or event == 'key_after_touch'
-             or event == 'patch_change'
-             or event == 'channel_after_touch'
-             or event == 'pitch_wheel_change'  ):
-
-            # This block is where we spend most of the time.  Gotta be tight.
-            if (event == 'note_off'):
-                status = 0x80 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
-            elif (event == 'note_on'):
-                status = 0x90 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
-            elif (event == 'key_after_touch'):
-                status = 0xA0 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>BB', int(E[1])&0x7F, int(E[2])&0x7F)
-            elif (event == 'control_change'):
-                status = 0xB0 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>BB', int(E[1])&0xFF, int(E[2])&0xFF)
-            elif (event == 'patch_change'):
-                status = 0xC0 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>B', int(E[1]) & 0xFF)
-            elif (event == 'channel_after_touch'):
-                status = 0xD0 | (int(E[0]) & 0x0F)
-                parameters = struct.pack('>B', int(E[1]) & 0xFF)
-            elif (event == 'pitch_wheel_change'):
-                status = 0xE0 | (int(E[0]) & 0x0F)
-                parameters =  _write_14_bit(int(E[1]) + 0x2000)
-            else:
-                _warn("BADASS FREAKOUT ERROR 31415!")
-
-            # And now the encoding
-            # w = BER compressed integer (not ASN.1 BER, see perlpacktut for
-            # details).  Its bytes represent an unsigned integer in base 128,
-            # most significant digit first, with as few digits as possible.
-            # Bit eight (the high bit) is set on each byte except the last.
-
-            data.append(_ber_compressed_int(dtime))
-            if (status != last_status) or no_running_status:
-                data.append(struct.pack('>B', status))
-            data.append(parameters)
- 
-            last_status = status
-            continue
-        else:
-            # Not a MIDI event.
-            # All the code in this block could be more efficient,
-            # but this is not where the code needs to be tight.
-            # print "zaz $event\n";
-            last_status = -1
-
-            if event == 'raw_meta_event':
-                event_data = _some_text_event(int(E[0]), E[1], text_encoding)
-            elif (event == 'set_sequence_number'):  # 3.9
-                event_data = b'\xFF\x00\x02'+_int2twobytes(E[0])
-
-            # Text meta-events...
-            # a case for a dict, I think (pjb) ...
-            elif (event == 'text_event'):
-                event_data = _some_text_event(0x01, E[0], text_encoding)
-            elif (event == 'copyright_text_event'):
-                event_data = _some_text_event(0x02, E[0], text_encoding)
-            elif (event == 'track_name'):
-                event_data = _some_text_event(0x03, E[0], text_encoding)
-            elif (event == 'instrument_name'):
-                event_data = _some_text_event(0x04, E[0], text_encoding)
-            elif (event == 'lyric'):
-                event_data = _some_text_event(0x05, E[0], text_encoding)
-            elif (event == 'marker'):
-                event_data = _some_text_event(0x06, E[0], text_encoding)
-            elif (event == 'cue_point'):
-                event_data = _some_text_event(0x07, E[0], text_encoding)
-            elif (event == 'text_event_08'):
-                event_data = _some_text_event(0x08, E[0], text_encoding)
-            elif (event == 'text_event_09'):
-                event_data = _some_text_event(0x09, E[0], text_encoding)
-            elif (event == 'text_event_0a'):
-                event_data = _some_text_event(0x0A, E[0], text_encoding)
-            elif (event == 'text_event_0b'):
-                event_data = _some_text_event(0x0B, E[0], text_encoding)
-            elif (event == 'text_event_0c'):
-                event_data = _some_text_event(0x0C, E[0], text_encoding)
-            elif (event == 'text_event_0d'):
-                event_data = _some_text_event(0x0D, E[0], text_encoding)
-            elif (event == 'text_event_0e'):
-                event_data = _some_text_event(0x0E, E[0], text_encoding)
-            elif (event == 'text_event_0f'):
-                event_data = _some_text_event(0x0F, E[0], text_encoding)
-            # End of text meta-events
-
-            elif (event == 'end_track'):
-                event_data = b"\xFF\x2F\x00"
-
-            elif (event == 'set_tempo'):
-                #event_data = struct.pack(">BBwa*", 0xFF, 0x51, 3,
-                #              substr( struct.pack('>I', E[0]), 1, 3))
-                event_data = b'\xFF\x51\x03'+struct.pack('>I',E[0])[1:]
-            elif (event == 'smpte_offset'):
-                # event_data = struct.pack(">BBwBBBBB", 0xFF, 0x54, 5, E[0:5] )
-                event_data = struct.pack(">BBBbBBBB", 0xFF,0x54,0x05,E[0],E[1],E[2],E[3],E[4])
-            elif (event == 'time_signature'):
-                # event_data = struct.pack(">BBwBBBB",  0xFF, 0x58, 4, E[0:4] )
-                event_data = struct.pack(">BBBbBBB", 0xFF, 0x58, 0x04, E[0],E[1],E[2],E[3])
-            elif (event == 'key_signature'):
-                event_data = struct.pack(">BBBbB", 0xFF, 0x59, 0x02, E[0],E[1])
-            elif (event == 'sequencer_specific'):
-                # event_data = struct.pack(">BBwa*", 0xFF,0x7F, len(E[0]), E[0])
-                event_data = _some_text_event(0x7F, E[0], text_encoding)
-            # End of Meta-events
-
-            # Other Things...
-            elif (event == 'sysex_f0'):
-                 #event_data = struct.pack(">Bwa*", 0xF0, len(E[0]), E[0])
-                 #B=bitstring w=BER-compressed-integer a=null-padded-ascii-str
-                 event_data = bytearray(b'\xF0')+_ber_compressed_int(len(E[0]))+bytearray(E[0])
-            elif (event == 'sysex_f7'):
-                 #event_data = struct.pack(">Bwa*", 0xF7, len(E[0]), E[0])
-                 event_data = bytearray(b'\xF7')+_ber_compressed_int(len(E[0]))+bytearray(E[0])
-
-            elif (event == 'song_position'):
-                 event_data = b"\xF2" + _write_14_bit( E[0] )
-            elif (event == 'song_select'):
-                 event_data = struct.pack('>BB', 0xF3, E[0] )
-            elif (event == 'tune_request'):
-                 event_data = b"\xF6"
-            elif (event == 'raw_data'):
-                _warn("_encode: raw_data event not supported")
-                # event_data = E[0]
-                continue
-            # End of Other Stuff
-
-            else:
-                # The Big Fallthru
-                if unknown_callback:
-                    # push(@data, &{ $unknown_callback }( @$event_r ))
-                    pass
-                else:
-                    _warn("Unknown event: "+str(event))
-                    # To surpress complaint here, just set
-                    #  'unknown_callback' => sub { return () }
-                continue
-
-            #print "Event $event encoded part 2\n"
-            if str(type(event_data)).find("'str'") >= 0:
-                event_data = bytearray(event_data.encode('Latin1', 'ignore'))
-            if len(event_data): # how could $event_data be empty
-                # data.append(struct.pack('>wa*', dtime, event_data))
-                # print(' event_data='+str(event_data))
-                data.append(_ber_compressed_int(dtime)+event_data)
-
-    return b''.join(data)
-
-###################################################################################
-###################################################################################
-###################################################################################
-#
-#	Tegridy MIDI X Module (TMIDI X / tee-midi eks)
-#
-#	Based upon and includes the amazing MIDI.py module v.6.7. by Peter Billam
-#	pjb.com.au
-#
-#	Project Los Angeles
-#	Tegridy Code 2025
-#
-#   https://github.com/Tegridy-Code/Project-Los-Angeles
-#
-###################################################################################
-###################################################################################
-###################################################################################
-
 import os
-
-import datetime
-
-from datetime import datetime
-
-import secrets
-
-import random
-
-import pickle
-
-import csv
-
-import tqdm
-
-import multiprocessing
-
-from itertools import zip_longest
-from itertools import groupby
-
-from collections import Counter
-from collections import defaultdict
-from collections import OrderedDict
-
-from operator import itemgetter
-
-from abc import ABC, abstractmethod
-
-from difflib import SequenceMatcher as SM
-
-import statistics
+import re
+import json
 import math
-
-import matplotlib.pyplot as plt
-
+import tqdm
+import copy
 import psutil
-
-import json
-
-from pathlib import Path
-
 import shutil
-
+import random
 import hashlib
+import secrets
+import statistics
+import multiprocessing
+from src import MIDI
 
 from array import array
-
 from pathlib import Path
 from fnmatch import fnmatch
-
-###################################################################################
-#
-# Original TMIDI Tegridy helper functions
-#
-###################################################################################
-
-def Tegridy_TXT_to_INT_Converter(input_TXT_string, line_by_line_INT_string=True, max_INT = 0):
-
-    '''Tegridy TXT to Intergers Converter
-     
-    Input: Input TXT string in the TMIDI-TXT format
-
-           Type of output TXT INT string: line-by-line or one long string
-
-           Maximum absolute integer to process. Maximum is inclusive 
-           Default = process all integers. This helps to remove outliers/unwanted ints
-
-    Output: List of pure intergers
-            String of intergers in the specified format: line-by-line or one long string
-            Number of processed integers
-            Number of skipped integers
-    
-    Project Los Angeles
-    Tegridy Code 2021'''
-
-    print('Tegridy TXT to Intergers Converter')
-
-    output_INT_list = []
-
-    npi = 0
-    nsi = 0
-
-    TXT_List = list(input_TXT_string)
-    for char in TXT_List:
-      if max_INT != 0:
-        if abs(ord(char)) <= max_INT:
-          output_INT_list.append(ord(char))
-          npi += 1
-        else:
-          nsi += 1  
-      else:
-        output_INT_list.append(ord(char))
-        npi += 1    
-    
-    if line_by_line_INT_string:
-      output_INT_string = '\n'.join([str(elem) for elem in output_INT_list])
-    else:
-      output_INT_string = ' '.join([str(elem) for elem in output_INT_list])  
-
-    print('Converted TXT to INTs:', npi, ' / ', nsi)
-
-    return output_INT_list, output_INT_string, npi, nsi
-
-###################################################################################
-
-def Tegridy_INT_to_TXT_Converter(input_INT_list):
-
-    '''Tegridy Intergers to TXT Converter
-     
-    Input: List of intergers in TMIDI-TXT-INT format
-    Output: Decoded TXT string in TMIDI-TXT format
-    Project Los Angeles
-    Tegridy Code 2020'''
-
-    output_TXT_string = ''
-
-    for i in input_INT_list:
-      output_TXT_string += chr(int(i))
-    
-    return output_TXT_string
-
-###################################################################################
-
-def Tegridy_INT_String_to_TXT_Converter(input_INT_String, line_by_line_input=True):
-
-    '''Tegridy Intergers String to TXT Converter
-     
-    Input: List of intergers in TMIDI-TXT-INT-String format
-    Output: Decoded TXT string in TMIDI-TXT format
-    Project Los Angeles
-    Tegridy Code 2020'''
-    
-    print('Tegridy Intergers String to TXT Converter')
-
-    if line_by_line_input:
-      input_string = input_INT_String.split('\n')
-    else:
-      input_string = input_INT_String.split(' ')  
-
-    output_TXT_string = ''
-
-    for i in input_string:
-      try:
-        output_TXT_string += chr(abs(int(i)))
-      except:
-        print('Bad note:', i)
-        continue  
-    
-    print('Done!')
-
-    return output_TXT_string
-
-###################################################################################
-
-def Tegridy_SONG_to_MIDI_Converter(SONG,
-                                  output_signature = 'Tegridy TMIDI Module', 
-                                  track_name = 'Composition Track',
-                                  number_of_ticks_per_quarter = 425,
-                                  list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0],
-                                  output_file_name = 'TMIDI-Composition',
-                                  text_encoding='ISO-8859-1',
-                                  verbose=True):
-
-    '''Tegridy SONG to MIDI Converter
-     
-    Input: Input SONG in TMIDI SONG/MIDI.py Score format
-           Output MIDI Track 0 name / MIDI Signature
-           Output MIDI Track 1 name / Composition track name
-           Number of ticks per quarter for the output MIDI
-           List of 16 MIDI patch numbers for output MIDI. Def. is MuseNet compatible patches.
-           Output file name w/o .mid extension.
-           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
-
-    Output: MIDI File
-            Detailed MIDI stats
-
-    Project Los Angeles
-    Tegridy Code 2020'''                                  
-    
-    if verbose:
-        print('Converting to MIDI. Please stand-by...')
-    
-    output_header = [number_of_ticks_per_quarter, 
-                    [['track_name', 0, bytes(output_signature, text_encoding)]]]                                                    
-
-    patch_list = [['patch_change', 0, 0, list_of_MIDI_patches[0]], 
-                    ['patch_change', 0, 1, list_of_MIDI_patches[1]],
-                    ['patch_change', 0, 2, list_of_MIDI_patches[2]],
-                    ['patch_change', 0, 3, list_of_MIDI_patches[3]],
-                    ['patch_change', 0, 4, list_of_MIDI_patches[4]],
-                    ['patch_change', 0, 5, list_of_MIDI_patches[5]],
-                    ['patch_change', 0, 6, list_of_MIDI_patches[6]],
-                    ['patch_change', 0, 7, list_of_MIDI_patches[7]],
-                    ['patch_change', 0, 8, list_of_MIDI_patches[8]],
-                    ['patch_change', 0, 9, list_of_MIDI_patches[9]],
-                    ['patch_change', 0, 10, list_of_MIDI_patches[10]],
-                    ['patch_change', 0, 11, list_of_MIDI_patches[11]],
-                    ['patch_change', 0, 12, list_of_MIDI_patches[12]],
-                    ['patch_change', 0, 13, list_of_MIDI_patches[13]],
-                    ['patch_change', 0, 14, list_of_MIDI_patches[14]],
-                    ['patch_change', 0, 15, list_of_MIDI_patches[15]],
-                    ['track_name', 0, bytes(track_name, text_encoding)]]
-
-    output = output_header + [patch_list + SONG]
-
-    midi_data = score2midi(output, text_encoding)
-    detailed_MIDI_stats = score2stats(output)
-
-    with open(output_file_name + '.mid', 'wb') as midi_file:
-        midi_file.write(midi_data)
-        midi_file.close()
-    
-    if verbose:    
-        print('Done! Enjoy! :)')
-    
-    return detailed_MIDI_stats
-
-###################################################################################
-
-def Tegridy_ms_SONG_to_MIDI_Converter(ms_SONG,
-                                      output_signature = 'Tegridy TMIDI Module', 
-                                      track_name = 'Composition Track',
-                                      list_of_MIDI_patches = [0, 24, 32, 40, 42, 46, 56, 71, 73, 0, 0, 0, 0, 0, 0, 0],
-                                      output_file_name = 'TMIDI-Composition',
-                                      text_encoding='ISO-8859-1',
-                                      timings_multiplier=1,
-                                      verbose=True
-                                      ):
-
-    '''Tegridy milisecond SONG to MIDI Converter
-     
-    Input: Input ms SONG in TMIDI ms SONG/MIDI.py ms Score format
-           Output MIDI Track 0 name / MIDI Signature
-           Output MIDI Track 1 name / Composition track name
-           List of 16 MIDI patch numbers for output MIDI. Def. is MuseNet compatible patches.
-           Output file name w/o .mid extension.
-           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
-           Optional timings multiplier
-           Optional verbose output
-
-    Output: MIDI File
-            Detailed MIDI stats
-
-    Project Los Angeles
-    Tegridy Code 2024'''                                  
-    
-    if verbose:
-        print('Converting to MIDI. Please stand-by...')
-
-    output_header = [1000,
-                    [['set_tempo', 0, 1000000],
-                     ['time_signature', 0, 4, 2, 24, 8],
-                     ['track_name', 0, bytes(output_signature, text_encoding)]]]
-
-    patch_list = [['patch_change', 0, 0, list_of_MIDI_patches[0]], 
-                    ['patch_change', 0, 1, list_of_MIDI_patches[1]],
-                    ['patch_change', 0, 2, list_of_MIDI_patches[2]],
-                    ['patch_change', 0, 3, list_of_MIDI_patches[3]],
-                    ['patch_change', 0, 4, list_of_MIDI_patches[4]],
-                    ['patch_change', 0, 5, list_of_MIDI_patches[5]],
-                    ['patch_change', 0, 6, list_of_MIDI_patches[6]],
-                    ['patch_change', 0, 7, list_of_MIDI_patches[7]],
-                    ['patch_change', 0, 8, list_of_MIDI_patches[8]],
-                    ['patch_change', 0, 9, list_of_MIDI_patches[9]],
-                    ['patch_change', 0, 10, list_of_MIDI_patches[10]],
-                    ['patch_change', 0, 11, list_of_MIDI_patches[11]],
-                    ['patch_change', 0, 12, list_of_MIDI_patches[12]],
-                    ['patch_change', 0, 13, list_of_MIDI_patches[13]],
-                    ['patch_change', 0, 14, list_of_MIDI_patches[14]],
-                    ['patch_change', 0, 15, list_of_MIDI_patches[15]],
-                    ['track_name', 0, bytes(track_name, text_encoding)]]
-
-    SONG = copy.deepcopy(ms_SONG)
-
-    if timings_multiplier != 1:
-      for S in SONG:
-        S[1] = S[1] * timings_multiplier
-        if S[0] == 'note':
-          S[2] = S[2] * timings_multiplier
-
-    output = output_header + [patch_list + SONG]
-
-    midi_data = score2midi(output, text_encoding)
-    detailed_MIDI_stats = score2stats(output)
-
-    with open(output_file_name + '.mid', 'wb') as midi_file:
-        midi_file.write(midi_data)
-        midi_file.close()
-    
-    if verbose:    
-        print('Done! Enjoy! :)')
-    
-    return detailed_MIDI_stats
-
-###################################################################################
-
-def hsv_to_rgb(h, s, v):
-    if s == 0.0:
-        return v, v, v
-    i = int(h*6.0)
-    f = (h*6.0) - i
-    p = v*(1.0 - s)
-    q = v*(1.0 - s*f)
-    t = v*(1.0 - s*(1.0-f))
-    i = i%6
-    return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
-
-def generate_colors(n):
-    return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
-
-def add_arrays(a, b):
-    return [sum(pair) for pair in zip(a, b)]
-
-#-------------------------------------------------------------------------------
-
-def plot_ms_SONG(ms_song,
-                  preview_length_in_notes=0,
-                  block_lines_times_list = None,
-                  plot_title='ms Song',
-                  max_num_colors=129, 
-                  drums_color_num=128, 
-                  plot_size=(11,4), 
-                  note_height = 0.75,
-                  show_grid_lines=False,
-                  return_plt = False,
-                  timings_multiplier=1,
-                  save_plt='',
-                  save_only_plt_image=True,
-                  save_transparent=False
-                  ):
-
-  '''Tegridy ms SONG plotter/vizualizer'''
-
-  notes = [s for s in ms_song if s[0] == 'note']
-
-  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
-    print('The song notes do not have patches information')
-    print('Ploease add patches to the notes in the song')
-
-  else:
-
-    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
-    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
-    pitches = [s[4] for s in notes]
-    patches = [s[6] for s in notes]
-
-    colors = generate_colors(max_num_colors)
-    colors[drums_color_num] = (1, 1, 1)
-
-    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
-
-    fig, ax = plt.subplots(figsize=plot_size)
-    #fig, ax = plt.subplots()
-
-    # Create a rectangle for each note with color based on patch number
-    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
-        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
-        ax.add_patch(rect)
-
-    # Set the limits of the plot
-    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
-    ax.set_ylim([min(pitches)-1, max(pitches)+1])
-
-    # Set the background color to black
-    ax.set_facecolor('black')
-    fig.patch.set_facecolor('white')
-
-    if preview_length_in_notes > 0:
-      ax.axvline(x=pbl, c='white')
-
-    if block_lines_times_list:
-      for bl in block_lines_times_list:
-        ax.axvline(x=bl, c='white')
-           
-    if show_grid_lines:
-      ax.grid(color='white')
-
-    plt.xlabel('Time (s)', c='black')
-    plt.ylabel('MIDI Pitch', c='black')
-
-    plt.title(plot_title)
-
-    if save_plt != '':
-      if save_only_plt_image:
-        plt.axis('off')
-        plt.title('')
-        plt.savefig(save_plt, transparent=save_transparent, bbox_inches='tight', pad_inches=0, facecolor='black')
-        plt.close()
-      
-      else:
-        plt.savefig(save_plt)
-        plt.close()
-
-    if return_plt:
-      plt.close(fig)
-      return fig
-
-    plt.show()
-    plt.close()
-
-###################################################################################
-
-def Tegridy_SONG_to_Full_MIDI_Converter(SONG,
-                                        output_signature = 'Tegridy TMIDI Module', 
-                                        track_name = 'Composition Track',
-                                        number_of_ticks_per_quarter = 1000,
-                                        output_file_name = 'TMIDI-Composition',
-                                        text_encoding='ISO-8859-1',
-                                        verbose=True):
-
-    '''Tegridy SONG to Full MIDI Converter
-     
-    Input: Input SONG in Full TMIDI SONG/MIDI.py Score format
-           Output MIDI Track 0 name / MIDI Signature
-           Output MIDI Track 1 name / Composition track name
-           Number of ticks per quarter for the output MIDI
-           Output file name w/o .mid extension.
-           Optional text encoding if you are working with text_events/lyrics. This is especially useful for Karaoke. Please note that anything but ISO-8859-1 is a non-standard way of encoding text_events according to MIDI specs.
-
-    Output: MIDI File
-            Detailed MIDI stats
-
-    Project Los Angeles
-    Tegridy Code 2023'''                                  
-    
-    if verbose:
-        print('Converting to MIDI. Please stand-by...')
-    
-    output_header = [number_of_ticks_per_quarter,
-                    [['set_tempo', 0, 1000000],
-                      ['track_name', 0, bytes(output_signature, text_encoding)]]]                                                    
-
-    song_track = [['track_name', 0, bytes(track_name, text_encoding)]]
-
-    output = output_header + [song_track + SONG]
-
-    midi_data = score2midi(output, text_encoding)
-    detailed_MIDI_stats = score2stats(output)
-
-    with open(output_file_name + '.mid', 'wb') as midi_file:
-        midi_file.write(midi_data)
-        midi_file.close()
-    
-    if verbose:    
-        print('Done! Enjoy! :)')
-    
-    return detailed_MIDI_stats
-
-###################################################################################
-
-def Tegridy_File_Time_Stamp(input_file_name='File_Created_on_', ext = ''):
-
-  '''Tegridy File Time Stamp
-     
-  Input: Full path and file name without extention
-         File extension
-          
-  Output: File name string with time-stamp and extension (time-stamped file name)
-
-  Project Los Angeles
-  Tegridy Code 2021'''       
-
-  print('Time-stamping output file...')
-
-  now = ''
-  now_n = str(datetime.now())
-  now_n = now_n.replace(' ', '_')
-  now_n = now_n.replace(':', '_')
-  now = now_n.replace('.', '_')
-      
-  fname = input_file_name + str(now) + ext
-
-  return(fname)
-
-###################################################################################
-
-def Tegridy_Any_Pickle_File_Writer(Data, input_file_name='TMIDI_Pickle_File'):
-
-  '''Tegridy Pickle File Writer
-     
-  Input: Data to write (I.e. a list)
-         Full path and file name without extention
-         
-  Output: Named Pickle file
-
-  Project Los Angeles
-  Tegridy Code 2021'''
-
-  print('Tegridy Pickle File Writer')
-
-  full_path_to_output_dataset_to = input_file_name + '.pickle'
-
-  if os.path.exists(full_path_to_output_dataset_to):
-    os.remove(full_path_to_output_dataset_to)
-    print('Removing old Dataset...')
-  else:
-    print("Creating new Dataset file...")
-
-  with open(full_path_to_output_dataset_to, 'wb') as filehandle:
-    # store the data as binary data stream
-    pickle.dump(Data, filehandle, protocol=pickle.HIGHEST_PROTOCOL)
-
-  print('Dataset was saved as:', full_path_to_output_dataset_to)
-  print('Task complete. Enjoy! :)')
-
-###################################################################################
-
-def Tegridy_Any_Pickle_File_Reader(input_file_name='TMIDI_Pickle_File', ext='.pickle', verbose=True):
-
-  '''Tegridy Pickle File Loader
-     
-  Input: Full path and file name with or without extention
-         File extension if different from default .pickle
-       
-  Output: Standard Python 3 unpickled data object
-
-  Project Los Angeles
-  Tegridy Code 2021'''
-
-  if verbose:
-    print('Tegridy Pickle File Loader')
-    print('Loading the pickle file. Please wait...')
-
-  if os.path.basename(input_file_name).endswith(ext):
-    fname = input_file_name
-  
-  else:
-    fname = input_file_name + ext
-
-  with open(fname, 'rb') as pickle_file:
-    content = pickle.load(pickle_file)
-
-  if verbose:
-    print('Done!')
-
-  return content
+from collections import Counter
+from collections import defaultdict
+from collections import OrderedDict
+from difflib import SequenceMatcher as SM
+from operator import itemgetter
+from itertools import product, combinations, groupby
 
 ###################################################################################
 
@@ -2091,7 +113,7 @@ def Optimus_MIDI_TXT_Processor(MIDI_file,
     if debug: print('Processing File:', MIDI_file)
     
     try:
-      opus = midi2opus(midi_file.read())
+      opus = MIDI.midi2opus(midi_file.read())
     
     except:
       print('Problematic MIDI. Skipping...')
@@ -2101,19 +123,19 @@ def Optimus_MIDI_TXT_Processor(MIDI_file,
          
     midi_file.close()
 
-    score1 = to_millisecs(opus)
-    score2 = opus2score(score1)
+    score1 = MIDI.to_millisecs(opus)
+    score2 = MIDI.opus2score(score1)
 
-    # score2 = opus2score(opus) # TODO Improve score timings when it will be possible.
+    # score2 = MIDI.opus2score(opus) # TODO Improve score timings when it will be possible.
     
     if MIDI_channel == 16: # Process all MIDI channels
       score = score2
     
     if MIDI_channel >= 0 and MIDI_channel <= 15: # Process only a selected single MIDI channel
-      score = grep(score2, [MIDI_channel])
+      score = MIDI.grep(score2, [MIDI_channel])
     
     if MIDI_channel == -1: # Process all channels except drums (except channel 9)
-      score = grep(score2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15])   
+      score = MIDI.grep(score2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15])   
     
     #print('Reading all MIDI events from the MIDI file...')
     while itrack < len(score):
@@ -3642,13 +1664,6 @@ def int_to_pitches_chord(integer, chord_base_pitch=60):
 
 ###################################################################################
 
-def bad_chord(chord):
-    bad = any(b - a == 1 for a, b in zip(chord, chord[1:]))
-    if (0 in chord) and (11 in chord):
-      bad = True
-    
-    return bad
-
 def validate_pitches_chord(pitches_chord, return_sorted = True):
 
     pitches_chord = sorted(list(set([x for x in pitches_chord if 0 < x < 128])))
@@ -3952,7 +1967,6 @@ def fix_monophonic_score_durations(monophonic_score,
 
 ###################################################################################
 
-from itertools import product
 
 ALL_CHORDS = [[0], [7], [5], [9], [2], [4], [11], [10], [8], [6], [3], [1], [0, 9], [2, 5],
               [4, 7], [7, 10], [2, 11], [0, 3], [6, 9], [1, 4], [8, 11], [5, 8], [1, 10],
@@ -4463,11 +2477,6 @@ def advanced_score_processor(raw_score,
 
 ###################################################################################
 
-import random
-import copy
-
-###################################################################################
-
 def replace_bad_tones_chord(bad_tones_chord):
   bad_chord_p = [0] * 12
   for b in bad_tones_chord:
@@ -5055,7 +3064,7 @@ def patch_list_from_enhanced_score_notes(enhanced_score_notes,
     print('Composition patches')
     print('=' * 70)
     for c, p in enumerate(patches):
-      print('Cha', str(c).zfill(2), '---', str(p).zfill(3), Number2patch[p])
+      print('Cha', str(c).zfill(2), '---', str(p).zfill(3), MIDI.Number2patch[p])
     print('=' * 70)
 
   return patches
@@ -5175,14 +3184,14 @@ def patch_enhanced_score_notes(escore_notes,
       print('Main composition patches')
       print('=' * 70)
       for c, p in enumerate(patches):
-        print('Cha', str(c).zfill(2), '---', str(p).zfill(3), Number2patch[p])
+        print('Cha', str(c).zfill(2), '---', str(p).zfill(3), MIDI.Number2patch[p])
       print('=' * 70)
 
       if overflow_patches:
         print('Extra composition patches')
         print('=' * 70)
         for c, p in enumerate(overflow_patches):
-          print(str(p).zfill(3), Number2patch[p])
+          print(str(p).zfill(3), MIDI.Number2patch[p])
         print('=' * 70)
 
     #===========================================================================
@@ -5321,10 +3330,6 @@ def check_and_fix_chords_in_chordified_score(chordified_score,
 
 ###################################################################################
 
-from itertools import combinations, groupby
-
-###################################################################################
-
 def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
                                                       channels_index=3,
                                                       pitches_index=4,
@@ -5963,10 +3968,6 @@ def enhanced_chord_to_tones_chord(enhanced_chord):
 
 ###################################################################################
 
-import hashlib
-
-###################################################################################
-
 def md5_hash(file_path_or_data=None, original_md5_hash=None):
 
   if type(file_path_or_data) == str:
@@ -9573,11 +7574,6 @@ MIDI_TEXT_EVENTS = ['text_event',
 
 ###################################################################################
 
-import hashlib
-import re
-
-###################################################################################
-
 def get_md5_hash(data):
     return hashlib.md5(data).hexdigest()
 
@@ -9764,20 +7760,20 @@ def escore_notes_to_text_description(escore_notes,
 
     patches = ordered_set(all_patches)[:16]
     
-    instruments = [alpha_str(Number2patch[p]) for p in patches if p < 128]
+    instruments = [alpha_str(MIDI.Number2patch[p]) for p in patches if p < 128]
     
     if instruments:
 
         nd_patches_counts = Counter([p for p in all_patches if p < 128]).most_common()
 
-        dominant_instrument = alpha_str(Number2patch[nd_patches_counts[0][0]])
+        dominant_instrument = alpha_str(MIDI.Number2patch[nd_patches_counts[0][0]])
 
     if 128 in patches:
         drums_present = True
 
         drums_pitches = [e[4] for e in escore_notes if e[3] == 9]
 
-        most_common_drums = [alpha_str(Notenum2percussion[p[0]]) for p in Counter(drums_pitches).most_common(3) if p[0] in Notenum2percussion]
+        most_common_drums = [alpha_str(MIDI.Notenum2percussion[p[0]]) for p in Counter(drums_pitches).most_common(3) if p[0] in MIDI.Notenum2percussion]
 
     else:
         drums_present = False
@@ -9859,10 +7855,10 @@ def escore_notes_to_text_description(escore_notes,
             escore_avgs = escore_notes_pitches_range(escore_notes, range_patch = mel[0])
             
             if mel[0] in LEAD_INSTRUMENTS and escore_avgs[3] > 60:
-                lead_melodies.append([Number2patch[mel[0]], mel[1]])
+                lead_melodies.append([MIDI.Number2patch[mel[0]], mel[1]])
 
             elif mel[0] in BASE_INSTRUMENTS and escore_avgs[3] <= 60:
-                base_melodies.append([Number2patch[mel[0]], mel[1]])
+                base_melodies.append([MIDI.Number2patch[mel[0]], mel[1]])
     
         if lead_melodies:
             lead_melodies.sort(key=lambda x: x[1], reverse=True)
@@ -10425,8 +8421,6 @@ def escore_notes_monoponic_melodies(escore_notes,
 
 ###################################################################################
 
-from itertools import groupby
-from operator import itemgetter
 
 def group_by_threshold(data, threshold, groupby_idx):
 
@@ -12992,9 +10986,15 @@ def convert_escore_notes_pitches_chords_signature(signature, convert_to_full_cho
 
 ###################################################################################
 
-def convert_bytes_in_nested_list(lst, encoding='utf-8', errors='ignore'):
+def convert_bytes_in_nested_list(lst, 
+                                 encoding='utf-8', 
+                                 errors='ignore',
+                                 return_changed_events_count=False
+                                ):
     
     new_list = []
+
+    ce_count = 0
     
     for item in lst:
         if isinstance(item, list):
@@ -13002,11 +11002,16 @@ def convert_bytes_in_nested_list(lst, encoding='utf-8', errors='ignore'):
             
         elif isinstance(item, bytes):
             new_list.append(item.decode(encoding, errors=errors))
+            ce_count += 1
             
         else:
             new_list.append(item)
             
-    return new_list
+    if return_changed_events_count:       
+        return new_list, ce_count
+
+    else:
+        return new_list
 
 ###################################################################################
 
@@ -13355,35 +11360,6 @@ def chunks_shuffle(lst,
     return flattened
 
 ###################################################################################
-
-def convert_bytes_in_nested_list(lst, 
-                                 encoding='utf-8', 
-                                 errors='ignore',
-                                 return_changed_events_count=False
-                                ):
-    
-    new_list = []
-
-    ce_count = 0
-    
-    for item in lst:
-        if isinstance(item, list):
-            new_list.append(convert_bytes_in_nested_list(item))
-            
-        elif isinstance(item, bytes):
-            new_list.append(item.decode(encoding, errors=errors))
-            ce_count += 1
-            
-        else:
-            new_list.append(item)
-            
-    if return_changed_events_count:       
-        return new_list, ce_count
-
-    else:
-        return new_list
-    
-###################################################################################
     
 def find_deepest_midi_dirs(roots,
                            marker_file="midi_score.mid",

TPLOTS.py → src/TPLOTS.py

@@ -1,1522 +1,1522 @@
-#! /usr/bin/python3
-
-r'''############################################################################
-################################################################################
-#
-#
-#	    Tegridy Plots Python Module (TPLOTS)
-#	    Version 1.0
-#
-#	    Project Los Angeles
-#
-#	    Tegridy Code 2025
-#
-#       https://github.com/asigalov61/tegridy-tools
-#
-#
-################################################################################
-#
-#       Copyright 2024 Project Los Angeles / Tegridy Code
-#
-#       Licensed under the Apache License, Version 2.0 (the "License");
-#       you may not use this file except in compliance with the License.
-#       You may obtain a copy of the License at
-#
-#           http://www.apache.org/licenses/LICENSE-2.0
-#
-#       Unless required by applicable law or agreed to in writing, software
-#       distributed under the License is distributed on an "AS IS" BASIS,
-#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#       See the License for the specific language governing permissions and
-#       limitations under the License.
-#
-################################################################################
-################################################################################
-#
-#       Critical dependencies
-#
-#       !pip install numpy==1.24.4
-#       !pip install scipy
-#       !pip install matplotlib
-#       !pip install networkx
-#       !pip3 install scikit-learn
-#
-################################################################################
-#
-#       Future critical dependencies
-#
-#       !pip install umap-learn
-#       !pip install alphashape
-#
-################################################################################
-'''
-
-################################################################################
-# Modules imports
-################################################################################
-
-import os
-from collections import Counter
-from itertools import groupby
-
-import numpy as np
-
-import networkx as nx
-
-from sklearn.manifold import TSNE
-from sklearn import metrics
-from sklearn.preprocessing import MinMaxScaler
-from sklearn.decomposition import PCA
-
-from scipy.ndimage import zoom
-from scipy.spatial import distance_matrix
-from scipy.sparse.csgraph import minimum_spanning_tree
-from scipy.stats import zscore
-
-import matplotlib.pyplot as plt
-from PIL import Image
-
-################################################################################
-# Constants
-################################################################################
-
-ALL_CHORDS_FULL = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6],
-                  [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 10], [0, 3, 8], [0, 3, 9],
-                  [0, 3, 10], [0, 4], [0, 4, 6], [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7],
-                  [0, 4, 7, 10], [0, 4, 8], [0, 4, 9], [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9],
-                  [0, 5, 10], [0, 6], [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9],
-                  [0, 10], [1], [1, 4], [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11],
-                  [1, 4, 7], [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9],
-                  [1, 4, 10], [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9],
-                  [1, 5, 10], [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7],
-                  [1, 7, 10], [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2],
-                  [2, 5], [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6],
-                  [2, 6, 9], [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8],
-                  [2, 8, 11], [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11],
-                  [3, 5, 9], [3, 5, 10], [3, 5, 11], [3, 6], [3, 6, 9], [3, 6, 10], [3, 6, 11],
-                  [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11], [3, 9], [3, 10], [3, 11],
-                  [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11], [4, 7], [4, 7, 10], [4, 7, 11],
-                  [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11], [5], [5, 8], [5, 8, 11], [5, 9],
-                  [5, 10], [5, 11], [6], [6, 9], [6, 10], [6, 11], [7], [7, 10], [7, 11], [8],
-                  [8, 11], [9], [10], [11]]
-
-################################################################################
-
-CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
-
-################################################################################
-
-WHITE_NOTES = [0, 2, 4, 5, 7, 9, 11]
-
-################################################################################
-
-BLACK_NOTES = [1, 3, 6, 8, 10]
-
-################################################################################
-# Helper functions
-################################################################################
-
-def tones_chord_type(tones_chord, 
-                     return_chord_type_index=True,
-                     ):
-
-  """
-  Returns tones chord type
-  """
-
-  WN = WHITE_NOTES
-  BN = BLACK_NOTES
-  MX = WHITE_NOTES + BLACK_NOTES
-
-
-  CHORDS = ALL_CHORDS_FULL
-
-  tones_chord = sorted(tones_chord)
-
-  ctype = 'UNKNOWN'
-
-  if tones_chord in CHORDS:
-
-    if sorted(set(tones_chord) & set(WN)) == tones_chord:
-      ctype = 'WHITE'
-
-    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
-      ctype = 'BLACK'
-
-    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
-
-      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
-        ctype = 'MIXED GRAY'
-
-      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
-        ctype = 'MIXED WHITE'
-
-      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
-        ctype = 'MIXED BLACK'
-
-  if return_chord_type_index:
-    return CHORDS_TYPES.index(ctype)
-
-  else:
-    return ctype
-
-###################################################################################
-
-def tone_type(tone, 
-              return_tone_type_index=True
-              ):
-
-  """
-  Returns tone type
-  """
-
-  tone = tone % 12
-
-  if tone in BLACK_NOTES:
-    if return_tone_type_index:
-      return CHORDS_TYPES.index('BLACK')
-    else:
-      return "BLACK"
-
-  else:
-    if return_tone_type_index:
-      return CHORDS_TYPES.index('WHITE')
-    else:
-      return "WHITE"
-
-###################################################################################
-
-def find_closest_points(points, return_points=True):
-
-  """
-  Find closest 2D points
-  """
-
-  coords = np.array(points)
-
-  num_points = coords.shape[0]
-  closest_matches = np.zeros(num_points, dtype=int)
-  distances = np.zeros((num_points, num_points))
-
-  for i in range(num_points):
-      for j in range(num_points):
-          if i != j:
-              distances[i, j] = np.linalg.norm(coords[i] - coords[j])
-          else:
-              distances[i, j] = np.inf
-
-  closest_matches = np.argmin(distances, axis=1)
-  
-  if return_points:
-    points_matches = coords[closest_matches].tolist()
-    return points_matches
-  
-  else:
-    return closest_matches.tolist()
-
-################################################################################
-
-def reduce_dimensionality_tsne(list_of_valies,
-                                n_comp=2,
-                                n_iter=5000,
-                                verbose=True
-                              ):
-
-  """
-  Reduces the dimensionality of the values using t-SNE.
-  """
-
-  vals = np.array(list_of_valies)
-
-  tsne = TSNE(n_components=n_comp,
-              n_iter=n_iter,
-              verbose=verbose)
-
-  reduced_vals = tsne.fit_transform(vals)
-
-  return reduced_vals.tolist()
-
-################################################################################
-
-def compute_mst_edges(similarity_scores_list):
-
-  """
-  Computes the Minimum Spanning Tree (MST) edges based on the similarity scores.
-  """
-  
-  num_tokens = len(similarity_scores_list[0])
-
-  graph = nx.Graph()
-
-  for i in range(num_tokens):
-      for j in range(i + 1, num_tokens):
-          weight = 1 - similarity_scores_list[i][j]
-          graph.add_edge(i, j, weight=weight)
-
-  mst = nx.minimum_spanning_tree(graph)
-
-  mst_edges = list(mst.edges(data=False))
-
-  return mst_edges
-
-################################################################################
-
-def square_binary_matrix(binary_matrix, 
-                         matrix_size=128,
-                         interpolation_order=5,
-                         return_square_matrix_points=False
-                         ):
-
-  """
-  Reduces an arbitrary binary matrix to a square binary matrix
-  """
-
-  zoom_factors = (matrix_size / len(binary_matrix), 1)
-
-  resized_matrix = zoom(binary_matrix, zoom_factors, order=interpolation_order)
-
-  resized_matrix = (resized_matrix > 0.5).astype(int)
-
-  final_matrix = np.zeros((matrix_size, matrix_size), dtype=int)
-  final_matrix[:, :resized_matrix.shape[1]] = resized_matrix
-
-  points = np.column_stack(np.where(final_matrix == 1)).tolist()
-
-  if return_square_matrix_points:
-    return points
-
-  else:
-    return resized_matrix
-
-################################################################################
-
-def square_matrix_points_colors(square_matrix_points):
-
-  """
-  Returns colors for square matrix points
-  """
-
-  cmap = generate_colors(12)
-
-  chords = []
-  chords_dict = set()
-  counts = []
-
-  for k, v in groupby(square_matrix_points, key=lambda x: x[0]):
-    pgroup = [vv[1] for vv in v]
-    chord = sorted(set(pgroup))
-    tchord = sorted(set([p % 12 for p in chord]))
-    chords_dict.add(tuple(tchord))
-    chords.append(tuple(tchord))
-    counts.append(len(pgroup))
-
-  chords_dict = sorted(chords_dict)
-
-  colors = []
-
-  for i, c in enumerate(chords):
-    colors.extend([cmap[round(sum(c) / len(c))]] * counts[i])
-
-  return colors
-
-################################################################################
-
-def hsv_to_rgb(h, s, v):
-
-  if s == 0.0:
-      return v, v, v
-
-  i = int(h*6.0)
-  f = (h*6.0) - i
-  p = v*(1.0 - s)
-  q = v*(1.0 - s*f)
-  t = v*(1.0 - s*(1.0-f))
-  i = i%6
-  
-  return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
-
-################################################################################
-
-def generate_colors(n):
-  return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
-
-################################################################################
-
-def add_arrays(a, b):
-  return [sum(pair) for pair in zip(a, b)]
-
-################################################################################
-
-def calculate_similarities(lists_of_values, metric='cosine'):
-  return metrics.pairwise_distances(lists_of_values, metric=metric).tolist()
-
-################################################################################
-
-def get_tokens_embeddings(x_transformer_model):
-  return x_transformer_model.net.token_emb.emb.weight.detach().cpu().tolist()
-
-################################################################################
-
-def minkowski_distance_matrix(X, p=3):
-
-  X = np.array(X)
-
-  n = X.shape[0]
-  dist_matrix = np.zeros((n, n))
-
-  for i in range(n):
-      for j in range(n):
-          dist_matrix[i, j] = np.sum(np.abs(X[i] - X[j])**p)**(1/p)
-
-  return dist_matrix.tolist()
-
-################################################################################
-
-def robust_normalize(values):
-
-  values = np.array(values)
-  q1 = np.percentile(values, 25)
-  q3 = np.percentile(values, 75)
-  iqr = q3 - q1
-
-  filtered_values = values[(values >= q1 - 1.5 * iqr) & (values <= q3 + 1.5 * iqr)]
-
-  min_val = np.min(filtered_values)
-  max_val = np.max(filtered_values)
-  normalized_values = (values - min_val) / (max_val - min_val)
-
-  normalized_values = np.clip(normalized_values, 0, 1)
-
-  return normalized_values.tolist()
-
-################################################################################
-
-def min_max_normalize(values):
-
-  scaler = MinMaxScaler()
-
-  return scaler.fit_transform(values).tolist()
-
-################################################################################
-
-def remove_points_outliers(points, z_score_threshold=3):
-
-  points = np.array(points)
-
-  z_scores = np.abs(zscore(points, axis=0))
-
-  return points[(z_scores < z_score_threshold).all(axis=1)].tolist()
-
-################################################################################
-
-def generate_labels(lists_of_values, 
-                    return_indices_labels=False
-                    ):
-
-  ordered_indices = list(range(len(lists_of_values)))
-  ordered_indices_labels = [str(i) for i in ordered_indices]
-  ordered_values_labels = [str(lists_of_values[i]) for i in ordered_indices]
-
-  if return_indices_labels:
-    return ordered_indices_labels
-  
-  else:
-    return ordered_values_labels
-
-################################################################################
-
-def reduce_dimensionality_pca(list_of_values, n_components=2):
-
-  """
-  Reduces the dimensionality of the values using PCA.
-  """
-
-  pca = PCA(n_components=n_components)
-  pca_data = pca.fit_transform(list_of_values)
-  
-  return pca_data.tolist()
-
-def reduce_dimensionality_simple(list_of_values, 
-                                 return_means=True,
-                                 return_std_devs=True,
-                                 return_medians=False,
-                                 return_vars=False
-                                 ):
-  
-  '''
-  Reduces dimensionality of the values in a simple way
-  '''
-
-  array = np.array(list_of_values)
-  results = []
-
-  if return_means:
-      means = np.mean(array, axis=1)
-      results.append(means)
-
-  if return_std_devs:
-      std_devs = np.std(array, axis=1)
-      results.append(std_devs)
-
-  if return_medians:
-      medians = np.median(array, axis=1)
-      results.append(medians)
-
-  if return_vars:
-      vars = np.var(array, axis=1)
-      results.append(vars)
-
-  merged_results = np.column_stack(results)
-  
-  return merged_results.tolist()
-
-################################################################################
-
-def reduce_dimensionality_2d_distance(list_of_values, p=5):
-
-  '''
-  Reduces the dimensionality of the values using 2d distance
-  '''
-
-  values = np.array(list_of_values)
-
-  dist_matrix = distance_matrix(values, values, p=p)
-
-  mst = minimum_spanning_tree(dist_matrix).toarray()
-
-  points = []
-
-  for i in range(len(values)):
-      for j in range(len(values)):
-          if mst[i, j] > 0:
-              points.append([i, j])
-
-  return points
-
-################################################################################
-
-def normalize_to_range(values, n):
-    
-  min_val = min(values)
-  max_val = max(values)
-  
-  range_val = max_val - min_val
-  
-  normalized_values = [((value - min_val) / range_val * 2 * n) - n for value in values]
-  
-  return normalized_values
-
-################################################################################
-
-def reduce_dimensionality_simple_pca(list_of_values, n_components=2):
-
-  '''
-  Reduces the dimensionality of the values using simple PCA
-  '''
-
-  reduced_values = []
-
-  for l in list_of_values:
-
-    norm_values = [round(v * len(l)) for v in normalize_to_range(l, (n_components+1) // 2)]
-
-    pca_values = Counter(norm_values).most_common()
-    pca_values = [vv[0] / len(l) for vv in pca_values]
-    pca_values = pca_values[:n_components]
-    pca_values = pca_values + [0] * (n_components - len(pca_values))
-
-    reduced_values.append(pca_values)
-
-  return reduced_values
-
-################################################################################
-
-def filter_and_replace_values(list_of_values, 
-                              threshold, 
-                              replace_value, 
-                              replace_above_threshold=False
-                              ):
-
-  array = np.array(list_of_values)
-
-  modified_array = np.copy(array)
-  
-  if replace_above_threshold:
-    modified_array[modified_array > threshold] = replace_value
-  
-  else:
-    modified_array[modified_array < threshold] = replace_value
-  
-  return modified_array.tolist()
-
-################################################################################
-
-def find_shortest_constellation_path(points, 
-                                     start_point_idx, 
-                                     end_point_idx,
-                                     p=5,
-                                     return_path_length=False,
-                                     return_path_points=False,
-                                     ):
-
-    """
-    Finds the shortest path between two points of the points constellation
-    """
-
-    points = np.array(points)
-
-    dist_matrix = distance_matrix(points, points, p=p)
-
-    mst = minimum_spanning_tree(dist_matrix).toarray()
-
-    G = nx.Graph()
-
-    for i in range(len(points)):
-        for j in range(len(points)):
-            if mst[i, j] > 0:
-                G.add_edge(i, j, weight=mst[i, j])
-
-    path = nx.shortest_path(G, 
-                            source=start_point_idx, 
-                            target=end_point_idx, 
-                            weight='weight'
-                            )
-    
-    path_length = nx.shortest_path_length(G, 
-                                          source=start_point_idx, 
-                                          target=end_point_idx, 
-                                          weight='weight')
-        
-    path_points = points[np.array(path)].tolist()
-
-
-    if return_path_points:
-      return path_points
-
-    if return_path_length:
-      return path_length
-
-    return path
-
-################################################################################
-# Core functions
-################################################################################
-
-def plot_ms_SONG(ms_song,
-                  preview_length_in_notes=0,
-                  block_lines_times_list = None,
-                  plot_title='ms Song',
-                  max_num_colors=129, 
-                  drums_color_num=128, 
-                  plot_size=(11,4), 
-                  note_height = 0.75,
-                  show_grid_lines=False,
-                  return_plt = False,
-                  timings_multiplier=1,
-                  save_plt='',
-                  save_only_plt_image=True,
-                  save_transparent=False
-                  ):
-
-  '''ms SONG plot'''
-
-  notes = [s for s in ms_song if s[0] == 'note']
-
-  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
-    print('The song notes do not have patches information')
-    print('Ploease add patches to the notes in the song')
-
-  else:
-
-    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
-    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
-    pitches = [s[4] for s in notes]
-    patches = [s[6] for s in notes]
-
-    colors = generate_colors(max_num_colors)
-    colors[drums_color_num] = (1, 1, 1)
-
-    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
-
-    fig, ax = plt.subplots(figsize=plot_size)
-
-    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
-        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
-        ax.add_patch(rect)
-
-    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
-    ax.set_ylim([min(pitches)-1, max(pitches)+1])
-
-    ax.set_facecolor('black')
-    fig.patch.set_facecolor('white')
-
-    if preview_length_in_notes > 0:
-      ax.axvline(x=pbl, c='white')
-
-    if block_lines_times_list:
-      for bl in block_lines_times_list:
-        ax.axvline(x=bl, c='white')
-           
-    if show_grid_lines:
-      ax.grid(color='white')
-
-    plt.xlabel('Time (s)', c='black')
-    plt.ylabel('MIDI Pitch', c='black')
-
-    plt.title(plot_title)
-
-    if save_plt != '':
-      if save_only_plt_image:
-        plt.axis('off')
-        plt.title('')
-        plt.savefig(save_plt, 
-                    transparent=save_transparent, 
-                    bbox_inches='tight', 
-                    pad_inches=0, 
-                    facecolor='black'
-                    )
-        plt.close()
-      
-      else:
-        plt.savefig(save_plt)
-        plt.close()
-
-    if return_plt:
-      return fig
-
-    plt.show()
-    plt.close()
-
-################################################################################
-
-def plot_square_matrix_points(list_of_points,
-                              list_of_points_colors,
-                              plot_size=(7, 7),
-                              point_size = 10,
-                              show_grid_lines=False,
-                              plot_title = 'Square Matrix Points Plot',
-                              return_plt=False,
-                              save_plt='',
-                              save_only_plt_image=True,
-                              save_transparent=False
-                              ):
-
-  '''Square matrix points plot'''
-
-  fig, ax = plt.subplots(figsize=plot_size)
-
-  ax.set_facecolor('black')
-
-  if show_grid_lines:
-    ax.grid(color='white')
-
-  plt.xlabel('Time Step', c='black')
-  plt.ylabel('MIDI Pitch', c='black')
-
-  plt.title(plot_title)
-
-  plt.scatter([p[0] for p in list_of_points], 
-              [p[1] for p in list_of_points], 
-              c=list_of_points_colors, 
-              s=point_size
-              )
-
-  if save_plt != '':
-    if save_only_plt_image:
-      plt.axis('off')
-      plt.title('')
-      plt.savefig(save_plt, 
-                  transparent=save_transparent, 
-                  bbox_inches='tight', 
-                  pad_inches=0, 
-                  facecolor='black'
-                  )
-      plt.close()
-    
-    else:
-      plt.savefig(save_plt)
-      plt.close()
-
-  if return_plt:
-    return fig
-
-  plt.show()
-  plt.close()
-
-################################################################################
-
-def plot_cosine_similarities(lists_of_values,
-                             plot_size=(7, 7),
-                             save_plot=''
-                            ):
-
-  """
-  Cosine similarities plot
-  """
-
-  cos_sim = metrics.pairwise_distances(lists_of_values, metric='cosine')
-
-  plt.figure(figsize=plot_size)
-
-  plt.imshow(cos_sim, cmap="inferno", interpolation="nearest")
-
-  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]
-
-  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
-
-  plt.xlabel("Index")
-  plt.ylabel("Index")
-
-  plt.tight_layout()
-
-  if save_plot != '':
-    plt.savefig(save_plot, bbox_inches="tight")
-    plt.close()
-
-  plt.show()
-  plt.close()
-
-################################################################################
-
-def plot_points_with_mst_lines(points, 
-                               points_labels, 
-                               points_mst_edges,
-                               plot_size=(20, 20),
-                               labels_size=24,
-                               save_plot=''
-                               ):
-
-  """
-  Plots 2D points with labels and MST lines.
-  """
-
-  plt.figure(figsize=plot_size)
-
-  for i, label in enumerate(points_labels):
-      plt.scatter(points[i][0], points[i][1])
-      plt.annotate(label, (points[i][0], points[i][1]), fontsize=labels_size)
-
-  for edge in points_mst_edges:
-      i, j = edge
-      plt.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'k-', alpha=0.5)
-
-  plt.title('Points Map with MST Lines', fontsize=labels_size)
-  plt.xlabel('X-axis', fontsize=labels_size)
-  plt.ylabel('Y-axis', fontsize=labels_size)
-
-  if save_plot != '':
-    plt.savefig(save_plot, bbox_inches="tight")
-    plt.close()
-
-  plt.show()
-
-  plt.close()
-
-################################################################################
-
-def plot_points_constellation(points, 
-                              points_labels,
-                              p=5,                              
-                              plot_size=(15, 15),
-                              labels_size=12,
-                              show_grid=False,
-                              save_plot=''
-                              ):
-
-  """
-  Plots 2D points constellation
-  """
-
-  points = np.array(points)
-
-  dist_matrix = distance_matrix(points, points, p=p)
-
-  mst = minimum_spanning_tree(dist_matrix).toarray()
-
-  plt.figure(figsize=plot_size)
-
-  plt.scatter(points[:, 0], points[:, 1], color='blue')
-
-  for i, label in enumerate(points_labels):
-      plt.annotate(label, (points[i, 0], points[i, 1]), 
-                   textcoords="offset points", 
-                   xytext=(0, 10), 
-                   ha='center',
-                   fontsize=labels_size
-                   )
-
-  for i in range(len(points)):
-      for j in range(len(points)):
-          if mst[i, j] > 0:
-              plt.plot([points[i, 0], points[j, 0]], [points[i, 1], points[j, 1]], 'k--')
-
-  plt.xlabel('X-axis', fontsize=labels_size)
-  plt.ylabel('Y-axis', fontsize=labels_size)
-  plt.title('2D Coordinates with Minimum Spanning Tree', fontsize=labels_size)
-
-  plt.grid(show_grid)
-
-  if save_plot != '':
-    plt.savefig(save_plot, bbox_inches="tight")
-    plt.close()
-
-  plt.show()
-
-  plt.close()
-
-################################################################################
-
-def binary_matrix_to_images(matrix, 
-                            step,
-                            overlap,
-                            output_folder='./Dataset/', 
-                            output_img_prefix='image', 
-                            output_img_ext='.png',
-                            save_to_array=False,
-                            verbose=True
-                            ):
-
-    if not save_to_array:
-
-      if verbose:
-        print('=' * 70)
-        print('Checking output folder dir...')
-
-      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
-
-      if verbose:
-        print('Done!')
-
-    if verbose:
-      print('=' * 70)
-      print('Writing images...')
-
-    matrix = np.array(matrix, dtype=np.uint8)
-    
-    image_array = []
-    
-    for i in range(0, max(1, matrix.shape[0]), overlap):
-       
-        submatrix = matrix[i:i+step, :]
-
-        if submatrix.shape[0] < 128:
-          zeros_array = np.zeros((128-submatrix.shape[0], 128))
-          submatrix = np.vstack((submatrix, zeros_array))
-
-        img = Image.fromarray(submatrix * 255).convert('1')
-        
-        if save_to_array:
-          image_array.append(np.array(img))
-
-        else:
-          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
-  
-    if verbose:
-      print('Done!')
-      print('=' * 70)
-      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
-      print('=' * 70)
-
-    if save_to_array:
-        return np.array(image_array).tolist()
-
-################################################################################
-
-def images_to_binary_matrix(list_of_images):
-
-    image_array = np.array(list_of_images)
-   
-    original_matrix = []
-    
-    for img in image_array:
-
-        submatrix = np.array(img)
-        original_matrix.extend(submatrix.tolist())
-    
-    return original_matrix
-
-################################################################################
-
-def square_image_matrix(image_matrix,
-                        matrix_size=128,
-                        num_pca_components=5,
-                        filter_out_zero_rows=False,
-                        return_square_matrix_points=False
-                        ):
-
-  """
-  Reduces an arbitrary image matrix to a square image matrix
-  """
-
-  matrix = np.array(image_matrix)
-
-  if filter_out_zero_rows:
-    matrix = matrix[~np.all(matrix == 0, axis=1)]
-
-  target_rows = matrix_size
-
-  rows_per_group = matrix.shape[0] // target_rows
-
-  compressed_matrix = np.zeros((target_rows, matrix.shape[1]), dtype=np.int32)
-
-  for i in range(target_rows):
-      start_row = i * rows_per_group
-      end_row = (i + 1) * rows_per_group
-      group = matrix[start_row:end_row, :]
-      
-      pca = PCA(n_components=num_pca_components)
-      pca.fit(group)
-      
-      principal_component = np.mean(pca.components_, axis=0)
-      contributions = np.dot(group, principal_component)
-      selected_row_index = np.argmax(contributions)
-      
-      compressed_matrix[i, :] = group[selected_row_index, :]
-
-  if return_square_matrix_points:
-    filtered_matrix = compressed_matrix[~np.all(compressed_matrix == 0, axis=1)]
-
-    row_indexes, col_indexes = np.where(filtered_matrix != 0)
-    points = np.column_stack((row_indexes, filtered_matrix[row_indexes, col_indexes])).tolist()
-
-    return points
-
-  else:
-    return compressed_matrix.tolist()
-
-################################################################################
-
-def image_matrix_to_images(image_matrix,
-                           step,
-                           overlap,
-                           num_img_channels=3,
-                           output_folder='./Dataset/',
-                           output_img_prefix='image',
-                           output_img_ext='.png',
-                           save_to_array=False,
-                           verbose=True
-                           ):
-
-    if num_img_channels > 1:
-      n_mat_channels = 3
-
-    else:
-      n_mat_channels = 1
-
-    if not save_to_array:
-
-      if verbose:
-        print('=' * 70)
-        print('Checking output folder dir...')
-
-      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
-
-      if verbose:
-        print('Done!')
-
-    if verbose:
-      print('=' * 70)
-      print('Writing images...')
-
-    matrix = np.array(image_matrix)
-
-    image_array = []
-
-    for i in range(0, max(1, matrix.shape[0]), overlap):
-
-        submatrix = matrix[i:i+step, :]
-
-        if submatrix.shape[0] < 128:
-          zeros_array = np.zeros((128-submatrix.shape[0], 128))
-          submatrix = np.vstack((submatrix, zeros_array))
-
-        if n_mat_channels == 3:
-
-          r = (submatrix // (256*256)) % 256
-          g = (submatrix // 256) % 256
-          b = submatrix % 256
-
-          rgb_image = np.stack((r, g, b), axis=-1).astype(np.uint8)
-          img = Image.fromarray(rgb_image, 'RGB')
-
-        else:
-          grayscale_image = submatrix.astype(np.uint8)
-          img = Image.fromarray(grayscale_image, 'L')
-
-        if save_to_array:
-          image_array.append(np.array(img))
-
-        else:
-          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
-
-    if verbose:
-      print('Done!')
-      print('=' * 70)
-      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
-      print('=' * 70)
-
-    if save_to_array:
-        return np.array(image_array).tolist()
-
-################################################################################
-
-def images_to_image_matrix(list_of_images,
-                           num_img_channels=3
-                           ):
-
-    if num_img_channels > 1:
-      n_mat_channels = 3
-
-    else:
-      n_mat_channels = 1
-
-    image_array = np.array(list_of_images)
-
-    original_matrix = []
-
-    for img in image_array:
-
-      if num_img_channels == 3:
-
-        rgb_array = np.array(img)
-
-        matrix = (rgb_array[..., 0].astype(np.int64) * 256*256 +
-                  rgb_array[..., 1].astype(np.int64) * 256 +
-                  rgb_array[..., 2].astype(np.int64))
-
-      else:
-        matrix = np.array(img)
-
-      original_matrix.extend(matrix)
-
-    return original_matrix
-
-################################################################################
-
-def square_matrix_to_RGB_matrix(square_matrix):
-
-  smatrix = np.array(square_matrix)
-  sq_matrix = smatrix[:smatrix.shape[1]]
-
-  r = (sq_matrix // (256 ** 2)) % 256
-  g = (sq_matrix // 256) % 256
-  b = sq_matrix % 256
-
-  rgb_array = np.stack((r, g, b), axis=-1)
-
-  return rgb_array.tolist()
-
-################################################################################
-
-def upsample_square_matrix(square_matrix, upsampling_factor=4):
-
-  smatrix = np.array(square_matrix)
-  sq_matrix = smatrix[:smatrix.shape[1]]
-
-  scaling_array = np.ones((upsampling_factor, upsampling_factor))
-  scaled_array = np.kron(sq_matrix, scaling_array)
-  scaled_array = scaled_array.astype('int')
-
-  return scaled_array.tolist()
-
-################################################################################
-
-def downsample_square_matrix(square_matrix, downsampling_factor=4):
-
-  smatrix = np.array(square_matrix)
-  sq_matrix = smatrix[:smatrix.shape[1]]
-
-  dmatrix = sq_matrix[::downsampling_factor, ::downsampling_factor]
-  dmatrix = dmatrix.astype('int')
-
-  return dmatrix.tolist()
-
-################################################################################
-
-def plot_parsons_code(parsons_code, 
-                      start_pitch=60, 
-                      return_plot_dict=False, 
-                      return_plot_string=False,
-                      plot_size=(10, 10),
-                      labels_size=16,
-                      save_plot=''
-                      ):
-  
-  '''
-  Plot parsons code string
-  '''
-
-  if parsons_code[0] != "*":
-      return None
-
-  contour_dict = {}
-  pitch = 0
-  index = 0
-
-  maxp = 0
-  minp = 0
-
-  contour_dict[(pitch, index)] = "*"
-
-  for point in parsons_code:
-      if point == "R":
-          index += 1
-          contour_dict[(pitch, index)] = "-"
-
-          index += 1
-          contour_dict[(pitch, index)] = "*"
-          
-      elif point == "U":
-          index += 1
-          pitch -= 1
-          contour_dict[(pitch, index)] = "/"
-
-          index += 1
-          pitch -= 1
-          contour_dict[(pitch, index)] = "*"
-
-          if pitch < maxp:
-              maxp = pitch
-
-      elif point == "D":
-          index += 1
-          pitch += 1
-          contour_dict[(pitch, index)] = "\\"
-
-          index += 1
-          pitch += 1
-          contour_dict[(pitch, index)] = "*"
-
-          if pitch > minp:
-              minp = pitch
-
-  if return_plot_dict:
-    return contour_dict
-  
-  if return_plot_string:
-
-    plot_string = ''
-
-    for pitch in range(maxp, minp+1):
-        line = [" " for _ in range(index + 1)]
-        for pos in range(index + 1):
-            if (pitch, pos) in contour_dict:
-                line[pos] = contour_dict[(pitch, pos)]
-
-        plot_string = "".join(line)
-
-    return plot_string
-
-  labels = []
-  pitches = []
-  positions = []
-  cur_pitch = start_pitch
-  pitch_idx = 0
-
-  for k, v in contour_dict.items():
-
-    if v != '*':
-
-      pitches.append(cur_pitch)
-      positions.append(pitch_idx)
-
-      if v == '/':
-        cur_pitch += 1
-        labels.append('U')
-      
-      elif v == '\\':
-        cur_pitch -= 1
-        labels.append('D')
-
-      elif v == '-':
-        labels.append('R')
-
-      pitch_idx += 1
-
-  plt.figure(figsize=plot_size)
-
-  
-  plt.plot(pitches)
-
-  for i, point in enumerate(zip(positions, pitches)):
-    plt.annotate(labels[i], point, fontsize=labels_size)
-  
-
-  plt.title('Parsons Code with Labels', fontsize=labels_size)
-  plt.xlabel('Position', fontsize=labels_size)
-  plt.ylabel('Pitch', fontsize=labels_size)
-
-  if save_plot != '':
-    plt.savefig(save_plot, bbox_inches="tight")
-    plt.close()
-
-  plt.show()
-
-  plt.close()
-  
-################################################################################
-
-def plot_tokens_embeddings_constellation(tokens_embeddings,
-                                         start_token,
-                                         end_token,
-                                         plot_size=(10, 10),
-                                         labels_size=12,
-                                         show_grid=False,
-                                         save_plot=''):
-    
-    """
-    Plots token embeddings constellation using MST and graph layout
-    without dimensionality reduction.
-    """
-
-    distance_matrix = metrics.pairwise_distances(tokens_embeddings[start_token:end_token], metric='cosine')
-    
-    token_labels = [str(i) for i in range(start_token, end_token)]
-
-    mst = minimum_spanning_tree(distance_matrix).toarray()
-    
-    n = distance_matrix.shape[0]
-    G = nx.Graph()
-    
-    for i in range(n):
-        for j in range(n):
-            if mst[i, j] > 0:
-                weight = 1 / (distance_matrix[i, j] + 1e-8)
-                G.add_edge(i, j, weight=weight)
-    
-    pos = nx.kamada_kawai_layout(G, weight='weight')
-    
-    points = np.array([pos[i] for i in range(n)])
-    
-    plt.figure(figsize=plot_size)
-    plt.scatter(points[:, 0], points[:, 1], color='blue')
-    
-    for i, label in enumerate(token_labels):
-        plt.annotate(label, (points[i, 0], points[i, 1]),
-                     textcoords="offset points",
-                     xytext=(0, 10),
-                     ha='center',
-                     fontsize=labels_size)
-    
-    for i in range(n):
-        for j in range(n):
-            if mst[i, j] > 0:
-                plt.plot([points[i, 0], points[j, 0]],
-                         [points[i, 1], points[j, 1]],
-                         'k--', alpha=0.5)
-    
-    plt.title('Token Embeddings Constellation with MST', fontsize=labels_size)
-    plt.grid(show_grid)
-    
-    if save_plot:
-        plt.savefig(save_plot, bbox_inches="tight")
-        plt.close()
-        
-    else:
-        plt.show()
-        
-    plt.close()
-    
-################################################################################
-
-def find_token_path(tokens_embeddings, 
-                    start_token, 
-                    end_token, 
-                    verbose=False
-                   ):
-    
-    """
-    Finds the path of tokens between start_token and end_token using
-    the Minimum Spanning Tree (MST) derived from the distance matrix.
-    """
-
-    distance_matrix = metrics.pairwise_distances(tokens_embeddings, metric='cosine')
-    
-    token_labels = [str(i) for i in range(len(distance_matrix))]
-    
-    if verbose:
-        print('Total number of tokens:', len(distance_matrix))
-    
-    mst = minimum_spanning_tree(distance_matrix).toarray()
-    
-    n = distance_matrix.shape[0]
-    G = nx.Graph()
-    
-    for i in range(n):
-        for j in range(n):
-            if mst[i, j] > 0:
-                weight = 1 / (distance_matrix[i, j] + 1e-8)
-                G.add_edge(i, j, weight=weight)
-    
-    try:
-        start_idx = token_labels.index(str(start_token))
-        end_idx = token_labels.index(str(end_token))
-        
-    except ValueError:
-        raise ValueError("Start or end token not found in the provided token labels.")
-    
-    path_indices = nx.shortest_path(G, source=start_idx, target=end_idx)
-    
-    token_path = [int(token_labels[idx]) for idx in path_indices]
-    
-    return token_path
-
-################################################################################
-# [WIP] Future dev functions
-################################################################################
-
-'''
-import umap
-
-def reduce_dimensionality_umap(list_of_values,
-                               n_comp=2,
-                               n_neighbors=15,
-                               ):
-
-  """
-  Reduces the dimensionality of the values using UMAP.
-  """
-
-  vals = np.array(list_of_values)
-
-  umap_reducer = umap.UMAP(n_components=n_comp,
-                           n_neighbors=n_neighbors,
-                           n_epochs=5000,
-                           verbose=True
-                           )
-
-  reduced_vals = umap_reducer.fit_transform(vals)
-
-  return reduced_vals.tolist()
-'''
-
-################################################################################
-
-'''
-import alphashape
-from shapely.geometry import Point
-from matplotlib.tri import Triangulation, LinearTriInterpolator
-from scipy.stats import zscore
-
-#===============================================================================
-
-coordinates = points
-
-dist_matrix = minkowski_distance_matrix(coordinates, p=3)  # You can change the value of p as needed
-
-# Centering matrix
-n = dist_matrix.shape[0]
-H = np.eye(n) - np.ones((n, n)) / n
-
-# Apply double centering
-B = -0.5 * H @ dist_matrix**2 @ H
-
-# Eigen decomposition
-eigvals, eigvecs = np.linalg.eigh(B)
-
-# Sort eigenvalues and eigenvectors
-idx = np.argsort(eigvals)[::-1]
-eigvals = eigvals[idx]
-eigvecs = eigvecs[:, idx]
-
-# Select the top 2 eigenvectors
-X_transformed = eigvecs[:, :2] * np.sqrt(eigvals[:2])
-
-#===============================================================================
-
-src_points = X_transformed
-src_values = np.array([[p[1]] for p in points]) #np.random.rand(X_transformed.shape[0])
-
-#===============================================================================
-
-# Normalize the points to the range [0, 1]
-scaler = MinMaxScaler()
-points_normalized = scaler.fit_transform(src_points)
-
-values_normalized = custom_normalize(src_values)
-
-# Remove outliers based on z-score
-z_scores = np.abs(zscore(points_normalized, axis=0))
-filtered_points = points_normalized[(z_scores < 3).all(axis=1)]
-filtered_values = values_normalized[(z_scores < 3).all(axis=1)]
-
-# Compute the concave hull (alpha shape)
-alpha = 8  # Adjust alpha as needed
-hull = alphashape.alphashape(filtered_points, alpha)
-
-# Create a triangulation
-tri = Triangulation(filtered_points[:, 0], filtered_points[:, 1])
-
-# Interpolate the values on the triangulation
-interpolator = LinearTriInterpolator(tri, filtered_values[:, 0])
-xi, yi = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
-zi = interpolator(xi, yi)
-
-# Mask out points outside the concave hull
-mask = np.array([hull.contains(Point(x, y)) for x, y in zip(xi.flatten(), yi.flatten())])
-zi = np.ma.array(zi, mask=~mask.reshape(zi.shape))
-
-# Plot the filled contour based on the interpolated values
-plt.contourf(xi, yi, zi, levels=50, cmap='viridis')
-
-# Plot the original points
-#plt.scatter(filtered_points[:, 0], filtered_points[:, 1], c=filtered_values, edgecolors='k')
-
-plt.title('Filled Contour Plot with Original Values')
-plt.xlabel('X-axis')
-plt.ylabel('Y-axis')
-plt.colorbar(label='Value')
-plt.show()
-'''
-
-################################################################################
-
-def plot_tree_horizontal(data):
-    
-    """
-    Given data as a list of levels (each level is a tuple or list of 
-    displacements for each branch), this function computes the cumulative 
-    value per branch (starting from 0) and plots each branch
-    with the tree level mapped to the x-axis and the cumulative value mapped 
-    to the y-axis. This gives a left-to-right tree with branches spanning up 
-    (positive) and down (negative).
-    
-    Parameters:
-        data (list of tuple/list): Each element represents a tree level.
-                                   It is assumed every level has the same length.
-    """
-    
-    # Convert data to a NumPy array with shape (n_levels, n_branches)
-    data = np.array(data)
-    n_levels, n_branches = data.shape
-
-    # Compute cumulative sums along each branch.
-    # Each branch starts at 0 at level 0.
-    cum = np.zeros((n_levels + 1, n_branches))
-    for i in range(n_levels):
-        cum[i + 1, :] = cum[i, :] + data[i, :]
-    
-    plt.figure(figsize=(12, 8))
-    
-    # Plot each branch as a line. For branch j:
-    #   - x coordinates are the tree levels (0 to n_levels)
-    #   - y coordinates are the corresponding cumulative values.
-    for j in range(n_branches):
-        x = np.arange(n_levels + 1)
-        y = cum[:, j]
-        plt.plot(x, y, marker='o', label=f'Branch {j}')
-    
-    plt.title("Horizontal Tree Visualization: Branches Spanning Up and Down", fontsize=14)
-    plt.xlabel("Tree Level (Left = Root)")
-    plt.ylabel("Cumulative Value (Up = Positive, Down = Negative)")
-    
-    # Add a horizontal line at y=0 to emphasize the center.
-    plt.axhline(0, color="gray", linestyle="--")
-    
-    #plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
-    plt.tight_layout()
-    plt.show()
-    
-################################################################################
-# This is the end of TPLOTS Python modules
+#! /usr/bin/python3
+
+r'''############################################################################
+################################################################################
+#
+#
+#	    Tegridy Plots Python Module (TPLOTS)
+#	    Version 1.0
+#
+#	    Project Los Angeles
+#
+#	    Tegridy Code 2025
+#
+#       https://github.com/asigalov61/tegridy-tools
+#
+#
+################################################################################
+#
+#       Copyright 2024 Project Los Angeles / Tegridy Code
+#
+#       Licensed under the Apache License, Version 2.0 (the "License");
+#       you may not use this file except in compliance with the License.
+#       You may obtain a copy of the License at
+#
+#           http://www.apache.org/licenses/LICENSE-2.0
+#
+#       Unless required by applicable law or agreed to in writing, software
+#       distributed under the License is distributed on an "AS IS" BASIS,
+#       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#       See the License for the specific language governing permissions and
+#       limitations under the License.
+#
+################################################################################
+################################################################################
+#
+#       Critical dependencies
+#
+#       !pip install numpy==1.24.4
+#       !pip install scipy
+#       !pip install matplotlib
+#       !pip install networkx
+#       !pip3 install scikit-learn
+#
+################################################################################
+#
+#       Future critical dependencies
+#
+#       !pip install umap-learn
+#       !pip install alphashape
+#
+################################################################################
+'''
+
+################################################################################
+# Modules imports
+################################################################################
+
+import os
+from collections import Counter
+from itertools import groupby
+
+import numpy as np
+
+import networkx as nx
+
+from sklearn.manifold import TSNE
+from sklearn import metrics
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.decomposition import PCA
+
+from scipy.ndimage import zoom
+from scipy.spatial import distance_matrix
+from scipy.sparse.csgraph import minimum_spanning_tree
+from scipy.stats import zscore
+
+import matplotlib.pyplot as plt
+from PIL import Image
+
+################################################################################
+# Constants
+################################################################################
+
+ALL_CHORDS_FULL = [[0], [0, 3], [0, 3, 5], [0, 3, 5, 8], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6],
+                  [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 10], [0, 3, 8], [0, 3, 9],
+                  [0, 3, 10], [0, 4], [0, 4, 6], [0, 4, 6, 9], [0, 4, 6, 10], [0, 4, 7],
+                  [0, 4, 7, 10], [0, 4, 8], [0, 4, 9], [0, 4, 10], [0, 5], [0, 5, 8], [0, 5, 9],
+                  [0, 5, 10], [0, 6], [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 10], [0, 8], [0, 9],
+                  [0, 10], [1], [1, 4], [1, 4, 6], [1, 4, 6, 9], [1, 4, 6, 10], [1, 4, 6, 11],
+                  [1, 4, 7], [1, 4, 7, 10], [1, 4, 7, 11], [1, 4, 8], [1, 4, 8, 11], [1, 4, 9],
+                  [1, 4, 10], [1, 4, 11], [1, 5], [1, 5, 8], [1, 5, 8, 11], [1, 5, 9],
+                  [1, 5, 10], [1, 5, 11], [1, 6], [1, 6, 9], [1, 6, 10], [1, 6, 11], [1, 7],
+                  [1, 7, 10], [1, 7, 11], [1, 8], [1, 8, 11], [1, 9], [1, 10], [1, 11], [2],
+                  [2, 5], [2, 5, 8], [2, 5, 8, 11], [2, 5, 9], [2, 5, 10], [2, 5, 11], [2, 6],
+                  [2, 6, 9], [2, 6, 10], [2, 6, 11], [2, 7], [2, 7, 10], [2, 7, 11], [2, 8],
+                  [2, 8, 11], [2, 9], [2, 10], [2, 11], [3], [3, 5], [3, 5, 8], [3, 5, 8, 11],
+                  [3, 5, 9], [3, 5, 10], [3, 5, 11], [3, 6], [3, 6, 9], [3, 6, 10], [3, 6, 11],
+                  [3, 7], [3, 7, 10], [3, 7, 11], [3, 8], [3, 8, 11], [3, 9], [3, 10], [3, 11],
+                  [4], [4, 6], [4, 6, 9], [4, 6, 10], [4, 6, 11], [4, 7], [4, 7, 10], [4, 7, 11],
+                  [4, 8], [4, 8, 11], [4, 9], [4, 10], [4, 11], [5], [5, 8], [5, 8, 11], [5, 9],
+                  [5, 10], [5, 11], [6], [6, 9], [6, 10], [6, 11], [7], [7, 10], [7, 11], [8],
+                  [8, 11], [9], [10], [11]]
+
+################################################################################
+
+CHORDS_TYPES = ['WHITE', 'BLACK', 'UNKNOWN', 'MIXED WHITE', 'MIXED BLACK', 'MIXED GRAY']
+
+################################################################################
+
+WHITE_NOTES = [0, 2, 4, 5, 7, 9, 11]
+
+################################################################################
+
+BLACK_NOTES = [1, 3, 6, 8, 10]
+
+################################################################################
+# Helper functions
+################################################################################
+
+def tones_chord_type(tones_chord, 
+                     return_chord_type_index=True,
+                     ):
+
+  """
+  Returns tones chord type
+  """
+
+  WN = WHITE_NOTES
+  BN = BLACK_NOTES
+  MX = WHITE_NOTES + BLACK_NOTES
+
+
+  CHORDS = ALL_CHORDS_FULL
+
+  tones_chord = sorted(tones_chord)
+
+  ctype = 'UNKNOWN'
+
+  if tones_chord in CHORDS:
+
+    if sorted(set(tones_chord) & set(WN)) == tones_chord:
+      ctype = 'WHITE'
+
+    elif sorted(set(tones_chord) & set(BN)) == tones_chord:
+      ctype = 'BLACK'
+
+    if len(tones_chord) > 1 and sorted(set(tones_chord) & set(MX)) == tones_chord:
+
+      if len(sorted(set(tones_chord) & set(WN))) == len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED GRAY'
+
+      elif len(sorted(set(tones_chord) & set(WN))) > len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED WHITE'
+
+      elif len(sorted(set(tones_chord) & set(WN))) < len(sorted(set(tones_chord) & set(BN))):
+        ctype = 'MIXED BLACK'
+
+  if return_chord_type_index:
+    return CHORDS_TYPES.index(ctype)
+
+  else:
+    return ctype
+
+###################################################################################
+
+def tone_type(tone, 
+              return_tone_type_index=True
+              ):
+
+  """
+  Returns tone type
+  """
+
+  tone = tone % 12
+
+  if tone in BLACK_NOTES:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('BLACK')
+    else:
+      return "BLACK"
+
+  else:
+    if return_tone_type_index:
+      return CHORDS_TYPES.index('WHITE')
+    else:
+      return "WHITE"
+
+###################################################################################
+
+def find_closest_points(points, return_points=True):
+
+  """
+  Find closest 2D points
+  """
+
+  coords = np.array(points)
+
+  num_points = coords.shape[0]
+  closest_matches = np.zeros(num_points, dtype=int)
+  distances = np.zeros((num_points, num_points))
+
+  for i in range(num_points):
+      for j in range(num_points):
+          if i != j:
+              distances[i, j] = np.linalg.norm(coords[i] - coords[j])
+          else:
+              distances[i, j] = np.inf
+
+  closest_matches = np.argmin(distances, axis=1)
+  
+  if return_points:
+    points_matches = coords[closest_matches].tolist()
+    return points_matches
+  
+  else:
+    return closest_matches.tolist()
+
+################################################################################
+
+def reduce_dimensionality_tsne(list_of_valies,
+                                n_comp=2,
+                                n_iter=5000,
+                                verbose=True
+                              ):
+
+  """
+  Reduces the dimensionality of the values using t-SNE.
+  """
+
+  vals = np.array(list_of_valies)
+
+  tsne = TSNE(n_components=n_comp,
+              n_iter=n_iter,
+              verbose=verbose)
+
+  reduced_vals = tsne.fit_transform(vals)
+
+  return reduced_vals.tolist()
+
+################################################################################
+
+def compute_mst_edges(similarity_scores_list):
+
+  """
+  Computes the Minimum Spanning Tree (MST) edges based on the similarity scores.
+  """
+  
+  num_tokens = len(similarity_scores_list[0])
+
+  graph = nx.Graph()
+
+  for i in range(num_tokens):
+      for j in range(i + 1, num_tokens):
+          weight = 1 - similarity_scores_list[i][j]
+          graph.add_edge(i, j, weight=weight)
+
+  mst = nx.minimum_spanning_tree(graph)
+
+  mst_edges = list(mst.edges(data=False))
+
+  return mst_edges
+
+################################################################################
+
+def square_binary_matrix(binary_matrix, 
+                         matrix_size=128,
+                         interpolation_order=5,
+                         return_square_matrix_points=False
+                         ):
+
+  """
+  Reduces an arbitrary binary matrix to a square binary matrix
+  """
+
+  zoom_factors = (matrix_size / len(binary_matrix), 1)
+
+  resized_matrix = zoom(binary_matrix, zoom_factors, order=interpolation_order)
+
+  resized_matrix = (resized_matrix > 0.5).astype(int)
+
+  final_matrix = np.zeros((matrix_size, matrix_size), dtype=int)
+  final_matrix[:, :resized_matrix.shape[1]] = resized_matrix
+
+  points = np.column_stack(np.where(final_matrix == 1)).tolist()
+
+  if return_square_matrix_points:
+    return points
+
+  else:
+    return resized_matrix
+
+################################################################################
+
+def square_matrix_points_colors(square_matrix_points):
+
+  """
+  Returns colors for square matrix points
+  """
+
+  cmap = generate_colors(12)
+
+  chords = []
+  chords_dict = set()
+  counts = []
+
+  for k, v in groupby(square_matrix_points, key=lambda x: x[0]):
+    pgroup = [vv[1] for vv in v]
+    chord = sorted(set(pgroup))
+    tchord = sorted(set([p % 12 for p in chord]))
+    chords_dict.add(tuple(tchord))
+    chords.append(tuple(tchord))
+    counts.append(len(pgroup))
+
+  chords_dict = sorted(chords_dict)
+
+  colors = []
+
+  for i, c in enumerate(chords):
+    colors.extend([cmap[round(sum(c) / len(c))]] * counts[i])
+
+  return colors
+
+################################################################################
+
+def hsv_to_rgb(h, s, v):
+
+  if s == 0.0:
+      return v, v, v
+
+  i = int(h*6.0)
+  f = (h*6.0) - i
+  p = v*(1.0 - s)
+  q = v*(1.0 - s*f)
+  t = v*(1.0 - s*(1.0-f))
+  i = i%6
+  
+  return [(v, t, p), (q, v, p), (p, v, t), (p, q, v), (t, p, v), (v, p, q)][i]
+
+################################################################################
+
+def generate_colors(n):
+  return [hsv_to_rgb(i/n, 1, 1) for i in range(n)]
+
+################################################################################
+
+def add_arrays(a, b):
+  return [sum(pair) for pair in zip(a, b)]
+
+################################################################################
+
+def calculate_similarities(lists_of_values, metric='cosine'):
+  return metrics.pairwise_distances(lists_of_values, metric=metric).tolist()
+
+################################################################################
+
+def get_tokens_embeddings(x_transformer_model):
+  return x_transformer_model.net.token_emb.emb.weight.detach().cpu().tolist()
+
+################################################################################
+
+def minkowski_distance_matrix(X, p=3):
+
+  X = np.array(X)
+
+  n = X.shape[0]
+  dist_matrix = np.zeros((n, n))
+
+  for i in range(n):
+      for j in range(n):
+          dist_matrix[i, j] = np.sum(np.abs(X[i] - X[j])**p)**(1/p)
+
+  return dist_matrix.tolist()
+
+################################################################################
+
+def robust_normalize(values):
+
+  values = np.array(values)
+  q1 = np.percentile(values, 25)
+  q3 = np.percentile(values, 75)
+  iqr = q3 - q1
+
+  filtered_values = values[(values >= q1 - 1.5 * iqr) & (values <= q3 + 1.5 * iqr)]
+
+  min_val = np.min(filtered_values)
+  max_val = np.max(filtered_values)
+  normalized_values = (values - min_val) / (max_val - min_val)
+
+  normalized_values = np.clip(normalized_values, 0, 1)
+
+  return normalized_values.tolist()
+
+################################################################################
+
+def min_max_normalize(values):
+
+  scaler = MinMaxScaler()
+
+  return scaler.fit_transform(values).tolist()
+
+################################################################################
+
+def remove_points_outliers(points, z_score_threshold=3):
+
+  points = np.array(points)
+
+  z_scores = np.abs(zscore(points, axis=0))
+
+  return points[(z_scores < z_score_threshold).all(axis=1)].tolist()
+
+################################################################################
+
+def generate_labels(lists_of_values, 
+                    return_indices_labels=False
+                    ):
+
+  ordered_indices = list(range(len(lists_of_values)))
+  ordered_indices_labels = [str(i) for i in ordered_indices]
+  ordered_values_labels = [str(lists_of_values[i]) for i in ordered_indices]
+
+  if return_indices_labels:
+    return ordered_indices_labels
+  
+  else:
+    return ordered_values_labels
+
+################################################################################
+
+def reduce_dimensionality_pca(list_of_values, n_components=2):
+
+  """
+  Reduces the dimensionality of the values using PCA.
+  """
+
+  pca = PCA(n_components=n_components)
+  pca_data = pca.fit_transform(list_of_values)
+  
+  return pca_data.tolist()
+
+def reduce_dimensionality_simple(list_of_values, 
+                                 return_means=True,
+                                 return_std_devs=True,
+                                 return_medians=False,
+                                 return_vars=False
+                                 ):
+  
+  '''
+  Reduces dimensionality of the values in a simple way
+  '''
+
+  array = np.array(list_of_values)
+  results = []
+
+  if return_means:
+      means = np.mean(array, axis=1)
+      results.append(means)
+
+  if return_std_devs:
+      std_devs = np.std(array, axis=1)
+      results.append(std_devs)
+
+  if return_medians:
+      medians = np.median(array, axis=1)
+      results.append(medians)
+
+  if return_vars:
+      vars = np.var(array, axis=1)
+      results.append(vars)
+
+  merged_results = np.column_stack(results)
+  
+  return merged_results.tolist()
+
+################################################################################
+
+def reduce_dimensionality_2d_distance(list_of_values, p=5):
+
+  '''
+  Reduces the dimensionality of the values using 2d distance
+  '''
+
+  values = np.array(list_of_values)
+
+  dist_matrix = distance_matrix(values, values, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  points = []
+
+  for i in range(len(values)):
+      for j in range(len(values)):
+          if mst[i, j] > 0:
+              points.append([i, j])
+
+  return points
+
+################################################################################
+
+def normalize_to_range(values, n):
+    
+  min_val = min(values)
+  max_val = max(values)
+  
+  range_val = max_val - min_val
+  
+  normalized_values = [((value - min_val) / range_val * 2 * n) - n for value in values]
+  
+  return normalized_values
+
+################################################################################
+
+def reduce_dimensionality_simple_pca(list_of_values, n_components=2):
+
+  '''
+  Reduces the dimensionality of the values using simple PCA
+  '''
+
+  reduced_values = []
+
+  for l in list_of_values:
+
+    norm_values = [round(v * len(l)) for v in normalize_to_range(l, (n_components+1) // 2)]
+
+    pca_values = Counter(norm_values).most_common()
+    pca_values = [vv[0] / len(l) for vv in pca_values]
+    pca_values = pca_values[:n_components]
+    pca_values = pca_values + [0] * (n_components - len(pca_values))
+
+    reduced_values.append(pca_values)
+
+  return reduced_values
+
+################################################################################
+
+def filter_and_replace_values(list_of_values, 
+                              threshold, 
+                              replace_value, 
+                              replace_above_threshold=False
+                              ):
+
+  array = np.array(list_of_values)
+
+  modified_array = np.copy(array)
+  
+  if replace_above_threshold:
+    modified_array[modified_array > threshold] = replace_value
+  
+  else:
+    modified_array[modified_array < threshold] = replace_value
+  
+  return modified_array.tolist()
+
+################################################################################
+
+def find_shortest_constellation_path(points, 
+                                     start_point_idx, 
+                                     end_point_idx,
+                                     p=5,
+                                     return_path_length=False,
+                                     return_path_points=False,
+                                     ):
+
+    """
+    Finds the shortest path between two points of the points constellation
+    """
+
+    points = np.array(points)
+
+    dist_matrix = distance_matrix(points, points, p=p)
+
+    mst = minimum_spanning_tree(dist_matrix).toarray()
+
+    G = nx.Graph()
+
+    for i in range(len(points)):
+        for j in range(len(points)):
+            if mst[i, j] > 0:
+                G.add_edge(i, j, weight=mst[i, j])
+
+    path = nx.shortest_path(G, 
+                            source=start_point_idx, 
+                            target=end_point_idx, 
+                            weight='weight'
+                            )
+    
+    path_length = nx.shortest_path_length(G, 
+                                          source=start_point_idx, 
+                                          target=end_point_idx, 
+                                          weight='weight')
+        
+    path_points = points[np.array(path)].tolist()
+
+
+    if return_path_points:
+      return path_points
+
+    if return_path_length:
+      return path_length
+
+    return path
+
+################################################################################
+# Core functions
+################################################################################
+
+def plot_ms_SONG(ms_song,
+                  preview_length_in_notes=0,
+                  block_lines_times_list = None,
+                  plot_title='ms Song',
+                  max_num_colors=129, 
+                  drums_color_num=128, 
+                  plot_size=(11,4), 
+                  note_height = 0.75,
+                  show_grid_lines=False,
+                  return_plt = False,
+                  timings_multiplier=1,
+                  save_plt='',
+                  save_only_plt_image=True,
+                  save_transparent=False
+                  ):
+
+  '''ms SONG plot'''
+
+  notes = [s for s in ms_song if s[0] == 'note']
+
+  if (len(max(notes, key=len)) != 7) and (len(min(notes, key=len)) != 7):
+    print('The song notes do not have patches information')
+    print('Ploease add patches to the notes in the song')
+
+  else:
+
+    start_times = [(s[1] * timings_multiplier) / 1000 for s in notes]
+    durations = [(s[2]  * timings_multiplier) / 1000 for s in notes]
+    pitches = [s[4] for s in notes]
+    patches = [s[6] for s in notes]
+
+    colors = generate_colors(max_num_colors)
+    colors[drums_color_num] = (1, 1, 1)
+
+    pbl = (notes[preview_length_in_notes][1] * timings_multiplier) / 1000
+
+    fig, ax = plt.subplots(figsize=plot_size)
+
+    for start, duration, pitch, patch in zip(start_times, durations, pitches, patches):
+        rect = plt.Rectangle((start, pitch), duration, note_height, facecolor=colors[patch])
+        ax.add_patch(rect)
+
+    ax.set_xlim([min(start_times), max(add_arrays(start_times, durations))])
+    ax.set_ylim([min(pitches)-1, max(pitches)+1])
+
+    ax.set_facecolor('black')
+    fig.patch.set_facecolor('white')
+
+    if preview_length_in_notes > 0:
+      ax.axvline(x=pbl, c='white')
+
+    if block_lines_times_list:
+      for bl in block_lines_times_list:
+        ax.axvline(x=bl, c='white')
+           
+    if show_grid_lines:
+      ax.grid(color='white')
+
+    plt.xlabel('Time (s)', c='black')
+    plt.ylabel('MIDI Pitch', c='black')
+
+    plt.title(plot_title)
+
+    if save_plt != '':
+      if save_only_plt_image:
+        plt.axis('off')
+        plt.title('')
+        plt.savefig(save_plt, 
+                    transparent=save_transparent, 
+                    bbox_inches='tight', 
+                    pad_inches=0, 
+                    facecolor='black'
+                    )
+        plt.close()
+      
+      else:
+        plt.savefig(save_plt)
+        plt.close()
+
+    if return_plt:
+      return fig
+
+    plt.show()
+    plt.close()
+
+################################################################################
+
+def plot_square_matrix_points(list_of_points,
+                              list_of_points_colors,
+                              plot_size=(7, 7),
+                              point_size = 10,
+                              show_grid_lines=False,
+                              plot_title = 'Square Matrix Points Plot',
+                              return_plt=False,
+                              save_plt='',
+                              save_only_plt_image=True,
+                              save_transparent=False
+                              ):
+
+  '''Square matrix points plot'''
+
+  fig, ax = plt.subplots(figsize=plot_size)
+
+  ax.set_facecolor('black')
+
+  if show_grid_lines:
+    ax.grid(color='white')
+
+  plt.xlabel('Time Step', c='black')
+  plt.ylabel('MIDI Pitch', c='black')
+
+  plt.title(plot_title)
+
+  plt.scatter([p[0] for p in list_of_points], 
+              [p[1] for p in list_of_points], 
+              c=list_of_points_colors, 
+              s=point_size
+              )
+
+  if save_plt != '':
+    if save_only_plt_image:
+      plt.axis('off')
+      plt.title('')
+      plt.savefig(save_plt, 
+                  transparent=save_transparent, 
+                  bbox_inches='tight', 
+                  pad_inches=0, 
+                  facecolor='black'
+                  )
+      plt.close()
+    
+    else:
+      plt.savefig(save_plt)
+      plt.close()
+
+  if return_plt:
+    return fig
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_cosine_similarities(lists_of_values,
+                             plot_size=(7, 7),
+                             save_plot=''
+                            ):
+
+  """
+  Cosine similarities plot
+  """
+
+  cos_sim = metrics.pairwise_distances(lists_of_values, metric='cosine')
+
+  plt.figure(figsize=plot_size)
+
+  plt.imshow(cos_sim, cmap="inferno", interpolation="nearest")
+
+  im_ratio = cos_sim.shape[0] / cos_sim.shape[1]
+
+  plt.colorbar(fraction=0.046 * im_ratio, pad=0.04)
+
+  plt.xlabel("Index")
+  plt.ylabel("Index")
+
+  plt.tight_layout()
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+  plt.close()
+
+################################################################################
+
+def plot_points_with_mst_lines(points, 
+                               points_labels, 
+                               points_mst_edges,
+                               plot_size=(20, 20),
+                               labels_size=24,
+                               save_plot=''
+                               ):
+
+  """
+  Plots 2D points with labels and MST lines.
+  """
+
+  plt.figure(figsize=plot_size)
+
+  for i, label in enumerate(points_labels):
+      plt.scatter(points[i][0], points[i][1])
+      plt.annotate(label, (points[i][0], points[i][1]), fontsize=labels_size)
+
+  for edge in points_mst_edges:
+      i, j = edge
+      plt.plot([points[i][0], points[j][0]], [points[i][1], points[j][1]], 'k-', alpha=0.5)
+
+  plt.title('Points Map with MST Lines', fontsize=labels_size)
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def plot_points_constellation(points, 
+                              points_labels,
+                              p=5,                              
+                              plot_size=(15, 15),
+                              labels_size=12,
+                              show_grid=False,
+                              save_plot=''
+                              ):
+
+  """
+  Plots 2D points constellation
+  """
+
+  points = np.array(points)
+
+  dist_matrix = distance_matrix(points, points, p=p)
+
+  mst = minimum_spanning_tree(dist_matrix).toarray()
+
+  plt.figure(figsize=plot_size)
+
+  plt.scatter(points[:, 0], points[:, 1], color='blue')
+
+  for i, label in enumerate(points_labels):
+      plt.annotate(label, (points[i, 0], points[i, 1]), 
+                   textcoords="offset points", 
+                   xytext=(0, 10), 
+                   ha='center',
+                   fontsize=labels_size
+                   )
+
+  for i in range(len(points)):
+      for j in range(len(points)):
+          if mst[i, j] > 0:
+              plt.plot([points[i, 0], points[j, 0]], [points[i, 1], points[j, 1]], 'k--')
+
+  plt.xlabel('X-axis', fontsize=labels_size)
+  plt.ylabel('Y-axis', fontsize=labels_size)
+  plt.title('2D Coordinates with Minimum Spanning Tree', fontsize=labels_size)
+
+  plt.grid(show_grid)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+
+################################################################################
+
+def binary_matrix_to_images(matrix, 
+                            step,
+                            overlap,
+                            output_folder='./Dataset/', 
+                            output_img_prefix='image', 
+                            output_img_ext='.png',
+                            save_to_array=False,
+                            verbose=True
+                            ):
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(matrix, dtype=np.uint8)
+    
+    image_array = []
+    
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+       
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        img = Image.fromarray(submatrix * 255).convert('1')
+        
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+  
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_binary_matrix(list_of_images):
+
+    image_array = np.array(list_of_images)
+   
+    original_matrix = []
+    
+    for img in image_array:
+
+        submatrix = np.array(img)
+        original_matrix.extend(submatrix.tolist())
+    
+    return original_matrix
+
+################################################################################
+
+def square_image_matrix(image_matrix,
+                        matrix_size=128,
+                        num_pca_components=5,
+                        filter_out_zero_rows=False,
+                        return_square_matrix_points=False
+                        ):
+
+  """
+  Reduces an arbitrary image matrix to a square image matrix
+  """
+
+  matrix = np.array(image_matrix)
+
+  if filter_out_zero_rows:
+    matrix = matrix[~np.all(matrix == 0, axis=1)]
+
+  target_rows = matrix_size
+
+  rows_per_group = matrix.shape[0] // target_rows
+
+  compressed_matrix = np.zeros((target_rows, matrix.shape[1]), dtype=np.int32)
+
+  for i in range(target_rows):
+      start_row = i * rows_per_group
+      end_row = (i + 1) * rows_per_group
+      group = matrix[start_row:end_row, :]
+      
+      pca = PCA(n_components=num_pca_components)
+      pca.fit(group)
+      
+      principal_component = np.mean(pca.components_, axis=0)
+      contributions = np.dot(group, principal_component)
+      selected_row_index = np.argmax(contributions)
+      
+      compressed_matrix[i, :] = group[selected_row_index, :]
+
+  if return_square_matrix_points:
+    filtered_matrix = compressed_matrix[~np.all(compressed_matrix == 0, axis=1)]
+
+    row_indexes, col_indexes = np.where(filtered_matrix != 0)
+    points = np.column_stack((row_indexes, filtered_matrix[row_indexes, col_indexes])).tolist()
+
+    return points
+
+  else:
+    return compressed_matrix.tolist()
+
+################################################################################
+
+def image_matrix_to_images(image_matrix,
+                           step,
+                           overlap,
+                           num_img_channels=3,
+                           output_folder='./Dataset/',
+                           output_img_prefix='image',
+                           output_img_ext='.png',
+                           save_to_array=False,
+                           verbose=True
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    if not save_to_array:
+
+      if verbose:
+        print('=' * 70)
+        print('Checking output folder dir...')
+
+      os.makedirs(os.path.dirname(output_folder), exist_ok=True)
+
+      if verbose:
+        print('Done!')
+
+    if verbose:
+      print('=' * 70)
+      print('Writing images...')
+
+    matrix = np.array(image_matrix)
+
+    image_array = []
+
+    for i in range(0, max(1, matrix.shape[0]), overlap):
+
+        submatrix = matrix[i:i+step, :]
+
+        if submatrix.shape[0] < 128:
+          zeros_array = np.zeros((128-submatrix.shape[0], 128))
+          submatrix = np.vstack((submatrix, zeros_array))
+
+        if n_mat_channels == 3:
+
+          r = (submatrix // (256*256)) % 256
+          g = (submatrix // 256) % 256
+          b = submatrix % 256
+
+          rgb_image = np.stack((r, g, b), axis=-1).astype(np.uint8)
+          img = Image.fromarray(rgb_image, 'RGB')
+
+        else:
+          grayscale_image = submatrix.astype(np.uint8)
+          img = Image.fromarray(grayscale_image, 'L')
+
+        if save_to_array:
+          image_array.append(np.array(img))
+
+        else:
+          img.save(output_folder + output_img_prefix + '_' + str(matrix.shape[1]) + '_' + str(i).zfill(7) + output_img_ext)
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved', (matrix.shape[0] // min(step, overlap))+1, 'imges!')
+      print('=' * 70)
+
+    if save_to_array:
+        return np.array(image_array).tolist()
+
+################################################################################
+
+def images_to_image_matrix(list_of_images,
+                           num_img_channels=3
+                           ):
+
+    if num_img_channels > 1:
+      n_mat_channels = 3
+
+    else:
+      n_mat_channels = 1
+
+    image_array = np.array(list_of_images)
+
+    original_matrix = []
+
+    for img in image_array:
+
+      if num_img_channels == 3:
+
+        rgb_array = np.array(img)
+
+        matrix = (rgb_array[..., 0].astype(np.int64) * 256*256 +
+                  rgb_array[..., 1].astype(np.int64) * 256 +
+                  rgb_array[..., 2].astype(np.int64))
+
+      else:
+        matrix = np.array(img)
+
+      original_matrix.extend(matrix)
+
+    return original_matrix
+
+################################################################################
+
+def square_matrix_to_RGB_matrix(square_matrix):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  r = (sq_matrix // (256 ** 2)) % 256
+  g = (sq_matrix // 256) % 256
+  b = sq_matrix % 256
+
+  rgb_array = np.stack((r, g, b), axis=-1)
+
+  return rgb_array.tolist()
+
+################################################################################
+
+def upsample_square_matrix(square_matrix, upsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  scaling_array = np.ones((upsampling_factor, upsampling_factor))
+  scaled_array = np.kron(sq_matrix, scaling_array)
+  scaled_array = scaled_array.astype('int')
+
+  return scaled_array.tolist()
+
+################################################################################
+
+def downsample_square_matrix(square_matrix, downsampling_factor=4):
+
+  smatrix = np.array(square_matrix)
+  sq_matrix = smatrix[:smatrix.shape[1]]
+
+  dmatrix = sq_matrix[::downsampling_factor, ::downsampling_factor]
+  dmatrix = dmatrix.astype('int')
+
+  return dmatrix.tolist()
+
+################################################################################
+
+def plot_parsons_code(parsons_code, 
+                      start_pitch=60, 
+                      return_plot_dict=False, 
+                      return_plot_string=False,
+                      plot_size=(10, 10),
+                      labels_size=16,
+                      save_plot=''
+                      ):
+  
+  '''
+  Plot parsons code string
+  '''
+
+  if parsons_code[0] != "*":
+      return None
+
+  contour_dict = {}
+  pitch = 0
+  index = 0
+
+  maxp = 0
+  minp = 0
+
+  contour_dict[(pitch, index)] = "*"
+
+  for point in parsons_code:
+      if point == "R":
+          index += 1
+          contour_dict[(pitch, index)] = "-"
+
+          index += 1
+          contour_dict[(pitch, index)] = "*"
+          
+      elif point == "U":
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "/"
+
+          index += 1
+          pitch -= 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch < maxp:
+              maxp = pitch
+
+      elif point == "D":
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "\\"
+
+          index += 1
+          pitch += 1
+          contour_dict[(pitch, index)] = "*"
+
+          if pitch > minp:
+              minp = pitch
+
+  if return_plot_dict:
+    return contour_dict
+  
+  if return_plot_string:
+
+    plot_string = ''
+
+    for pitch in range(maxp, minp+1):
+        line = [" " for _ in range(index + 1)]
+        for pos in range(index + 1):
+            if (pitch, pos) in contour_dict:
+                line[pos] = contour_dict[(pitch, pos)]
+
+        plot_string = "".join(line)
+
+    return plot_string
+
+  labels = []
+  pitches = []
+  positions = []
+  cur_pitch = start_pitch
+  pitch_idx = 0
+
+  for k, v in contour_dict.items():
+
+    if v != '*':
+
+      pitches.append(cur_pitch)
+      positions.append(pitch_idx)
+
+      if v == '/':
+        cur_pitch += 1
+        labels.append('U')
+      
+      elif v == '\\':
+        cur_pitch -= 1
+        labels.append('D')
+
+      elif v == '-':
+        labels.append('R')
+
+      pitch_idx += 1
+
+  plt.figure(figsize=plot_size)
+
+  
+  plt.plot(pitches)
+
+  for i, point in enumerate(zip(positions, pitches)):
+    plt.annotate(labels[i], point, fontsize=labels_size)
+  
+
+  plt.title('Parsons Code with Labels', fontsize=labels_size)
+  plt.xlabel('Position', fontsize=labels_size)
+  plt.ylabel('Pitch', fontsize=labels_size)
+
+  if save_plot != '':
+    plt.savefig(save_plot, bbox_inches="tight")
+    plt.close()
+
+  plt.show()
+
+  plt.close()
+  
+################################################################################
+
+def plot_tokens_embeddings_constellation(tokens_embeddings,
+                                         start_token,
+                                         end_token,
+                                         plot_size=(10, 10),
+                                         labels_size=12,
+                                         show_grid=False,
+                                         save_plot=''):
+    
+    """
+    Plots token embeddings constellation using MST and graph layout
+    without dimensionality reduction.
+    """
+
+    distance_matrix = metrics.pairwise_distances(tokens_embeddings[start_token:end_token], metric='cosine')
+    
+    token_labels = [str(i) for i in range(start_token, end_token)]
+
+    mst = minimum_spanning_tree(distance_matrix).toarray()
+    
+    n = distance_matrix.shape[0]
+    G = nx.Graph()
+    
+    for i in range(n):
+        for j in range(n):
+            if mst[i, j] > 0:
+                weight = 1 / (distance_matrix[i, j] + 1e-8)
+                G.add_edge(i, j, weight=weight)
+    
+    pos = nx.kamada_kawai_layout(G, weight='weight')
+    
+    points = np.array([pos[i] for i in range(n)])
+    
+    plt.figure(figsize=plot_size)
+    plt.scatter(points[:, 0], points[:, 1], color='blue')
+    
+    for i, label in enumerate(token_labels):
+        plt.annotate(label, (points[i, 0], points[i, 1]),
+                     textcoords="offset points",
+                     xytext=(0, 10),
+                     ha='center',
+                     fontsize=labels_size)
+    
+    for i in range(n):
+        for j in range(n):
+            if mst[i, j] > 0:
+                plt.plot([points[i, 0], points[j, 0]],
+                         [points[i, 1], points[j, 1]],
+                         'k--', alpha=0.5)
+    
+    plt.title('Token Embeddings Constellation with MST', fontsize=labels_size)
+    plt.grid(show_grid)
+    
+    if save_plot:
+        plt.savefig(save_plot, bbox_inches="tight")
+        plt.close()
+        
+    else:
+        plt.show()
+        
+    plt.close()
+    
+################################################################################
+
+def find_token_path(tokens_embeddings, 
+                    start_token, 
+                    end_token, 
+                    verbose=False
+                   ):
+    
+    """
+    Finds the path of tokens between start_token and end_token using
+    the Minimum Spanning Tree (MST) derived from the distance matrix.
+    """
+
+    distance_matrix = metrics.pairwise_distances(tokens_embeddings, metric='cosine')
+    
+    token_labels = [str(i) for i in range(len(distance_matrix))]
+    
+    if verbose:
+        print('Total number of tokens:', len(distance_matrix))
+    
+    mst = minimum_spanning_tree(distance_matrix).toarray()
+    
+    n = distance_matrix.shape[0]
+    G = nx.Graph()
+    
+    for i in range(n):
+        for j in range(n):
+            if mst[i, j] > 0:
+                weight = 1 / (distance_matrix[i, j] + 1e-8)
+                G.add_edge(i, j, weight=weight)
+    
+    try:
+        start_idx = token_labels.index(str(start_token))
+        end_idx = token_labels.index(str(end_token))
+        
+    except ValueError:
+        raise ValueError("Start or end token not found in the provided token labels.")
+    
+    path_indices = nx.shortest_path(G, source=start_idx, target=end_idx)
+    
+    token_path = [int(token_labels[idx]) for idx in path_indices]
+    
+    return token_path
+
+################################################################################
+# [WIP] Future dev functions
+################################################################################
+
+'''
+import umap
+
+def reduce_dimensionality_umap(list_of_values,
+                               n_comp=2,
+                               n_neighbors=15,
+                               ):
+
+  """
+  Reduces the dimensionality of the values using UMAP.
+  """
+
+  vals = np.array(list_of_values)
+
+  umap_reducer = umap.UMAP(n_components=n_comp,
+                           n_neighbors=n_neighbors,
+                           n_epochs=5000,
+                           verbose=True
+                           )
+
+  reduced_vals = umap_reducer.fit_transform(vals)
+
+  return reduced_vals.tolist()
+'''
+
+################################################################################
+
+'''
+import alphashape
+from shapely.geometry import Point
+from matplotlib.tri import Triangulation, LinearTriInterpolator
+from scipy.stats import zscore
+
+#===============================================================================
+
+coordinates = points
+
+dist_matrix = minkowski_distance_matrix(coordinates, p=3)  # You can change the value of p as needed
+
+# Centering matrix
+n = dist_matrix.shape[0]
+H = np.eye(n) - np.ones((n, n)) / n
+
+# Apply double centering
+B = -0.5 * H @ dist_matrix**2 @ H
+
+# Eigen decomposition
+eigvals, eigvecs = np.linalg.eigh(B)
+
+# Sort eigenvalues and eigenvectors
+idx = np.argsort(eigvals)[::-1]
+eigvals = eigvals[idx]
+eigvecs = eigvecs[:, idx]
+
+# Select the top 2 eigenvectors
+X_transformed = eigvecs[:, :2] * np.sqrt(eigvals[:2])
+
+#===============================================================================
+
+src_points = X_transformed
+src_values = np.array([[p[1]] for p in points]) #np.random.rand(X_transformed.shape[0])
+
+#===============================================================================
+
+# Normalize the points to the range [0, 1]
+scaler = MinMaxScaler()
+points_normalized = scaler.fit_transform(src_points)
+
+values_normalized = custom_normalize(src_values)
+
+# Remove outliers based on z-score
+z_scores = np.abs(zscore(points_normalized, axis=0))
+filtered_points = points_normalized[(z_scores < 3).all(axis=1)]
+filtered_values = values_normalized[(z_scores < 3).all(axis=1)]
+
+# Compute the concave hull (alpha shape)
+alpha = 8  # Adjust alpha as needed
+hull = alphashape.alphashape(filtered_points, alpha)
+
+# Create a triangulation
+tri = Triangulation(filtered_points[:, 0], filtered_points[:, 1])
+
+# Interpolate the values on the triangulation
+interpolator = LinearTriInterpolator(tri, filtered_values[:, 0])
+xi, yi = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
+zi = interpolator(xi, yi)
+
+# Mask out points outside the concave hull
+mask = np.array([hull.contains(Point(x, y)) for x, y in zip(xi.flatten(), yi.flatten())])
+zi = np.ma.array(zi, mask=~mask.reshape(zi.shape))
+
+# Plot the filled contour based on the interpolated values
+plt.contourf(xi, yi, zi, levels=50, cmap='viridis')
+
+# Plot the original points
+#plt.scatter(filtered_points[:, 0], filtered_points[:, 1], c=filtered_values, edgecolors='k')
+
+plt.title('Filled Contour Plot with Original Values')
+plt.xlabel('X-axis')
+plt.ylabel('Y-axis')
+plt.colorbar(label='Value')
+plt.show()
+'''
+
+################################################################################
+
+def plot_tree_horizontal(data):
+    
+    """
+    Given data as a list of levels (each level is a tuple or list of 
+    displacements for each branch), this function computes the cumulative 
+    value per branch (starting from 0) and plots each branch
+    with the tree level mapped to the x-axis and the cumulative value mapped 
+    to the y-axis. This gives a left-to-right tree with branches spanning up 
+    (positive) and down (negative).
+    
+    Parameters:
+        data (list of tuple/list): Each element represents a tree level.
+                                   It is assumed every level has the same length.
+    """
+    
+    # Convert data to a NumPy array with shape (n_levels, n_branches)
+    data = np.array(data)
+    n_levels, n_branches = data.shape
+
+    # Compute cumulative sums along each branch.
+    # Each branch starts at 0 at level 0.
+    cum = np.zeros((n_levels + 1, n_branches))
+    for i in range(n_levels):
+        cum[i + 1, :] = cum[i, :] + data[i, :]
+    
+    plt.figure(figsize=(12, 8))
+    
+    # Plot each branch as a line. For branch j:
+    #   - x coordinates are the tree levels (0 to n_levels)
+    #   - y coordinates are the corresponding cumulative values.
+    for j in range(n_branches):
+        x = np.arange(n_levels + 1)
+        y = cum[:, j]
+        plt.plot(x, y, marker='o', label=f'Branch {j}')
+    
+    plt.title("Horizontal Tree Visualization: Branches Spanning Up and Down", fontsize=14)
+    plt.xlabel("Tree Level (Left = Root)")
+    plt.ylabel("Cumulative Value (Up = Positive, Down = Negative)")
+    
+    # Add a horizontal line at y=0 to emphasize the center.
+    plt.axhline(0, color="gray", linestyle="--")
+    
+    #plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.tight_layout()
+    plt.show()
+    
+################################################################################
+# This is the end of TPLOTS Python modules
 ################################################################################

src/midi_to_colab_audio.py

@@ -0,0 +1,475 @@
+r'''#===================================================================================================================
+#
+# MIDI to Colab AUdio Python Module
+#
+# Converts any MIDI file to raw audio which is compatible 
+# with Google Colab or HUgging Face Gradio
+#
+# Version 2.0
+#
+# Includes full source code of MIDI and pyfluidsynth
+# 
+# Original source code for all modules was retrieved on 07/31/2025
+#
+# Project Los Angeles
+# Tegridy Code 2025
+#
+#===================================================================================================================
+#
+# Critical dependencies
+#
+# pip install numpy
+# sudo apt install fluidsynth
+#
+#===================================================================================================================
+# 
+# Example usage:
+#
+# from midi_to_colab_audio import midi_to_colab_audio
+# from IPython.display import display, Audio
+#
+# raw_audio = midi_to_colab_audio('/content/input.mid')
+#
+# display(Audio(raw_audio, rate=16000, normalize=False))
+#
+#===================================================================================================================
+'''
+
+import fluidsynth
+from src import MIDI
+
+#===============================================================================
+
+import numpy as np
+import wave
+
+#===============================================================================
+
+def normalize_audio(audio: np.ndarray,
+                    method: str = 'peak',
+                    target_level_db: float = -1.0,
+                    per_channel: bool = False,
+                    eps: float = 1e-9
+                   ) -> np.ndarray:
+    
+    """
+    Normalize audio to a target dBFS level.
+
+    Parameters
+    ----------
+    audio : np.ndarray
+        Float-valued array in range [-1, 1] with shape (channels, samples)
+        or (samples,) for mono.
+    method : {'peak', 'rms'}
+        - 'peak': scale so that max(|audio|) = target_level_lin  
+        - 'rms' : scale so that RMS(audio) = target_level_lin
+    target_level_db : float
+        Desired output level, in dBFS (0 dBFS = max digital full scale).
+        e.g. -1.0 dBFS means ~0.8913 linear gain.
+    per_channel : bool
+        If True, normalize each channel independently. Otherwise, use a
+        global measure across all channels.
+    eps : float
+        Small constant to avoid division by zero.
+
+    Returns
+    -------
+    normalized : np.ndarray
+        Audio array of same shape, scaled so that levels meet the target.
+    """
+    
+    # Convert target dB to linear gain
+    target_lin = 10 ** (target_level_db / 20.0)
+
+    # Ensure audio is float
+    audio = audio.astype(np.float32)
+
+    # if mono, make it (1, N)
+    if audio.ndim == 1:
+        audio = audio[np.newaxis, :]
+
+    # Choose measurement axis
+    axis = 1 if per_channel else None
+
+    if method == 'peak':
+        # Compute peak per channel or global
+        peak = np.max(np.abs(audio), axis=axis, keepdims=True)
+        peak = np.maximum(peak, eps)
+        scales = target_lin / peak
+
+    elif method == 'rms':
+        # Compute RMS per channel or global
+        rms = np.sqrt(np.mean(audio ** 2, axis=axis, keepdims=True))
+        rms = np.maximum(rms, eps)
+        scales = target_lin / rms
+
+    else:
+        raise ValueError(f"Unsupported method '{method}'; choose 'peak' or 'rms'.")
+
+    # Broadcast scales back to audio shape
+    normalized = audio * scales
+
+    # Clip just in case of rounding
+    return np.clip(normalized, -1.0, 1.0)
+
+#===============================================================================
+
+def midi_opus_to_colab_audio(midi_opus, 
+                              soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2', 
+                              sample_rate=16000, # 44100
+                              volume_level_db=-1,
+                              trim_silence=True,
+                              silence_threshold=0.1,
+                              output_for_gradio=False,
+                              write_audio_to_WAV=''
+                              ):
+
+    if midi_opus[1]:
+
+        ticks_per_beat, *tracks = midi_opus
+        if not tracks:
+            return None
+    
+        # Flatten & convert delta-times to absolute-time
+        events = []
+        for track in tracks:
+            abs_t = 0
+            for name, dt, *data in track:
+                abs_t += dt
+                events.append([name, abs_t, *data])
+        events.sort(key=lambda e: e[1])
+    
+        # Setup FluidSynth
+        fl = fluidsynth.Synth(samplerate=float(sample_rate))
+        sfid = fl.sfload(soundfont_path)
+        for chan in range(16):
+            # channel 9 = percussion GM bank 128
+            fl.program_select(chan, sfid, 128 if chan == 9 else 0, 0)
+    
+        # Playback vars
+        tempo = int((60 / 120) * 1e6)  # default 120bpm
+        last_t = 0
+        ss = np.empty((0, 2), dtype=np.int16)
+    
+        for name, cur_t, *data in events:
+            # compute how many samples have passed since the last event
+            delta_ticks = cur_t - last_t
+            last_t = cur_t
+            dt_seconds = (delta_ticks / ticks_per_beat) * (tempo / 1e6)
+            sample_len = int(dt_seconds * sample_rate)
+            if sample_len > 0:
+                buf = fl.get_samples(sample_len).reshape(-1, 2)
+                ss = np.concatenate([ss, buf], axis=0)
+    
+            # Dispatch every known event
+            if name == "note_on" and data[2] > 0:
+                chan, note, vel = data
+                fl.noteon(chan, note, vel)
+    
+            elif name == "note_off" or (name == "note_on" and data[2] == 0):
+                chan, note = data[:2]
+                fl.noteoff(chan, note)
+    
+            elif name == "patch_change":
+                chan, patch = data[:2]
+                bank = 128 if chan == 9 else 0
+                fl.program_select(chan, sfid, bank, patch)
+    
+            elif name == "control_change":
+                chan, ctrl, val = data[:3]
+                fl.cc(chan, ctrl, val)
+    
+            elif name == "key_after_touch":
+                chan, note, vel = data
+                fl.key_pressure(chan, note, vel)
+    
+            elif name == "channel_after_touch":
+                chan, vel = data
+                fl.channel_pressure(chan, vel)
+    
+            elif name == "pitch_wheel_change":
+                chan, wheel = data
+                fl.pitch_bend(chan, wheel)
+    
+            elif name == "song_position":
+                # song_pos = data[0];  # often not needed for playback
+                pass
+    
+            elif name == "song_select":
+                # song_number = data[0]
+                pass
+    
+            elif name == "tune_request":
+                # typically resets tuning; FS handles internally
+                pass
+    
+            elif name in ("sysex_f0", "sysex_f7"):
+                raw_bytes = data[0]
+                fl.sysex(raw_bytes)
+    
+            # Meta events & others—no direct audio effect, so we skip or log
+            elif name in (
+                "set_tempo",       # handled below
+                "end_track",
+                "text_event", "text_event_08", "text_event_09", "text_event_0a",
+                "text_event_0b", "text_event_0c", "text_event_0d", "text_event_0e", "text_event_0f",
+                "copyright_text_event", "track_name", "instrument_name",
+                "lyric", "marker", "cue_point",
+                "smpte_offset", "time_signature", "key_signature",
+                "sequencer_specific", "raw_meta_event"
+            ):
+                if name == "set_tempo":
+                    tempo = data[0]
+                # else: skip all other meta & text; you could hook in logging here
+                continue
+    
+            else:
+                # unknown event type
+                continue
+    
+        # Cleanup synth
+        fl.delete()
+    
+        if ss.size:
+            maxv = np.abs(ss).max()
+            if maxv:
+                ss = (ss / maxv) * np.iinfo(np.int16).max
+        ss = ss.astype(np.int16)
+    
+        # Optional trimming of trailing silence
+        if trim_silence and ss.size:
+            thresh = np.std(np.abs(ss)) * silence_threshold
+            idx = np.where(np.abs(ss) > thresh)[0]
+            if idx.size:
+                ss = ss[: idx[-1] + 1]
+    
+        # For Gradio you might want raw int16 PCM
+        if output_for_gradio:
+            return ss
+    
+        # Swap to (channels, samples) and normalize for playback
+        ss = ss.T
+        raw_audio = normalize_audio(ss, target_level_db=volume_level_db)
+    
+        # Optionally write WAV to disk
+        if write_audio_to_WAV:
+            wav_name = midi_file.rsplit('.', 1)[0] + '.wav'
+            pcm = np.int16(raw_audio.T / np.max(np.abs(raw_audio)) * 32767)
+            with wave.open(wav_name, 'wb') as wf:
+                wf.setframerate(sample_rate)
+                wf.setsampwidth(2)
+                wf.setnchannels(pcm.shape[1])
+                wf.writeframes(pcm.tobytes())
+    
+        return raw_audio
+  
+    else:
+      return None
+
+#===============================================================================
+
+def midi_to_colab_audio(midi_file,
+                        soundfont_path='/usr/share/sounds/sf2/FluidR3_GM.sf2',
+                        sample_rate=16000,
+                        volume_level_db=-1,
+                        trim_silence=True,
+                        silence_threshold=0.1,
+                        output_for_gradio=False,
+                        write_audio_to_WAV=False
+                       ):
+    """
+    Returns raw audio to pass to IPython.disaply.Audio func
+
+    Example usage:
+
+    from IPython.display import Audio
+
+    display(Audio(raw_audio, rate=16000, normalize=False))
+    """
+
+    # Check if midi_input is a path (string) or file content (bytes)
+    if isinstance(midi_file, str):
+        # It's a file path, open and read it.
+        try:
+            with open(midi_file, 'rb') as f:
+                midi_bytes = f.read()
+        except FileNotFoundError:
+            print(f"Error: Could not find or open the file at {midi_file}")
+            return None # Or handle the error appropriately
+    elif isinstance(midi_file, bytes):
+        # It's already the file content.
+        midi_bytes = midi_file
+    else:
+        raise TypeError("midi_input must be a file path (str) or file content (bytes)")
+
+    # Read and decode MIDI → opus event list from bytes
+    ticks_per_beat, *tracks = MIDI.midi2opus(midi_bytes)
+    if not tracks:
+        return None
+
+    # Flatten & convert delta-times to absolute-time
+    events = []
+    for track in tracks:
+        abs_t = 0
+        for name, dt, *data in track:
+            abs_t += dt
+            events.append([name, abs_t, *data])
+    events.sort(key=lambda e: e[1])
+
+    # Setup FluidSynth
+    fl = fluidsynth.Synth(samplerate=float(sample_rate))
+    sfid = fl.sfload(soundfont_path)
+    for chan in range(16):
+        # channel 9 = percussion GM bank 128
+        fl.program_select(chan, sfid, 128 if chan == 9 else 0, 0)
+
+    # Playback vars
+    tempo = int((60 / 120) * 1e6)  # default 120bpm
+    last_t = 0
+    
+    # Initialize a Python list to store audio chunks
+    audio_chunks = []
+
+    for name, cur_t, *data in events:
+        # compute how many samples have passed since the last event
+        delta_ticks = cur_t - last_t
+        last_t = cur_t
+        dt_seconds = (delta_ticks / ticks_per_beat) * (tempo / 1e6)
+        sample_len = int(dt_seconds * sample_rate)
+
+        if sample_len > 0:
+            buf = fl.get_samples(sample_len).reshape(-1, 2)
+            # Append the audio chunk to the list
+            audio_chunks.append(buf)
+
+        # Dispatch every known event
+        if name == "note_on" and data[2] > 0:
+            chan, note, vel = data
+            fl.noteon(chan, note, vel)
+
+        elif name == "note_off" or (name == "note_on" and data[2] == 0):
+            chan, note = data[:2]
+            fl.noteoff(chan, note)
+
+        elif name == "patch_change":
+            chan, patch = data[:2]
+            bank = 128 if chan == 9 else 0
+            fl.program_select(chan, sfid, bank, patch)
+
+        elif name == "control_change":
+            chan, ctrl, val = data[:3]
+            fl.cc(chan, ctrl, val)
+
+        elif name == "key_after_touch":
+            chan, note, vel = data
+            fl.key_pressure(chan, note, vel)
+
+        elif name == "channel_after_touch":
+            chan, vel = data
+            fl.channel_pressure(chan, vel)
+
+        elif name == "pitch_wheel_change":
+            chan, wheel = data
+            fl.pitch_bend(chan, wheel)
+
+        elif name == "song_position":
+            # song_pos = data[0];  # often not needed for playback
+            pass
+
+        elif name == "song_select":
+            # song_number = data[0]
+            pass
+
+        elif name == "tune_request":
+            # typically resets tuning; FS handles internally
+            pass
+
+        elif name in ("sysex_f0", "sysex_f7"):
+            raw_bytes = data[0]
+            fl.sysex(raw_bytes)
+
+        # Meta events & others—no direct audio effect, so we skip or log
+        elif name in (
+            "set_tempo",       # handled below
+            "end_track",
+            "text_event", "text_event_08", "text_event_09", "text_event_0a",
+            "text_event_0b", "text_event_0c", "text_event_0d", "text_event_0e", "text_event_0f",
+            "copyright_text_event", "track_name", "instrument_name",
+            "lyric", "marker", "cue_point",
+            "smpte_offset", "time_signature", "key_signature",
+            "sequencer_specific", "raw_meta_event"
+        ):
+            if name == "set_tempo":
+                tempo = data[0]
+            # else: skip all other meta & text; you could hook in logging here
+            continue
+
+        else:
+            # unknown event type
+            continue
+
+    # This captures the sound of the last notes, allowing them to decay naturally.
+    # We render an extra 2 seconds of audio. A shorter time like 1 second might be sufficient.
+    tail_len_seconds = 2
+    tail_buf = fl.get_samples(int(sample_rate * tail_len_seconds)).reshape(-1, 2)
+    audio_chunks.append(tail_buf)
+    
+    # Cleanup synth
+    fl.delete()
+    
+    # After the loop finishes, concatenate all audio chunks in a single operation
+    if not audio_chunks:
+        return None # No audio was generated
+    ss = np.concatenate(audio_chunks, axis=0)
+    
+
+    # Optimized silence trimming logic
+    if trim_silence and ss.size:
+        # Using a fixed amplitude threshold based on the data type's max value.
+        # This is more robust than using standard deviation for trimming the tail.
+        dtype_max = np.iinfo(ss.dtype).max
+        fixed_threshold = int(dtype_max * 0.005) # 0.5% of max amplitude
+        
+        # Find the first and last samples exceeding the threshold.
+        indices = np.where(np.abs(ss) > fixed_threshold)[0]
+        if indices.size > 0:
+            # We trim from the start as well in case of leading silence
+            first_idx = indices[0]
+            last_idx = indices[-1]
+            ss = ss[first_idx : last_idx + 1]
+        else:
+            # If it's all silence, return an empty array.
+            ss = np.empty((0, 2), dtype=ss.dtype)
+
+    if ss.size:
+        maxv = np.abs(ss).max()
+        if maxv:
+            ss = (ss / maxv) * np.iinfo(np.int16).max
+    ss = ss.astype(np.int16)
+
+    # For Gradio you might want raw int16 PCM
+    if output_for_gradio:
+        return ss
+
+    # Swap to (channels, samples) and normalize for playback
+    ss = ss.T
+    raw_audio = normalize_audio(ss, target_level_db=volume_level_db)
+
+    # Optionally write WAV to disk
+    if write_audio_to_WAV and isinstance(midi_file, str):
+        wav_name = midi_file.rsplit('.', 1)[0] + '.wav'
+        # Note: raw_audio is float, needs conversion back to int16 for WAV format.
+        if np.max(np.abs(raw_audio)) > 0:
+            pcm = np.int16(raw_audio.T / np.max(np.abs(raw_audio)) * 32767)
+        else:
+            pcm = np.int16(raw_audio.T * 32767)
+            
+        with wave.open(wav_name, 'wb') as wf:
+            wf.setframerate(sample_rate)
+            wf.setsampwidth(2)
+            wf.setnchannels(pcm.shape[1])
+            wf.writeframes(pcm.tobytes())
+
+    return raw_audio
+
+#===================================================================================================================

src/piano_transcription/utils.py

@@ -0,0 +1,128 @@
+# src/piano_transcription/utils.py
+
+import os
+from pathlib import Path
+from typing import Final
+
+# Import for the new downloader
+from huggingface_hub import hf_hub_download
+
+# Imports for the patch
+import numpy as np
+import librosa
+import audioread
+from piano_transcription_inference import utilities
+
+# --- Constants ---
+# By convention, uppercase variables are treated as constants and should not be modified.
+# Using typing.Final to indicate to static type checkers that these should not be reassigned.
+MODEL_NAME: Final[str] = "CRNN_note_F1=0.9677_pedal_F1=0.9186.pth"
+REPO_ID: Final[str] = "Genius-Society/piano_trans"
+
+
+# --- Model Download Function ---
+
+def download_model_from_hf_if_needed():
+    """
+    Checks for the model and downloads it from the Hugging Face Hub if not present.
+    The hf_hub_download function handles caching and existence checks automatically.
+    """
+    # Assuming this utils.py is in 'src/piano_transcription/', models are in 'src/models/'
+    utils_dir = Path(__file__).parent
+    base_dir = utils_dir.parent  # This should be the 'src' directory
+    model_dir = base_dir / "models"
+    model_path = model_dir / MODEL_NAME
+
+    print(f"Checking for model '{MODEL_NAME}' from Hugging Face Hub repo '{REPO_ID}'...")
+
+    try:
+        # hf_hub_download will download the file to a cache and return the path.
+        # To place it directly in our desired folder, we use `local_dir`.
+        # `local_dir_use_symlinks=False` ensures the actual file is copied to model_dir.
+        hf_hub_download(
+            repo_id=REPO_ID,
+            filename=MODEL_NAME,
+            local_dir=model_dir,
+            # local_dir_use_symlinks=False, # Recommended for moving projects around
+            # resume_download=True,
+        )
+        print(f"Model is available at '{model_path}'")
+
+    except AttributeError as e:
+        print(f"Error downloading from Hugging Face Hub. Please check your network connection and the repo/filename.")
+        print(f"Details: {e}")
+        # You might want to exit or raise the exception if the model is critical
+        # raise e 
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        # raise e
+
+
+# --- Monkey Patching Function ---
+
+def _fixed_load_audio(path, sr=22050, mono=True, offset=0.0, duration=None,
+    dtype=np.float32, res_type='kaiser_best',
+    backends=[audioread.ffdec.FFmpegAudioFile]):
+    """
+    A patched version of load_audio that uses updated function paths
+    for newer librosa versions. This function is intended to replace the
+    original one in the `piano_transcription_inference` library.
+    """
+    # (The code for this function remains unchanged)
+    y = []
+    with audioread.audio_open(os.path.realpath(path), backends=backends) as input_file:
+        sr_native = input_file.samplerate
+        n_channels = input_file.channels
+        s_start = int(np.round(sr_native * offset)) * n_channels
+        if duration is None:
+            s_end = np.inf
+        else:
+            s_end = s_start + (int(np.round(sr_native * duration)) * n_channels)
+        n = 0
+        for frame in input_file:
+            frame = librosa.util.buf_to_float(frame, dtype=dtype)
+            n_prev = n
+            n = n + len(frame)
+            if n < s_start:
+                continue
+            if s_end < n_prev:
+                break
+            if s_end < n:
+                frame = frame[:s_end - n_prev]
+            if n_prev <= s_start <= n:
+                frame = frame[(s_start - n_prev):]
+            y.append(frame)
+    if y:
+        y = np.concatenate(y)
+        if n_channels > 1:
+            y = y.reshape((-1, n_channels)).T
+            if mono:
+                y = librosa.to_mono(y)
+        if sr is not None:
+            y = librosa.resample(y, orig_sr=sr_native, target_sr=sr, res_type=res_type)
+        else:
+            sr = sr_native
+    y = np.ascontiguousarray(y, dtype=dtype)
+    return (y, sr)
+
+
+def apply_monkey_patch():
+    """
+    Applies the patch to the `piano_transcription_inference` library by
+    replacing its `load_audio` function with our fixed version.
+    """
+    print("Applying librosa compatibility patch...")
+    utilities.load_audio = _fixed_load_audio
+
+
+# --- Main Initializer ---
+
+def initialize_app():
+    """
+    Main initialization function. Call this at the start of your app.
+    It downloads the model from Hugging Face and applies the necessary patches.
+    """
+    print("--- Initializing Application ---")
+    download_model_from_hf_if_needed()
+    apply_monkey_patch()
+    print("--- Initialization Complete ---")

webui.bat

@@ -0,0 +1,162 @@
+@echo off
+
+:: The original source of the webui.bat file is stable-diffusion-webui
+:: Modified and enhanced by Gemini with features for venv management and requirements handling.
+
+:: --------- Configuration ---------
+set COMMANDLINE_ARGS=
+:: Define the name of the Launch application
+set APPLICATION_NAME=app.py
+:: Define the name of the virtual environment directory
+set VENV_NAME=venv
+:: Set to 1 to always attempt to update packages from requirements.txt on every launch
+set ALWAYS_UPDATE_REQS=0
+:: ---------------------------------
+
+
+:: Set PYTHON executable if not already defined
+if not defined PYTHON (set PYTHON=python)
+:: Set VENV_DIR using VENV_NAME if not already defined
+if not defined VENV_DIR (set "VENV_DIR=%~dp0%VENV_NAME%")
+
+mkdir tmp 2>NUL
+
+:: Check if Python is callable
+%PYTHON% -c "" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :check_pip
+echo Couldn't launch python
+goto :show_stdout_stderr
+
+:check_pip
+:: Check if pip is available
+%PYTHON% -mpip --help >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+:: If pip is not available and PIP_INSTALLER_LOCATION is set, try to install pip
+if "%PIP_INSTALLER_LOCATION%" == "" goto :show_stdout_stderr
+%PYTHON% "%PIP_INSTALLER_LOCATION%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+echo Couldn't install pip
+goto :show_stdout_stderr
+
+:start_venv
+:: Skip venv creation/activation if VENV_DIR is explicitly set to "-"
+if ["%VENV_DIR%"] == ["-"] goto :skip_venv_entirely
+:: Skip venv creation/activation if SKIP_VENV is set to "1"
+if ["%SKIP_VENV%"] == ["1"] goto :skip_venv_entirely
+
+:: Check if the venv already exists by looking for Python.exe in its Scripts directory
+dir "%VENV_DIR%\Scripts\Python.exe" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :activate_venv_and_maybe_update
+
+:: Venv does not exist, create it
+echo Virtual environment not found in "%VENV_DIR%". Creating a new one.
+for /f "delims=" %%i in ('CALL %PYTHON% -c "import sys; print(sys.executable)"') do set PYTHON_FULLNAME="%%i"
+echo Creating venv in directory %VENV_DIR% using python %PYTHON_FULLNAME%
+%PYTHON_FULLNAME% -m venv "%VENV_DIR%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% NEQ 0 (
+    echo Unable to create venv in directory "%VENV_DIR%"
+    goto :show_stdout_stderr
+)
+echo Venv created.
+
+:: Install requirements for the first time if venv was just created
+:: This section handles the initial installation of packages from requirements.txt
+:: immediately after a new virtual environment is created.
+echo Checking for requirements.txt for initial setup in %~dp0
+if exist "%~dp0requirements.txt" (
+    echo Found requirements.txt, attempting to install for initial setup...
+    call "%VENV_DIR%\Scripts\activate.bat"
+    echo Installing packages from requirements.txt ^(initial setup^)...
+    "%VENV_DIR%\Scripts\python.exe" -m pip install -r "%~dp0requirements.txt"
+    if %ERRORLEVEL% NEQ 0 (
+        echo Failed to install requirements during initial setup. Please check the output above.
+        pause
+        goto :show_stdout_stderr_custom_pip_initial 
+    )
+    echo Initial requirements installed successfully.
+    call "%VENV_DIR%\Scripts\deactivate.bat"
+) else (
+    echo No requirements.txt found for initial setup, skipping package installation.
+)
+goto :activate_venv_and_maybe_update
+
+
+:activate_venv_and_maybe_update
+:: This label is reached if the venv exists or was just created.
+:: Set PYTHON to point to the venv's Python interpreter.
+set PYTHON="%VENV_DIR%\Scripts\Python.exe"
+echo Activating venv: %PYTHON%
+
+:: Always update requirements if ALWAYS_UPDATE_REQS is 1
+:: This section allows for updating packages from requirements.txt on every launch
+:: if the ALWAYS_UPDATE_REQS variable is set to 1.
+if defined ALWAYS_UPDATE_REQS (
+    if "%ALWAYS_UPDATE_REQS%"=="1" (
+        echo ALWAYS_UPDATE_REQS is enabled.
+        if exist "%~dp0requirements.txt" (
+            echo Attempting to update packages from requirements.txt...
+            REM No need to call activate.bat here again, PYTHON is already set to the venv's python
+            %PYTHON% -m pip install -r "%~dp0requirements.txt"
+            if %ERRORLEVEL% NEQ 0 (
+                echo Failed to update requirements. Please check the output above.
+                pause
+                goto :endofscript 
+            )
+            echo Requirements updated successfully.
+        ) else (
+            echo ALWAYS_UPDATE_REQS is enabled, but no requirements.txt found. Skipping update.
+        )
+    ) else (
+        echo ALWAYS_UPDATE_REQS is not enabled or not set to 1. Skipping routine update.
+    )
+)
+
+goto :launch
+
+:skip_venv_entirely
+:: This label is reached if venv usage is explicitly skipped.
+echo Skipping venv.
+goto :launch
+
+:launch
+:: Launch the main application
+echo Launching Web UI with arguments: %COMMANDLINE_ARGS% %*
+%PYTHON% %APPLICATION_NAME% %COMMANDLINE_ARGS% %*
+echo Launch finished.
+pause
+exit /b
+
+:show_stdout_stderr_custom_pip_initial
+:: Custom error handler for failures during the initial pip install process.
+echo.
+echo exit code ^(pip initial install^): %errorlevel%
+echo Errors during initial pip install. See output above.
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b
+
+
+:show_stdout_stderr
+:: General error handler: displays stdout and stderr from the tmp directory.
+echo.
+echo exit code: %errorlevel%
+
+for /f %%i in ("tmp\stdout.txt") do set size=%%~zi
+if %size% equ 0 goto :show_stderr
+echo.
+echo stdout:
+type tmp\stdout.txt
+
+:show_stderr
+for /f %%i in ("tmp\stderr.txt") do set size=%%~zi
+if %size% equ 0 goto :endofscript
+echo.
+echo stderr:
+type tmp\stderr.txt
+
+:endofscript
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b