Auto wire stems setup

2025-08-18 08:37 UTC gpt-5-thinking Open in ChatGPT ↗

Awesome project. You can auto-wire your stems in TouchDesigner with one small Python script and (optionally) a single “Load Stems” button.

Here’s a drop-in approach that:

Scans your folder H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder
Finds files that contain -drums, -bass, -guitar, -piano, -other, -vocals (case-insensitive)
Picks the remaining file as the “full song”
Assigns each match to the corresponding Audio File In CHOP (I’m assuming they’re named full_song1, drums1, bass1, guitar1, piano1, other1, vocals1 like in your network)
Reloads the CHOPs so they’re ready to play

1) Add this Text DAT (name it `load_stems`), then Run Script

# load_stems Text DAT ----------------------------------------------
# Scans a folder for stems and assigns files to Audio File In CHOPs.

import os

STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')  # TD is happy with / on Windows

# Map keywords in filenames  ->  operator names in your network
TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'   # the CHOP for the unstemmed track

VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

def _reload_if_available(o):
    # TouchDesigner CHOPs often expose a .par.reload pulse
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        debug('Stem folder not found:', stem_dir)
        return

    files = [f for f in os.listdir(stem_dir) if f.lower().endswith(VALID_EXTS)]
    files_lower = [f.lower() for f in files]

    # 1) Assign each keyworded stem
    used = set()
    for key, op_name in TARGETS.items():
        match = next((f for f in files if f.lower().find('-' + key) != -1), None)
        o = op(op_name)
        if not o:
            debug('Missing operator:', op_name)
            continue
        if match:
            full_path = stem_dir + '/' + match
            o.par.file = full_path
            _reload_if_available(o)
            used.add(match)
            debug('Assigned', key, '->', op_name, 'file:', match)
        else:
            debug('No file found for', key)

    # 2) Assign the remaining file as the full song (any file that doesn't include any keyword)
    keywords = tuple('-' + k for k in TARGETS.keys())
    candidates = [f for f in files if f not in used and all(k not in f.lower() for k in keywords)]

    # choose the first candidate (or the shortest name if you prefer determinism)
    full_file = min(candidates, key=len) if candidates else None

    o_full = op(FULL_SONG_OP)
    if o_full:
        if full_file:
            o_full.par.file = stem_dir + '/' + full_file
            _reload_if_available(o_full)
            debug('Assigned full song ->', FULL_SONG_OP, 'file:', full_file)
        else:
            debug('No standalone full-song file found.')
    else:
        debug('Missing operator:', FULL_SONG_OP)

# run it immediately when you execute this DAT
load_stems()

If your CHOP names are different, just edit TARGETS (and FULL_SONG_OP) to match.

2) (Optional) A “Load Stems” button you can press anytime

Add a Button COMP named btn_load.
Add a DAT Execute DAT and set:
- DAT: btn_load/state
- In onOffToOn():
```
op('load_stems').run()    # runs the code above
return
```

Now pressing the button rescans the folder and repopulates all the CHOPs.

Notes / tweaks

If you sometimes have multiple versions per stem (e.g., -guitar-alt), change the selection logic to prefer the newest or largest file.
If you want the folder path to be a parameter, put it in a Base COMP with a custom parameter and read it in the script with parent().par.Stemdir.eval().
If you’re driving play/stop with your existing buttons, nothing changes—this only sets each CHOP’s file parameter and pulses a reload.

That’s it—drop the script in, press Run Script, and your network should populate itself from that folder.

You’re right — a Text DAT in TouchDesigner doesn’t have a “Run Script” menu item by default.
Instead, you execute its contents manually in a couple of ways:

✅ Ways to run the code inside a Text DAT:

Right-click inside the DAT → “Run Script”
- In TouchDesigner, if the DAT contains Python code, you can right-click anywhere in its body (or on its title bar) and you should see “Run Script” in the context menu.
- If you don’t see it, make sure the DAT type is Text DAT (not a Table, not a Parameter DAT).
Use run() explicitly
- From another DAT (e.g., a Button’s DAT Execute), call:
```
op('load_stems').run()
```
- This tells TD to execute the contents of the load_stems DAT.
Execute on load
- Add this line at the very bottom of your script:
```
load_stems()
```
- Then, every time you save or reload the project, TouchDesigner will execute the function automatically.
Hotkey shortcut
- With the Text DAT open and active, press Ctrl + R (or Cmd + R on Mac).
- This executes the script in that DAT.

👉 So for your case:
Drop the script into a Text DAT named load_stems. Then either:

Hit Ctrl+R inside it, or
Right-click it → Run Script, or
Trigger it with a button using op('load_stems').run().

Do you want me to also show you how to wire the folder path as a parameter (so you don’t hardcode H:\...) and just point the script at whatever folder you drop into?

Totally—let’s make it auto-pick the latest set when your folder contains multiple songs.

Below is a drop-in replacement for the Text DAT script. It:

Groups files by the song prefix (everything before “-drums”, “-guitar”, etc.).
Chooses the set whose newest file has the most recent modified time (tie-breakers: the one with the most stems, then shortest name).
Assigns stems + the full mix to your CHOPs.

Keep your CHOP names the same (full_song1, drums1, bass1, guitar1, piano1, other1, vocals1).
If you renamed them, edit TARGETS / FULL_SONG_OP.

# load_stems Text DAT — picks the "latest set" in the folder and assigns files to CHOPs
import os
from collections import defaultdict

# --- CONFIG ---
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _is_audio(fname):
    return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    """
    Returns the song 'prefix' for a file if it contains a known -stem keyword.
    E.g. 'AURORA - All_Is_Soft_Inside-guitar.mp3' -> 'AURORA - All_Is_Soft_Inside'
    If no keyword is present, returns the filename without extension (used as a 'full' candidate).
    """
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext  # likely the full mix within a set

def _choose_latest_set(stem_dir, files):
    """
    Groups files by song_key and returns the list of files belonging to the 'latest' set.
    Latest = group with the most recent mtime among its files.
    Tie-breakers: (1) most stems present, (2) shortest song_key string.
    """
    groups = defaultdict(list)
    for f in files:
        key = _song_key_for(f.lower())
        groups[key].append(f)

    def group_stats(key, flist):
        mtimes = [os.path.getmtime(os.path.join(stem_dir, f)) for f in flist]
        newest = max(mtimes) if mtimes else 0
        # how many known stem tags are present
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return newest, stems_present, -len(key)  # we’ll sort descending on first two, ascending on name length

    # pick best group
    best_key = None
    best_tuple = None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup

    return best_key, groups.get(best_key, [])

def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        debug('Stem folder not found:', stem_dir)
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        debug('No audio files found in:', stem_dir)
        return

    # pick the "latest" set
    song_key, set_files = _choose_latest_set(stem_dir, files)
    if not set_files:
        debug('No files resolved for latest set.')
        return

    # Helper: find a file in the chosen set that contains a token
    def find_in_set(token):
        token = token.lower()
        for f in set_files:
            if token in f.lower():
                return f
        return None

    used = set()

    # assign each stem
    for key, op_name in TARGETS.items():
        match = find_in_set('-' + key)
        o = op(op_name)
        if not o:
            debug('Missing operator:', op_name)
            continue
        if match:
            full_path = stem_dir + '/' + match
            o.par.file = full_path
            _reload_if_available(o)
            used.add(match)
            debug('Assigned', key, '->', op_name, 'file:', match)
        else:
            debug('No', key, 'file found in latest set.')

    # assign full song = file in set that has no stem keyword
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(k not in f.lower() for k in keywords)]

    full_file = None
    if full_candidates:
        # prefer one that shares the exact song_key (by prefix)
        # strip extension and compare prefix
        wanted_prefix = song_key
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(wanted_prefix) else 0
            mtime = os.path.getmtime(os.path.join(stem_dir, f))
            return (exact_prefix, mtime)
        full_file = max(full_candidates, key=score)

    o_full = op(FULL_SONG_OP)
    if o_full:
        if full_file:
            o_full.par.file = stem_dir + '/' + full_file
            _reload_if_available(o_full)
            debug('Assigned full song ->', FULL_SONG_OP, 'file:', full_file)
        else:
            debug('No full-mix file found for latest set.')
    else:
        debug('Missing operator:', FULL_SONG_OP)

    debug('Loaded latest set:', song_key)

# Run immediately (or call op('load_stems').run() from a button)
load_stems()

How it decides “latest”

It creates groups by filename prefix before the stem tag.
For each group it looks at the newest modification time among its files.
The group with the newest file wins; if tied, the one with more stems present wins; then shorter name as a final tie-breaker.

Optional: make the folder path a parameter

If you don’t want to hardcode the path:

Put this Text DAT inside a Base COMP (e.g., /project/stemloader).
Add a custom parameter (String) called Stemdir on that COMP and set your folder path there.

Replace the STEM_DIR line with:

STEM_DIR = parent().par.Stemdir.eval().replace('\\','/')

Want me to add auto-feedback to the UI (e.g., display which set was loaded in a Text TOP or a parameter readout)?

love it — let’s add a friendly status readout you can see right in TD.

What you’ll get

A Text DAT called stem_status that the script fills with:
- which set it loaded,
- which file went to each CHOP,
- timestamp.
A Text TOP that displays that DAT on screen.

1) Drop-in script (replace your Text DAT code)

Put this in your load_stems Text DAT (it includes the “latest set” logic you already have, plus the status output):

# load_stems — populate CHOPs from the latest set and write a status readout to a Text DAT
import os
from collections import defaultdict
import time

# --- CONFIG ---
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

STATUS_DAT_NAME = 'stem_status'   # Text DAT we’ll write to

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _is_audio(fname):
    return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext

def _choose_latest_set(stem_dir, files):
    groups = defaultdict(list)
    for f in files:
        key = _song_key_for(f.lower())
        groups[key].append(f)

    def group_stats(key, flist):
        mtimes = [os.path.getmtime(os.path.join(stem_dir, f)) for f in flist]
        newest = max(mtimes) if mtimes else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return newest, stems_present, -len(key)

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        d = parent() if hasattr(me, 'parent') else op('/project1')
        # try to create in the same COMP as this DAT; fall back to root/project1
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        dat = container.create(textDAT, STATUS_DAT_NAME)
        dat.write('')  # clear
        return dat
    return d

def _write_status(lines):
    dat = _get_or_create_status_dat()
    dat.text = '\n'.join(lines)

def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _write_status([f'[ERROR] Stem folder not found:', stem_dir])
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status([f'[WARN] No audio files in:', stem_dir])
        return

    song_key, set_files = _choose_latest_set(stem_dir, files)
    if not set_files:
        _write_status(['[WARN] Could not resolve a latest set.'])
        return

    def find_in_set(token):
        token = token.lower()
        for f in set_files:
            if token in f.lower():
                return f
        return None

    used = set()
    report = []
    ts = time.strftime('%Y-%m-%d %H:%M:%S')

    # assign each stem
    for key, op_name in TARGETS.items():
        match = find_in_set('-' + key)
        o = op(op_name)
        if not o:
            report.append(f'✗ Missing OP: {op_name}')
            continue
        if match:
            full_path = stem_dir + '/' + match
            o.par.file = full_path
            _reload_if_available(o)
            used.add(match)
            report.append(f'✓ {key:<6} -> {op_name} | {match}')
        else:
            report.append(f'– {key:<6} -> (none)')

    # full mix
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(k not in f.lower() for k in keywords)]

    full_file = None
    if full_candidates:
        wanted_prefix = song_key
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(wanted_prefix) else 0
            mtime = os.path.getmtime(os.path.join(stem_dir, f))
            return (exact_prefix, mtime)
        full_file = max(full_candidates, key=score)

    o_full = op(FULL_SONG_OP)
    if o_full and full_file:
        o_full.par.file = stem_dir + '/' + full_file
        _reload_if_available(o_full)
        report.append(f'✓ full   -> {FULL_SONG_OP} | {full_file}')
    elif o_full:
        report.append(f'– full   -> (none)')
    else:
        report.append(f'✗ Missing OP: {FULL_SONG_OP}')

    header = [
        f'Stem Loader Status',
        f'Folder : {stem_dir}',
        f'Set    : {song_key}',
        f'Time   : {ts}',
        '-'*48
    ]
    _write_status(header + report)

# auto-run on save/ctrl+R
load_stems()

2) Show it as on-screen text

Option A (quick & pretty): Text TOP

Add a Text TOP.
In its parameters:
- Set “DAT” to the stem_status DAT you just created (drag-drop the DAT onto the parameter).
- Turn “Top/Bottom Justify” and font/size to taste.
Composite the Text TOP into your render (e.g., over your main TOP with an Over TOP).

Option B: Panel label

Add a Label COMP and set its Text parameter to op('stem_status').text.
Place it in your UI container as a readout.

3) (Optional) Trigger updates

If you have a “Load Stems” button, wire its DAT Execute to:

op('load_stems').run()

The readout updates every time you press it (and anytime you Ctrl+R the DAT or reload the project).

If you want the status to also blink red on errors or show a green tick in the corner, I can add a small TOP pipeline that samples the first character (✓ ✗ –) and changes a colored badge accordingly.

Got it 👍 — you want the status DAT to only show a short, single-line summary like:

3: Set: tom petty - wildflowers

Here’s a trimmed-down version of the code. It still does all the loading logic, but only writes that one line to stem_status:

# load_stems — simplified status output
import os
from collections import defaultdict
import time

STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

STATUS_DAT_NAME = 'stem_status'

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _is_audio(fname): return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext

def _choose_latest_set(stem_dir, files):
    groups = defaultdict(list)
    for f in files:
        key = _song_key_for(f.lower())
        groups[key].append(f)

    def group_stats(key, flist):
        mtimes = [os.path.getmtime(os.path.join(stem_dir, f)) for f in flist]
        newest = max(mtimes) if mtimes else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return newest, stems_present, -len(key)

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _write_status(line):
    dat = _get_or_create_status_dat()
    dat.text = line

def load_stems(stem_dir=STEM_DIR):
    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status("No audio files found")
        return

    song_key, set_files = _choose_latest_set(stem_dir, files)
    if not set_files:
        _write_status("No set resolved")
        return

    # assign stems (same as before)
    for key, op_name in TARGETS.items():
        match = next((f for f in set_files if ('-'+key) in f.lower()), None)
        o = op(op_name)
        if o and match:
            o.par.file = stem_dir + '/' + match
            _reload_if_available(o)

    # assign full song
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(k not in f.lower() for k in keywords)]
    if full_candidates:
        o_full = op(FULL_SONG_OP)
        if o_full:
            full_file = max(full_candidates, key=lambda f: os.path.getmtime(os.path.join(stem_dir,f)))
            o_full.par.file = stem_dir + '/' + full_file
            _reload_if_available(o_full)

    # --- simplified status line ---
    ts = time.strftime('%H:%M')  # just hour:minute
    _write_status(f"{ts}: Set: {song_key}")

# auto-run
load_stems()

What changes:

Instead of a full report, the DAT now only contains something like:
```
3: Set: tom petty - wildflowers
```
(3 will be the current hour in 24h format; you can switch to full timestamp if you prefer).

❓ Do you want that prefix (3:) to be time of day (like above), or literally an incrementing counter every time you load a new set?

Perfect — let’s make it hands-free with a button that runs your load_stems DAT.

Step-by-step: “Load Stems” button

Add a Button COMP
- From the OP Create Dialog: COMP → Button.
- Rename it to btn_load.
Add a DAT Execute DAT
- Place a DAT Execute DAT next to the button.
- In its parameters:
  - DAT: set to btn_load/state
    (this is the table that flips between 0 and 1 when the button is pressed).
  - Turn on the onOffToOn callback only (turn others off).
Edit the DAT Execute DAT’s code
- Inside the generated DAT Execute DAT you’ll see functions like def onOffToOn(channel, sampleIndex, val, prev):.
- Replace the body of that function with:
```
def onOffToOn(channel, sampleIndex, val, prev):
    # Run the load_stems script
    op('load_stems').run()
    return
```
(make sure 'load_stems' matches the name of your Text DAT with the script).

Now when you click the button:

It fires the DAT Execute.
That calls op('load_stems').run().
Your stems reload + the status DAT updates automatically.

👉 Do you also want the status readout (the stem_status DAT text) to appear on the button itself (instead of a separate Text TOP), so it’s all in one place?

No worries—you’re looking at a DAT Execute template (it reacts to table/DAT changes).
For a button press it’s easier to use a Panel Execute DAT (reacts to UI “value” changes).

Easiest way: Panel Execute DAT (recommended)

Create a Button COMP (name it btn_load).
Create a Panel Execute DAT next to it.
In the Panel Execute DAT parameters:
- Panel: drag the btn_load COMP into this field.
- Turn on only Value Change (turn the others off).
Open the Panel Execute DAT and replace its code with:

def onValueChange(panelValue):
    # Fires when button value changes 0→1 or 1→0.
    # Only act on PRESS (value == 1)
    if panelValue == 1:
        op('load_stems').run()
    return

That’s it—press the button and your load_stems Text DAT will run.

If you prefer to keep using a DAT Execute

Wire it to the button’s internal state table and react when it flips to 1.

Create a DAT Execute DAT.
Set DAT to btn_load/state.
Turn ON only Cell Change.
Put this code in the DAT Execute:

def onCellChange(dat, cells, prev):
    # Button state table changes; run when it becomes "1"
    for i, c in enumerate(cells):
        # state value is in row 1, col 1 for Button COMP's state table
        if c.row == 1 and c.col == 1 and c.val in ('1','on') and prev[i] in ('0','off'):
            op('load_stems').run()
            break
    return

Either method will trigger your loader without right-click → Run Script.

You’re super close—the error means the Panel Execute DAT has the “Off to On” toggle enabled, so TD expects a function named onOffToOn(), but your code only defines onValueChange().

Fix it one of two ways:

Option A (simple): use only Value Change

In the Panel Execute DAT parameters:

Panels: btn_load (already set)
Turn ON: Value Change
Turn OFF: Off to On, On to Off, While On, While Off

Paste this code in the DAT:

def onValueChange(panelValue):
    # fire only on press
    if panelValue == 1:
        op('load_stems').run()
    return

Option B: keep Off to On (press-only)

In the Panel Execute DAT parameters:

Turn ON: Off to On
Turn OFF: the rest (including Value Change)

Paste this code:

def onOffToOn(panelValue):
    op('load_stems').run()
    return

Either way, pressing btn_load will run your load_stems script without right-click → Run Script.

Got it ✅ — right now the script is using os.path.getmtime() (modified time). To use creation time instead, swap in os.path.getctime().

Here’s the updated key parts of your script (with minimal changes):

import os
from collections import defaultdict
import time

# ... config above unchanged ...

def _choose_latest_set(stem_dir, files):
    groups = defaultdict(list)
    for f in files:
        key = _song_key_for(f.lower())
        groups[key].append(f)

    def group_stats(key, flist):
        # use creation time instead of modified time
        ctimes = [os.path.getctime(os.path.join(stem_dir, f)) for f in flist]
        newest = max(ctimes) if ctimes else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return newest, stems_present, -len(key)

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

def load_stems(stem_dir=STEM_DIR):
    # ... same as before ...

    # when selecting the full song file, also use creation time
    if full_candidates:
        wanted_prefix = song_key
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(wanted_prefix) else 0
            ctime = os.path.getctime(os.path.join(stem_dir, f))
            return (exact_prefix, ctime)
        full_file = max(full_candidates, key=score)

⚠️ Platform note

On Windows, getctime is creation time.
On macOS/Linux, it’s actually the inode change time (not true creation).
If you’re working on Windows (looks like you are, from your screenshot), you’ll get what you want.

Do you want me to also update the status line (your stem_status DAT) so it prints the creation date of the set instead of just the name/time-of-day?

Totally fine—cloud sync can wreck both “created” and “modified”.
Let’s pick the set that was dropped in most recently as a group by using a cohort time:

For each set (prefix before -guitar, -drums, etc.), get a per-file timestamp = max(ctime, mtime).
Take the median of those times for that set (robust against a single file being re-synced later).
Choose the set with the latest median.
Tie-breakers: more stems present, then shorter name.

Below is a drop-in replacement for your loader (keeps your one-line status). Paste it over your current Text DAT:

# load_stems — choose the set most recently placed in the folder (cohort/median time)
import os, time, statistics
from collections import defaultdict

STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

STATUS_DAT_NAME = 'stem_status'

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _is_audio(fname):
    return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext

def _file_cohort_time(path):
    """Use the max of ctime & mtime to survive weird sync behaviors."""
    try:
        c = os.path.getctime(path)
    except Exception:
        c = 0
    try:
        m = os.path.getmtime(path)
    except Exception:
        m = 0
    return max(c, m)

def _choose_latest_set(stem_dir, files):
    """
    Group by song key and pick the set with the latest median cohort time.
    Cohort time per file = max(ctime, mtime).
    Tie-breakers: more stems present, then shorter key.
    """
    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    def group_stats(key, flist):
        times = [_file_cohort_time(os.path.join(stem_dir, f)) for f in flist]
        med_time = statistics.median(times) if times else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return (med_time, stems_present, -len(key))  # sort desc on first two

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _write_status(line):
    _get_or_create_status_dat().text = line

def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _write_status("Folder not found")
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status("No audio files found")
        return

    song_key, set_files = _choose_latest_set(stem_dir, files)
    if not set_files:
        _write_status("No set resolved")
        return

    # assign stems
    for key, op_name in TARGETS.items():
        match = next((f for f in set_files if ('-'+key) in f.lower()), None)
        o = op(op_name)
        if o and match:
            o.par.file = f"{stem_dir}/{match}"
            _reload_if_available(o)

    # assign full mix (prefer same prefix; tie by latest cohort time)
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(k not in f.lower() for k in keywords)]
    if full_candidates:
        wanted_prefix = song_key
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(wanted_prefix) else 0
            t = _file_cohort_time(os.path.join(stem_dir, f))
            return (exact_prefix, t)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # one-line status
    _write_status(f"Set: {song_key}")

# auto-run (or call from your Panel Execute DAT)
load_stems()

This “cohort/median” method is usually the most reliable signal for “which set landed last” when files are synced or touched at different times. If you ever want to visualize which set it picked and why, I can add a debug flag that writes the per-file times into another DAT.

Great call — file metadata won’t reliably tell you when a set was copied in.
Let’s solve it by keeping a tiny local cache of “first time I ever saw this file in the folder”. Then we pick the set whose files have the latest median first-seen time. This is robust to copied metadata and cloud sync quirks.

Below is a drop-in replacement for your load_stems Text DAT. It keeps a JSON file next to your stems folder ( .td_stems_seen.json ). Pressing your button updates the cache and loads the most recently added set.

What it does

On each run, scans the folder.
For any filename it hasn’t seen before, records first_seen = time.time().
Groups files by set prefix (before -guitar, -drums, etc.).
Chooses the set with the latest median(first_seen) (tie-breakers: most stems present, then shortest name).
Assigns stems + full mix.
Status DAT shows: Set: <name>.

To “reset” history, just delete .td_stems_seen.json in the stems folder.

Script (paste into your `load_stems` Text DAT)

# load_stems — choose the set most recently *added* to the folder
import os, time, json, statistics
from collections import defaultdict

# --- CONFIG ---
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

STATUS_DAT_NAME = 'stem_status'
SEEN_FILE = os.path.join(STEM_DIR, '.td_stems_seen.json')  # cache of first_seen times

# --- Helpers -------------------------------------------------------
def _is_audio(fname):
    return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext  # treat as full-mix candidate within the set

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _write_status(line):
    _get_or_create_status_dat().text = line

def _load_seen():
    try:
        with open(SEEN_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}

def _save_seen(seen):
    try:
        with open(SEEN_FILE, 'w', encoding='utf-8') as f:
            json.dump(seen, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    """
    Group by song key and choose the set with the latest median 'first_seen' time.
    Unknown files get stamped now().
    """
    now = time.time()
    # stamp unseen files
    for f in files:
        if f not in seen:
            seen[f] = {"first_seen": now}

    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    def group_stats(key, flist):
        times = [seen.get(f, {}).get("first_seen", 0) for f in flist]
        med_time = statistics.median(times) if times else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return (med_time, stems_present, -len(key))  # sort desc on first two

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _write_status("Folder not found")
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status("No audio files found")
        return

    seen = _load_seen()
    song_key, set_files = _choose_latest_set_by_first_seen(stem_dir, files, seen)
    _save_seen(seen)

    if not set_files:
        _write_status("No set resolved")
        return

    # Assign stems
    for key, op_name in TARGETS.items():
        match = next((f for f in set_files if ('-' + key) in f.lower()), None)
        o = op(op_name)
        if o and match:
            o.par.file = f"{stem_dir}/{match}"
            _reload_if_available(o)

    # Assign full mix (prefer same prefix; fall back to any non-stem file in the set)
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(k not in f.lower() for k in keywords)]
    if full_candidates:
        # pick the one with latest first_seen (and matching prefix if possible)
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(song_key) else 0
            fs = _load_seen().get(f, {}).get("first_seen", 0)
            return (exact_prefix, fs)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # One-line status
    _write_status(f"Set: {song_key}")

# auto-run (or trigger via your Panel Execute button)
load_stems()

Notes

The cache keys by filename. If you paste the same filenames again (overwriting old ones), they’ll keep their original “first_seen”. If you want “fresh paste wins” even with identical names, delete .td_stems_seen.json before the paste (or I can add a small Reset button/param).
This works regardless of file metadata, because it records when TD first noticed the files.

Want me to add a tiny “Reset history” button that deletes the cache file and reloads?

Short answer: not with the previous version—it keyed only by filename. If you paste new files with the same names, they’ll keep the old “first_seen”.

Here’s a tiny upgrade so it treats a same-named file as “new” whenever its content changed (size or mtime). We store a lightweight fingerprint (size, mtime) and, if it differs from what we saw before, we reset first_seen = now.

Replace these parts in your `load_stems` DAT

1) Add a fingerprint helper

def _fingerprint(path):
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

2) Update _choose_latest_set_by_first_seen(...) to stamp unseen OR changed files

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    now = time.time()

    # stamp unseen or changed files
    for f in files:
        path = os.path.join(stem_dir, f)
        fp = _fingerprint(path)
        entry = seen.get(f)
        if entry is None or tuple(entry.get('fp', (None, None))) != fp:
            # new file or replaced content with same name
            seen[f] = {"first_seen": now, "fp": fp}

    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    def group_stats(key, flist):
        times = [seen.get(f, {}).get("first_seen", 0) for f in flist]
        med_time = statistics.median(times) if times else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return (med_time, stems_present, -len(key))

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

3) When picking the full-mix file, use the same seen dict (don’t reload it):

# inside load_stems(), after set_files is chosen
full_candidates = [f for f in set_files if all(('-' + k) not in f.lower() for k in TARGETS.keys())]
if full_candidates:
    def score(f):
        base = os.path.splitext(f.lower())[0]
        exact_prefix = 1 if base.startswith(song_key) else 0
        fs = seen.get(f, {}).get("first_seen", 0)
        return (exact_prefix, fs)
    full_file = max(full_candidates, key=score)
    o_full = op(FULL_SONG_OP)
    if o_full:
        o_full.par.file = f"{stem_dir}/{full_file}"
        _reload_if_available(o_full)

That’s it. Now each time you paste a set—even with identical filenames—the changed files get a new fingerprint, the set’s median first_seen moves forward, and it becomes the one that loads. If you ever want to fully reset history, just delete .td_stems_seen.json in the folder.

Absolutely 👍 here’s the full updated loader script with the “fingerprint” logic baked in so that if you paste in new stems with the same filenames it will still recognise them as new.

Just drop this into your load_stems Text DAT.

# load_stems — choose the set most recently *added* to the folder,
# even if filenames are reused (checks file size + mtime fingerprint).
import os, time, json, statistics
from collections import defaultdict

# --- CONFIG ---
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

STATUS_DAT_NAME = 'stem_status'
SEEN_FILE = os.path.join(STEM_DIR, '.td_stems_seen.json')  # cache of first_seen + fingerprint

# --- Helpers -------------------------------------------------------
def _is_audio(fname):
    return fname.lower().endswith(VALID_EXTS)

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return base_no_ext[:idx]
    return base_no_ext

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _write_status(line):
    _get_or_create_status_dat().text = line

def _load_seen():
    try:
        with open(SEEN_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}

def _save_seen(seen):
    try:
        with open(SEEN_FILE, 'w', encoding='utf-8') as f:
            json.dump(seen, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _fingerprint(path):
    """Simple file fingerprint: size + mtime"""
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    now = time.time()

    # Stamp unseen or changed files
    for f in files:
        path = os.path.join(stem_dir, f)
        fp = _fingerprint(path)
        entry = seen.get(f)
        if entry is None or tuple(entry.get('fp', (None, None))) != fp:
            seen[f] = {"first_seen": now, "fp": fp}

    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    def group_stats(key, flist):
        times = [seen.get(f, {}).get("first_seen", 0) for f in flist]
        med_time = statistics.median(times) if times else 0
        stems_present = sum(any(('-' + k) in f.lower() for f in flist) for k in TARGETS.keys())
        return (med_time, stems_present, -len(key))

    best_key, best_tuple = None, None
    for k, flist in groups.items():
        tup = group_stats(k, flist)
        if best_tuple is None or tup > best_tuple:
            best_key, best_tuple = k, tup
    return best_key, groups.get(best_key, [])

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _write_status("Folder not found")
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status("No audio files found")
        return

    seen = _load_seen()
    song_key, set_files = _choose_latest_set_by_first_seen(stem_dir, files, seen)
    _save_seen(seen)

    if not set_files:
        _write_status("No set resolved")
        return

    # Assign stems
    for key, op_name in TARGETS.items():
        match = next((f for f in set_files if ('-' + key) in f.lower()), None)
        o = op(op_name)
        if o and match:
            o.par.file = f"{stem_dir}/{match}"
            _reload_if_available(o)

    # Assign full mix (non-stem file in set, prefer same prefix, pick latest first_seen)
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(('-' + k) not in f.lower() for k in keywords)]
    if full_candidates:
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if base.startswith(song_key) else 0
            fs = seen.get(f, {}).get("first_seen", 0)
            return (exact_prefix, fs)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # One-line status
    _write_status(f"Set: {song_key}")

# auto-run (or trigger via your Panel Execute button)
load_stems()

✅ Behaviour

Keeps a hidden JSON .td_stems_seen.json in your stems folder.
Each file gets first_seen the moment TD notices it with a new fingerprint.
If you paste in a new set with the same names but different contents, the fingerprints change → new first_seen timestamps → that set wins.
Status DAT just shows:
```
Set: tom petty - wildflowers
```

Do you also want me to add a Reset button in TD (that wipes the .td_stems_seen.json) so you don’t need to delete it manually if you ever want to start fresh?

Thanks for the screenshots — I see what’s happening. Your Active folder currently has a bunch of full-mix only files (“Tom Petty – Wildflowers…”) with no stem tags (e.g. -drums, -guitar). My earlier script happily considered those as a “newest set”, so it kept choosing them.

Below is a stricter loader that:

Only considers a group a valid stem set if it contains at least MIN_STEMS_REQUIRED files with stem tags (default = 2).
Normalizes Windows copy names (e.g. "(1)", " - Copy") so duplicates group correctly.
Still uses the first-seen+fingerprint approach so copy/paste with reused filenames works.
If no valid stem set exists, it falls back to the newest full-mix-only group (so you can still play a single track if needed).

Drop this into your load_stems Text DAT.

# load_stems — pick the most recently *pasted* valid stem set.
# Valid set = has at least MIN_STEMS_REQUIRED tagged stems (e.g. -drums/-guitar/...).
# Robust to reused filenames via size+mtime fingerprint; normalizes "(1)" / " - Copy" suffixes.

import os, re, time, json, statistics
from collections import defaultdict

# --- CONFIG ---
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')
MIN_STEMS_REQUIRED = 2  # change if you want stricter/looser

STATUS_DAT_NAME = 'stem_status'
SEEN_FILE = os.path.join(STEM_DIR, '.td_stems_seen.json')  # cache of first_seen + fingerprint

# --- Helpers -------------------------------------------------------
def _is_audio(fname): return fname.lower().endswith(VALID_EXTS)

def _normalize_base(base_no_ext):
    # remove Windows duplicate suffixes: " (1)", " (2)", "...", and " - Copy", " - Copy (3)"
    base = re.sub(r'\s*-\s*copy(?:\s*$\d+$)?$', '', base_no_ext, flags=re.IGNORECASE)
    base = re.sub(r'\s*$\d+$$', '', base)
    return base

def _song_key_for(fname_lower):
    base_no_ext = os.path.splitext(fname_lower)[0]
    # If it has a stem tag, group by the part before the tag
    for k in TARGETS.keys():
        tag = '-' + k
        idx = base_no_ext.rfind(tag)
        if idx != -1:
            return _normalize_base(base_no_ext[:idx])
    # No tag → treat as full-mix candidate; normalize to collapse "(1)" / "- Copy"
    return _normalize_base(base_no_ext)

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _write_status(line):
    _get_or_create_status_dat().text = line

def _load_seen():
    try:
        with open(SEEN_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}

def _save_seen(seen):
    try:
        with open(SEEN_FILE, 'w', encoding='utf-8') as f:
            json.dump(seen, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _fingerprint(path):
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

def _stem_count(file_list):
    lc = [f.lower() for f in file_list]
    return sum(any(('-' + k) in f for f in lc) for k in TARGETS.keys())

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    now = time.time()

    # Stamp unseen or changed files
    for f in files:
        path = os.path.join(stem_dir, f)
        fp = _fingerprint(path)
        entry = seen.get(f)
        if entry is None or tuple(entry.get('fp', (None, None))) != fp:
            seen[f] = {"first_seen": now, "fp": fp}

    # Group by normalized song key
    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    # Split groups into "valid stem sets" and "full-only sets"
    valid_groups = []
    full_only_groups = []
    for key, flist in groups.items():
        sc = _stem_count(flist)
        if sc >= MIN_STEMS_REQUIRED:
            valid_groups.append((key, flist, sc))
        else:
            full_only_groups.append((key, flist, sc))

    def cohort_median(flist):
        return statistics.median([seen.get(f, {}).get("first_seen", 0) for f in flist]) if flist else 0

    # Rank: latest median first_seen, then more stems, then shorter key
    def rank(tup):
        key, flist, sc = tup
        return (cohort_median(flist), sc, -len(key))

    # Prefer valid stem sets; if none, fall back to newest full-only
    pool = valid_groups if valid_groups else full_only_groups
    if not pool:
        return None, []

    best = max(pool, key=rank)
    key, flist, _ = best
    return key, flist

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _write_status("Set: (folder not found)")
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _write_status("Set: (no audio files)")
        return

    seen = _load_seen()
    song_key, set_files = _choose_latest_set_by_first_seen(stem_dir, files, seen)
    _save_seen(seen)

    if not set_files or not song_key:
        _write_status("Set: (none)")
        return

    # Assign stems
    for key, op_name in TARGETS.items():
        match = next((f for f in set_files if ('-' + key) in f.lower()), None)
        o = op(op_name)
        if o:
            if match:
                o.par.file = f"{stem_dir}/{match}"
                _reload_if_available(o)
            else:
                # Clear if the new set doesn't contain this stem
                try:
                    o.par.file = ''
                except Exception:
                    pass

    # Assign full mix (non-stem file in set, prefer same prefix, pick latest first_seen)
    keywords = tuple('-' + k for k in TARGETS.keys())
    full_candidates = [f for f in set_files if all(('-' + k) not in f.lower() for k in TARGETS.keys())]
    if full_candidates:
        fs = seen  # already loaded
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if _song_key_for(base) == song_key else 0
            first_seen = fs.get(f, {}).get("first_seen", 0)
            return (exact_prefix, first_seen)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # One-line status
    _write_status(f"Set: {song_key}")

# auto-run (or trigger via your Panel Execute button)
load_stems()

How to use it (with your two-folder workflow)

Keep your Library inside the Active folder if you like; the script ignores subfolders.
When you want to switch:
1. Copy the 7 stem files (with -drums, -bass, …) from Library into the Active folder root.
2. Press your Load Stems button.
If you accidentally paste a full-mix only track (no -stem files), it won’t override a valid set unless there are no valid sets present.

If you still see it picking the wrong thing, paste one example set into the Active folder root exactly as you want them named, press the button once, and tell me what the stem_status line shows—then I can tighten the matching further (e.g., require at least 4 stems, or prefer sets that include -vocals).

Thanks for the detail — two things likely tripped us up:

Your Tom Petty filenames probably do have tags but not exactly -guitar etc. (often they’re - guitar, _guitar, (guitar), etc.).
We need visibility into what the loader thinks it sees.

Here’s a robust + debuggable loader. It:

Detects tags with a flexible regex (matches -guitar, - guitar, _guitar, (guitar), .guitar, etc., case‑insensitive).
Picks the most recently pasted set using the first‑seen + fingerprint method (size+mtime).
Requires at least MIN_STEMS_REQUIRED tagged stems to treat a group as a valid set.
Writes a short status line to stem_status and a detailed breakdown to stem_debug so you can verify grouping and times.

Drop this into your load_stems Text DAT and run. Keep your Panel Execute button as-is (it calls op('load_stems').run()).

# load_stems — robust stem loader with first-seen fingerprint + flexible tag detection
import os, re, time, json, statistics
from collections import defaultdict

# --- CONFIG --------------------------------------------------------
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')
MIN_STEMS_REQUIRED = 2    # require at least this many tagged stems to treat as a valid set

STATUS_DAT_NAME = 'stem_status'
DEBUG_DAT_NAME  = 'stem_debug'
SEEN_FILE = os.path.join(STEM_DIR, '.td_stems_seen.json')  # cache of first_seen + fingerprint

# --- Flexible tag regexes (e.g., -guitar, - guitar, _guitar, (guitar), .guitar) ---
TAG_PAT = {k: re.compile(r'(^|[\s._\-]){}($|[\s._\-])'.format(re.escape(k)), re.IGNORECASE)
           for k in TARGETS.keys()}

# --- Helpers -------------------------------------------------------
def _is_audio(fname): return fname.lower().endswith(VALID_EXTS)

def _normalize_base(base_no_ext):
    # collapse Windows duplicate suffixes: " (1)" / " - Copy" / " - Copy (3)"
    base = re.sub(r'\s*-\s*copy(?:\s*$\d+$)?$', '', base_no_ext, flags=re.IGNORECASE)
    base = re.sub(r'\s*$\d+$$', '', base)
    return base.strip(' ._-')

def _has_tag(base_no_ext, tag):
    return bool(TAG_PAT[tag].search(base_no_ext))

def _song_key_for(fname_lower):
    base = os.path.splitext(fname_lower)[0]
    # find first matching tag and take the prefix before it
    for k in TAG_PAT:
        m = TAG_PAT[k].search(base)
        if m:
            return _normalize_base(base[:m.start()])
    return _normalize_base(base)

def _reload_if_available(o):
    if hasattr(o.par, 'reload'):
        o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):
        o.par.cue.pulse()

def _get_or_create_text_dat(name):
    d = op(name)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, name)
    return d

def _status(line):
    _get_or_create_text_dat(STATUS_DAT_NAME).text = line

def _debug(lines):
    _get_or_create_text_dat(DEBUG_DAT_NAME).text = '\n'.join(lines)

def _load_seen():
    try:
        with open(SEEN_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}

def _save_seen(seen):
    try:
        with open(SEEN_FILE, 'w', encoding='utf-8') as f:
            json.dump(seen, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _fingerprint(path):
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

def _stem_count(file_list):
    lc = [os.path.splitext(f)[0].lower() for f in file_list]
    count = 0
    for k, pat in TAG_PAT.items():
        if any(pat.search(b) for b in lc):
            count += 1
    return count

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    now = time.time()

    # Stamp unseen or changed files (same-name paste with new content)
    for f in files:
        path = os.path.join(stem_dir, f)
        fp = _fingerprint(path)
        entry = seen.get(f)
        if entry is None or tuple(entry.get('fp', (None, None))) != fp:
            seen[f] = {"first_seen": now, "fp": fp}

    # Group files by normalized key
    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    # Split into valid stem sets vs full-only
    valid_groups, full_only_groups = [], []
    for key, flist in groups.items():
        sc = _stem_count(flist)
        if sc >= MIN_STEMS_REQUIRED:
            valid_groups.append((key, flist, sc))
        else:
            full_only_groups.append((key, flist, sc))

    def cohort_median(flist):
        return statistics.median([seen.get(f, {}).get("first_seen", 0) for f in flist]) if flist else 0

    def rank(tup):
        key, flist, sc = tup
        return (cohort_median(flist), sc, -len(key))

    pool = valid_groups if valid_groups else full_only_groups
    if not pool:
        return None, [], groups, {}

    best = max(pool, key=rank)
    key, flist, sc = best

    # Build debug snapshot
    dbg = {}
    for k, fl in groups.items():
        dbg[k] = {
            'files': fl,
            'stems': _stem_count(fl),
            'median_first_seen': cohort_median(fl),
            'first_seen_each': {f: seen.get(f, {}).get('first_seen', 0) for f in fl}
        }
    return key, flist, groups, dbg

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _status("Set: (folder not found)")
        _debug(["ERROR: folder not found", stem_dir])
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _status("Set: (no audio files)")
        _debug(["No audio files in:", stem_dir])
        return

    seen = _load_seen()
    song_key, set_files, groups, dbg = _choose_latest_set_by_first_seen(stem_dir, files, seen)
    _save_seen(seen)

    if not set_files or not song_key:
        _status("Set: (none)")
        _debug(["No set resolved.", "Groups:", *[f"- {k}: {groups[k]}" for k in groups]])
        return

    # Assign stems to CHOPs; clear missing ones
    for tag, op_name in TARGETS.items():
        o = op(op_name)
        if not o:
            continue
        match = None
        for f in set_files:
            base = os.path.splitext(f)[0].lower()
            if TAG_PAT[tag].search(base):
                match = f
                break
        if match:
            o.par.file = f"{stem_dir}/{match}"
            _reload_if_available(o)
        else:
            try: o.par.file = ''
            except Exception: pass

    # Assign full mix: any file in set with NO tag
    full_candidates = []
    for f in set_files:
        base = os.path.splitext(f)[0].lower()
        if not any(p.search(base) for p in TAG_PAT.values()):
            full_candidates.append(f)
    if full_candidates:
        # pick by latest first_seen; require same key equality after normalization
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if _song_key_for(base) == song_key else 0
            fs = seen.get(f, {}).get("first_seen", 0)
            return (exact_prefix, fs)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # Output status + debug
    _status(f"Set: {song_key}")

    lines = [f"Chosen set: {song_key}", "-"*60]
    for k in sorted(dbg.keys()):
        info = dbg[k]
        lines.append(f"{k} | stems:{info['stems']} | median_seen:{info['median_first_seen']:.0f}")
        for f in info['files']:
            fs = info['first_seen_each'].get(f, 0)
            lines.append(f"  - {f}  (seen:{fs:.0f})")
    _debug(lines)

# auto-run (or trigger from Panel Execute)
load_stems()

How to use the debug

Add a Text TOP pointed at stem_debug to see exactly:
- which groups were found,
- how many stems in each,
- their first‑seen times,
- which set was chosen.

If it still picks the wrong set, the stem_debug contents will reveal why (e.g., it’s not detecting tags because they’re like "(guitar stem)"). If so, tell me one exact filename that should count as, say, guitar, and I’ll extend the regex to match that pattern too.

Got it — here’s a full loader that wipes the .td_stems_seen file right after a successful load so each new paste starts fresh.

Robust stem tag detection (handles -guitar, - guitar, _guitar, (guitar), etc.)
Picks the most recently pasted set using first-seen + fingerprint (size+mtime) for the current run only
After loading, it deletes any cache file named .td_stems_seen or .td_stems_seen.json
Short status line to stem_status; optional debug to stem_debug (leave on; it’s handy)

Paste this into your load_stems Text DAT:

# load_stems — robust stem loader; wipes 'td_stems_seen' after each successful load
import os, re, time, json, statistics
from collections import defaultdict

# --- CONFIG --------------------------------------------------------
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')
MIN_STEMS_REQUIRED = 2    # treat as a valid set only if >= this many tagged stems

STATUS_DAT_NAME = 'stem_status'
DEBUG_DAT_NAME  = 'stem_debug'

# support either filename (you had both in screenshots/code)
SEEN_CANDIDATES = [
    os.path.join(STEM_DIR, '.td_stems_seen'),
    os.path.join(STEM_DIR, '.td_stems_seen.json'),
]

# --- Flexible tag regexes (e.g., -guitar, - guitar, _guitar, (guitar), .guitar)
TAG_PAT = {k: re.compile(r'(^|[\s._\-]){}($|[\s._\-])'.format(re.escape(k)), re.IGNORECASE)
           for k in TARGETS.keys()}

# --- Helpers -------------------------------------------------------
def _is_audio(fname): return fname.lower().endswith(VALID_EXTS)

def _normalize_base(base_no_ext):
    base = re.sub(r'\s*-\s*copy(?:\s*$\d+$)?$', '', base_no_ext, flags=re.IGNORECASE)
    base = re.sub(r'\s*$\d+$$', '', base)
    return base.strip(' ._-')

def _song_key_for(fname_lower):
    base = os.path.splitext(fname_lower)[0]
    for k, pat in TAG_PAT.items():
        m = pat.search(base)
        if m:
            return _normalize_base(base[:m.start()])
    return _normalize_base(base)

def _reload_if_available(o):
    if hasattr(o.par, 'reload'): o.par.reload.pulse()
    elif hasattr(o.par, 'cue'):  o.par.cue.pulse()

def _get_or_create_text_dat(name):
    d = op(name)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, name)
    return d

def _status(line): _get_or_create_text_dat(STATUS_DAT_NAME).text = line
def _debug(lines): _get_or_create_text_dat(DEBUG_DAT_NAME).text = '\n'.join(lines)

def _load_seen():
    # Read whichever seen file exists first; else empty
    for p in SEEN_CANDIDATES:
        try:
            if os.path.exists(p):
                with open(p, 'r', encoding='utf-8') as f:
                    return json.load(f), p
        except Exception:
            pass
    return {}, SEEN_CANDIDATES[0]

def _save_seen(seen, path_hint):
    try:
        with open(path_hint, 'w', encoding='utf-8') as f:
            json.dump(seen, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _wipe_seen_files():
    for p in SEEN_CANDIDATES:
        try:
            if os.path.exists(p):
                os.remove(p)
        except Exception:
            pass

def _fingerprint(path):
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

def _stem_count(file_list):
    lc = [os.path.splitext(f)[0].lower() for f in file_list]
    count = 0
    for _, pat in TAG_PAT.items():
        if any(pat.search(b) for b in lc):
            count += 1
    return count

def _choose_latest_set_by_first_seen(stem_dir, files, seen):
    now = time.time()

    # Stamp unseen or changed files (same-name paste with new content)
    for f in files:
        path = os.path.join(stem_dir, f)
        fp = _fingerprint(path)
        entry = seen.get(f)
        if entry is None or tuple(entry.get('fp', (None, None))) != fp:
            seen[f] = {"first_seen": now, "fp": fp}

    # Group by normalized key
    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)

    valid_groups, full_only_groups = [], []
    for key, flist in groups.items():
        sc = _stem_count(flist)
        (valid_groups if sc >= MIN_STEMS_REQUIRED else full_only_groups).append((key, flist, sc))

    def cohort_median(flist):
        return statistics.median([seen.get(f, {}).get("first_seen", 0) for f in flist]) if flist else 0

    def rank(tup):
        key, flist, sc = tup
        return (cohort_median(flist), sc, -len(key))

    pool = valid_groups if valid_groups else full_only_groups
    if not pool:
        return None, [], groups, {}

    best = max(pool, key=rank)
    key, flist, sc = best

    # Build debug snapshot
    dbg = {}
    for k, fl in groups.items():
        dbg[k] = {
            'files': fl,
            'stems': _stem_count(fl),
            'median_first_seen': cohort_median(fl),
            'first_seen_each': {f: seen.get(f, {}).get('first_seen', 0) for f in fl}
        }
    return key, flist, groups, dbg

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    if not os.path.isdir(stem_dir):
        _status("Set: (folder not found)")
        _debug(["ERROR: folder not found", stem_dir])
        return

    files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not files:
        _status("Set: (no audio files)")
        _debug(["No audio files in:", stem_dir])
        return

    seen, seen_path = _load_seen()
    song_key, set_files, groups, dbg = _choose_latest_set_by_first_seen(stem_dir, files, seen)
    _save_seen(seen, seen_path)

    if not set_files or not song_key:
        _status("Set: (none)")
        _debug(["No set resolved.", "Groups:"] + [f"- {k}: {groups[k]}" for k in groups])
        return

    # Assign stems to CHOPs; clear missing ones
    for tag, op_name in TARGETS.items():
        o = op(op_name)
        if not o:
            continue
        match = None
        for f in set_files:
            base = os.path.splitext(f)[0].lower()
            if TAG_PAT[tag].search(base):
                match = f
                break
        if match:
            o.par.file = f"{stem_dir}/{match}"
            _reload_if_available(o)
        else:
            try: o.par.file = ''
            except Exception: pass

    # Assign full mix: any file in set with NO tag
    full_candidates = []
    for f in set_files:
        base = os.path.splitext(f)[0].lower()
        if not any(p.search(base) for p in TAG_PAT.values()):
            full_candidates.append(f)
    if full_candidates:
        def score(f):
            base = os.path.splitext(f.lower())[0]
            exact_prefix = 1 if _song_key_for(base) == song_key else 0
            # within this run, first_seen exists in `seen`
            fs = seen.get(f, {}).get("first_seen", 0)
            return (exact_prefix, fs)
        full_file = max(full_candidates, key=score)
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            _reload_if_available(o_full)

    # Status + debug
    _status(f"Set: {song_key}")
    lines = [f"Chosen set: {song_key}", "-"*60]
    for k in sorted(dbg.keys()):
        info = dbg[k]
        lines.append(f"{k} | stems:{info['stems']} | median_seen:{info['median_first_seen']:.0f}")
        for f in info['files']:
            fs = info['first_seen_each'].get(f, 0)
            lines.append(f"  - {f}  (seen:{fs:.0f})")
    _debug(lines)

    # 💥 Wipe cache so the next paste starts clean
    _wipe_seen_files()

# auto-run (or trigger from your Panel Execute button)
load_stems()

Why wipe after loading?

We still need the cache during the current run to decide which set was just pasted.
Once loaded, we delete it so the next paste will re-stamp everything from zero, making the freshly copied set win reliably.

If you want a small “Reset Seen Now” button as well, say the word and I’ll add a one-liner Panel Execute that calls _wipe_seen_files() and refreshes.

Got it — let’s stop relying on file timestamps altogether.

How this version works

It remembers a snapshot of what was in the Active folder the last time you pressed the button (filename + fingerprint = size+mtime).
When you paste a new set and press the button, it looks at files that are new or changed since last run.
It chooses the set from those new/changed files (no timestamps involved).
If for some reason there are no new/changed files, it falls back to all files but prefers groups containing any new/changed files.
After loading, it updates the snapshot so the next paste is recognized cleanly.
Flexible tag matching (-guitar, _guitar, - guitar, (guitar) etc.).
One-line status in stem_status.

Paste this entire script into your load_stems Text DAT, and keep your Panel Execute button calling op('load_stems').run().

# load_stems — ALWAYS pick the set you just pasted (no timestamps).
# Logic: compare current folder to last-snapshot; use files that are NEW/CHANGED since last run.
import os, re, json
from collections import defaultdict

# --- CONFIG --------------------------------------------------------
STEM_DIR = r'H:\My Drive\02_Projects\00_Personal Projects\Synesthesia\Stems\TD_Stem_Auto_Setup_Folder'
STEM_DIR = STEM_DIR.replace('\\', '/')

TARGETS = {
    'drums' : 'drums1',
    'bass'  : 'bass1',
    'guitar': 'guitar1',
    'piano' : 'piano1',
    'other' : 'other1',
    'vocals': 'vocals1',
}
FULL_SONG_OP = 'full_song1'
VALID_EXTS = ('.wav', '.mp3', '.aiff', '.aif', '.flac', '.ogg', '.m4a')

MIN_STEMS_REQUIRED = 2            # treat as valid set if >= this many tagged stems
SNAP_FILE = os.path.join(STEM_DIR, '.td_stems_snapshot.json')  # previous snapshot (filename -> fingerprint)
STATUS_DAT_NAME = 'stem_status'   # one-line status readout

# --- Flexible tag regex: matches -guitar, _guitar, - guitar, (guitar), .guitar (case-insensitive)
TAG_PAT = {k: re.compile(r'(^|[\s._\-]){}($|[\s._\-])'.format(re.escape(k)), re.IGNORECASE)
           for k in TARGETS.keys()}

# --- Helpers -------------------------------------------------------
def _is_audio(fname): return fname.lower().endswith(VALID_EXTS)

def _normalize_base(base_no_ext):
    # collapse Windows duplicate suffixes: " (1)" / " - Copy" / " - Copy (3)"
    base = re.sub(r'\s*-\s*copy(?:\s*$\d+$)?$', '', base_no_ext, flags=re.IGNORECASE)
    base = re.sub(r'\s*$\d+$$', '', base)
    return base.strip(' ._-')

def _song_key_for(fname_lower):
    base = os.path.splitext(fname_lower)[0]
    for _, pat in TAG_PAT.items():
        m = pat.search(base)
        if m:
            return _normalize_base(base[:m.start()])
    return _normalize_base(base)

def _has_tag(base_no_ext, tag):
    return bool(TAG_PAT[tag].search(base_no_ext))

def _fingerprint(path):
    # small + fast; if content replaced, fingerprint changes
    try:
        st = os.stat(path)
        return (st.st_size, int(st.st_mtime))
    except Exception:
        return (None, None)

def _load_snapshot():
    try:
        with open(SNAP_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    except Exception:
        return {}

def _save_snapshot(snap):
    try:
        with open(SNAP_FILE, 'w', encoding='utf-8') as f:
            json.dump(snap, f, ensure_ascii=False, indent=0)
    except Exception:
        pass

def _get_or_create_status_dat():
    d = op(STATUS_DAT_NAME)
    if not d:
        container = me.parent() if hasattr(me, 'parent') else op('/project1')
        d = container.create(textDAT, STATUS_DAT_NAME)
    return d

def _status(line):
    _get_or_create_status_dat().text = line

def _group(files):
    groups = defaultdict(list)
    for f in files:
        groups[_song_key_for(f.lower())].append(f)
    return groups

def _stem_count(file_list):
    lc = [os.path.splitext(f)[0].lower() for f in file_list]
    count = 0
    for _, pat in TAG_PAT.items():
        if any(pat.search(b) for b in lc):
            count += 1
    return count

# --- Main ----------------------------------------------------------
def load_stems(stem_dir=STEM_DIR):
    # 0) sanity
    if not os.path.isdir(stem_dir):
        _status("Set: (folder not found)")
        return

    # 1) current inventory + fingerprints
    curr_files = [f for f in os.listdir(stem_dir) if _is_audio(f)]
    if not curr_files:
        _status("Set: (no audio files)")
        return
    curr_fp = {f: _fingerprint(os.path.join(stem_dir, f)) for f in curr_files}

    # 2) compare to previous snapshot
    prev = _load_snapshot()  # {filename: [size, mtime]}
    new_or_changed = [f for f in curr_files if f not in prev or tuple(prev.get(f, (None,None))) != tuple(curr_fp[f])]

    # 3) group files
    groups_all = _group(curr_files)
    groups_new = _group(new_or_changed) if new_or_changed else {}

    # 4) choose a set
    def pick_from_groups(groups, prefer_new=False):
        if not groups: return (None, [])
        # build candidates: (key, files, stem_count, new_count)
        cands = []
        for key, flist in groups.items():
            sc = _stem_count(flist)
            # count how many in this group are "new/changed" (if prefer_new=True)
            newc = len([f for f in flist if f in new_or_changed]) if prefer_new else 0
            cands.append((key, flist, sc, newc))
        # Prefer groups with stems >= MIN_STEMS_REQUIRED; else allow any
        valid = [c for c in cands if c[2] >= MIN_STEMS_REQUIRED]
        pool = valid if valid else cands
        # Rank: if prefer_new, more new files first; then higher stem count; then shorter key
        pool.sort(key=lambda t: (t[3] if prefer_new else 0, t[2], -len(t[0])), reverse=True)
        best = pool[0]
        return (best[0], best[1])

    # First try: only the NEW/CHANGED files (this is the paste you just did)
    song_key, set_files = pick_from_groups(groups_new, prefer_new=True)

    # Fallback: consider all files but still weight groups that contain new/changed files
    if not set_files:
        # reweight using all groups, but prefer those with any new files
        song_key, set_files = pick_from_groups(groups_all, prefer_new=True)

    if not set_files:
        _status("Set: (none)")
        return

    # 5) assign stems to CHOPs; clear missing ones
    for tag, op_name in TARGETS.items():
        o = op(op_name)
        if not o:
            continue
        match = None
        for f in set_files:
            base = os.path.splitext(f)[0].lower()
            if _has_tag(base, tag):
                match = f
                break
        if match:
            o.par.file = f"{stem_dir}/{match}"
            # pulse reload/cue if available
            if hasattr(o.par, 'reload'): o.par.reload.pulse()
            elif hasattr(o.par, 'cue'):  o.par.cue.pulse()
        else:
            try: o.par.file = ''
            except Exception: pass

    # 6) assign full mix = files in chosen set with NO stem tag
    full_candidates = []
    for f in set_files:
        base = os.path.splitext(f)[0].lower()
        if not any(p.search(base) for p in TAG_PAT.values()):
            full_candidates.append(f)
    if full_candidates:
        # prefer one whose normalized prefix exactly equals the group key
        def score(f):
            pref_match = 1 if _song_key_for(os.path.splitext(f.lower())[0]) == song_key else 0
            # prefer if it's also new/changed this run
            is_new = 1 if f in new_or_changed else 0
            return (pref_match, is_new)
        full_file = sorted(full_candidates, key=score, reverse=True)[0]
        o_full = op(FULL_SONG_OP)
        if o_full:
            o_full.par.file = f"{stem_dir}/{full_file}"
            if hasattr(o_full.par, 'reload'): o_full.par.reload.pulse()
            elif hasattr(o_full.par, 'cue'):  o_full.par.cue.pulse()

    # 7) status + snapshot update
    _status(f"Set: {song_key}")

    # Save current inventory as the new baseline so next paste is detected
    _save_snapshot({f: list(curr_fp[f]) for f in curr_files})

# auto-run (or trigger via Panel Execute button)
load_stems()

How to use

Paste your 7 stem files (and optional full mix) into the Active folder.
Press your Load Stems button.
The script looks only at files that are new/changed since the last press, and loads that set.

This should match your workflow exactly: every time you paste in a set, that set wins — even if identical names were used before and dozens of old sets are still in the folder.