Delete sd-webui-timemachine-fixed

sd-webui-timemachine-fixed/javascript/init.js

@@ -1,56 +0,0 @@
-(function(NAME) {
-
-    const name = NAME.toLowerCase().replaceAll(/\s/g, '');
-    
-    let _r = 0;
-    function to_gradio(v) {
-        // force call `change` event on gradio
-        return [v.toString(), (_r++).toString()];
-    }
-    
-    function js2py(type, gradio_field, value) {
-        // set `value` to gradio's field
-        // (1) Click gradio's button.
-        // (2) Gradio will fire js callback to retrieve value to be set.
-        // (3) Gradio will fire another js callback to notify the process has been completed.
-        return new Promise(resolve => {
-            const callback_name = `${name}-${type}-${gradio_field}`;
-            
-            // (2)
-            globalThis[callback_name] = () => {
-                
-                delete globalThis[callback_name];
-                
-                // (3)
-                const callback_after = callback_name + '_after';
-                globalThis[callback_after] = () => {
-                    delete globalThis[callback_after];
-                    resolve();
-                };
-                
-                return to_gradio(value);
-            };
-            
-            // (1)
-            gradioApp().querySelector(`#${callback_name}_set`).click();
-        });
-    }
-
-    function id(mode, s) {
-        const v = `${name}-${mode}`;
-        return s === undefined ? v : `${v}-${s}`;
-    }
-
-    if (!globalThis[name]) {
-        globalThis[name] = {};
-    }
-
-    const obj = globalThis[name];
-    obj.id = id;
-    obj.js2py = js2py;
-    obj.init = true;
-
-    console.log(`[${NAME}] initialized`)
-    document.dispatchEvent(new CustomEvent(`${name}_init`, { detail: obj }));
-
-})('TimeMachine');

sd-webui-timemachine-fixed/javascript/timemachine.js

@@ -1,951 +0,0 @@
-(function (NAME) {
-
-    const name = NAME.toLowerCase().replaceAll(/\s/g, '');
-
-    if (globalThis[name]?.init) init(name, globalThis[name]);
-    else document.addEventListener(`${name}_init`, e => init(name, e.detail), { once: true });
-
-    async function init(name, lib) { await load_modules(lib); await main(name, lib); }
-
-    function load_modules(lib) {
-        return new Promise(resolve => {
-            function load() {
-                if (lib.module_loaded) return true;
-                const app = gradioApp();
-                if (!app || app === document) return false;
-                const jscont = app.querySelector('#' + lib.id('js_modules'));
-                if (!jscont) return false;
-                const [base_path, ...scripts] = jscont.textContent.trim().split('\n').map(x => x.trim());
-                jscont.textContent = '';
-                const df = document.createDocumentFragment();
-                for (let src of scripts) {
-                    const s = document.createElement('script');
-                    s.async = true; s.type = 'module'; s.src = `file=${src}`; df.appendChild(s);
-                }
-                app.appendChild(df);
-                lib.import = s => import(`/file=${base_path}/javascript/modules/${s}`);
-                lib.module_loaded = true; resolve(); return true;
-            }
-            (function try_load() { if (!load()) setTimeout(try_load, 500); })();
-        });
-    }
-
-    async function main(name, lib) {
-        await lib.import('chart.umd.js');
-        main2(name, lib, 'txt2img');
-        main2(name, lib, 'img2img');
-    }
-
-    async function main2(name, lib, mode) {
-        // Ждём появления аккордеона в DOM
-        await new Promise(resolve => {
-            (function try_get() {
-                const el = gradioApp().querySelector('#' + lib.id(mode, 'accordion'));
-                el ? resolve(el) : setTimeout(try_get, 500);
-            })();
-        });
-
-        let initialized = false;
-
-        function tryInit() {
-            if (initialized) return;
-            const container = gradioApp().querySelector('#' + lib.id(mode, 'container'));
-            // offsetParent === null если элемент скрыт (display:none)
-            if (container && container.offsetParent !== null) {
-                initialized = true;
-                main3(name, lib, mode);
-            }
-        }
-
-        // Попытка сразу (Gradio 4.x: контент уже в DOM, просто скрыт)
-        tryInit();
-
-        // MutationObserver для Gradio 3.x (контент добавляется при открытии)
-        const acc = gradioApp().querySelector('#' + lib.id(mode, 'accordion'));
-        if (acc) {
-            new MutationObserver(() => tryInit())
-                .observe(acc, { childList: true, subtree: true, attributes: true });
-        }
-
-        // Опрос как запасной вариант (ловит CSS-изменения видимости)
-        // Останавливается как только граф инициализирован или через 60 сек
-        const deadline = Date.now() + 60000;
-        const poll = setInterval(() => {
-            if (initialized || Date.now() > deadline) { clearInterval(poll); return; }
-            tryInit();
-        }, 300);
-    }
-
-    function main3(name, lib, mode) {
-        const id  = s => lib.id(mode, s);
-        const $   = x => Array.from(gradioApp().querySelectorAll(x)).at(-1);
-        const $$  = x => gradioApp().querySelector(x);
-
-        const enabled         = $$(`#${id('enabled')} input[type=checkbox]`);
-        const generate_button = $$(`#${mode}_generate`);
-        const step_ele        = $$(`#${mode}_steps input[type=number]`);
-        const oneShotEl       = $$(`#${id('one_shot')} input[type=checkbox]`);
-        const cutoffEl        = $$(`#${id('cutoff')} input[type=number]`);
-
-        // ── Главный график ──────────────────────────────────
-        const canvas  = document.createElement('canvas');
-        canvas.width  = 512; canvas.height = 512;
-
-        const plugins = createPlugins(canvas, step_ele, cutoffEl);
-        const chart   = new Chart(canvas.getContext('2d'), {
-            type: 'scatter', data: createInitialData(),
-            options: createChartOption(), plugins,
-        });
-        $('#' + id('container')).appendChild(canvas);
-
-        // ── Per-segment mode: right-click on line → menu ─────────
-        const SEG_MODES = ['Linear', 'Ease In', 'Ease Out', 'Ease In-Out', 'Cubic', 'Exponential', 'Step'];
-
-        function _findSegment(c, ev) {
-            const rect = c.canvas.getBoundingClientRect();
-            const x = c.scales.x.getValueForPixel(ev.clientX - rect.left);
-            const data = c.data.datasets[0].data;
-            for (let i = 0; i < data.length - 1; i++) {
-                if (data[i].x <= x && x <= data[i + 1].x) return { idx: i, pt: data[i] };
-            }
-            return null;
-        }
-
-        let _segMenuCloser = null;
-        function _closeSegMenu() {
-            const old = document.getElementById(id('segmenu')); if (old) old.remove();
-            if (_segMenuCloser) { document.removeEventListener('click', _segMenuCloser); _segMenuCloser = null; }
-        }
-
-        function _showSegMenu(c, seg, ev) {
-            _closeSegMenu();
-            const div = document.createElement('div');
-            div.id = id('segmenu');
-            div.style.cssText = 'position:fixed;background:#1a1a2e;border:1px solid #ff8c00;border-radius:8px;padding:4px 0;z-index:99999;font-size:13px;box-shadow:0 4px 20px rgba(0,0,0,.6);min-width:150px';
-            _segMenuCloser = () => _closeSegMenu();
-            document.addEventListener('click', _segMenuCloser, {once:true});
-
-            SEG_MODES.forEach(m => {
-                const el = document.createElement('div');
-                el.textContent = m;
-                const active = seg.pt.mode === m || (!seg.pt.mode && m === 'Linear');
-                el.style.cssText = `padding:4px 16px;cursor:pointer;color:${active?'#ff8c00':'#ddd'};font-weight:${active?'bold':'normal'}`;
-                el.addEventListener('mouseenter', () => { el.style.background = '#ff8c0022'; });
-                el.addEventListener('mouseleave', () => { el.style.background = 'transparent'; });
-                el.addEventListener('click', e => { e.stopPropagation();
-                    if (m === 'Linear') delete seg.pt.mode; else seg.pt.mode = m;
-                    c.update(); saveState(c); triggerSync(c); _closeSegMenu();
-                });
-                div.appendChild(el);
-            });
-
-            const sep = document.createElement('div');
-            sep.style.cssText = 'height:1px;background:#444;margin:3px 8px';
-            div.appendChild(sep);
-
-            const clear = document.createElement('div');
-            clear.textContent = '— Use global';
-            clear.style.cssText = 'padding:4px 16px;cursor:pointer;color:#999;font-style:italic';
-            clear.addEventListener('mouseenter', () => { clear.style.background = '#ff8c0022'; });
-            clear.addEventListener('mouseleave', () => { clear.style.background = 'transparent'; });
-            clear.addEventListener('click', e => { e.stopPropagation();
-                delete seg.pt.mode; c.update(); saveState(c); triggerSync(c); _closeSegMenu();
-            });
-            div.appendChild(clear);
-
-            div.style.left = Math.min(ev.clientX, window.innerWidth - 170) + 'px';
-            div.style.top  = Math.min(ev.clientY, window.innerHeight - div.offsetHeight) + 'px';
-            document.body.appendChild(div);
-        }
-
-        canvas.addEventListener('contextmenu', e => {
-            e.preventDefault();
-            if (plugins[0].lastRemoved) { plugins[0].lastRemoved = false; return; }
-            const seg = _findSegment(chart, e);
-            if (seg) _showSegMenu(chart, seg, e);
-        }, true);
-
-        // σ-аппроксимация (реальные через HTTP, fallback Karras)
-        let showSigma = false, approxSigmas = [];
-
-        function getScheduler() {
-            const el = $$(`#${id('scheduler')} select`);
-            return el?.value || 'Use sampler default';
-        }
-
-        function getSampler() {
-            const el = $$(`#${mode}_sampling select`);
-            return el?.value || '';
-        }
-
-        async function _fetchRealSigmas(scheduler, steps) {
-            try {
-                let url = `/timemachine/sigmas?scheduler=${encodeURIComponent(scheduler)}&steps=${steps}`;
-                const sampler = getSampler();
-                if (sampler) url += `&sampler=${encodeURIComponent(sampler)}`;
-                const res = await fetch(url);
-                if (!res.ok) return null;
-                const data = await res.json();
-                return Array.isArray(data.sigmas) ? data.sigmas : null;
-            } catch(e) {
-                return null;
-            }
-        }
-
-        function _karrasApprox(n) {
-            const [sMin, sMax, rho] = [0.1, 14.6, 7];
-            const sig = Array.from({length: n}, (_, i) => {
-                const t = i / Math.max(1, n-1);
-                return Math.pow(Math.pow(sMax,1/rho)+t*(Math.pow(sMin,1/rho)-Math.pow(sMax,1/rho)), rho);
-            });
-            sig.push(0);
-            return sig;
-        }
-
-        function updateSigmaApprox(n, scheduler) {
-            approxSigmas = _karrasApprox(n);
-            _fetchRealSigmas(scheduler, n).then(real => {
-                if (real && real.length >= n) {
-                    // real has n+1 sigmas (including trailing 0)
-                    approxSigmas = real.slice(0, n + 1);
-                    if (showSigma) { chart?.update(); if (hr_chart) hr_chart?.update(); }
-                }
-            });
-        }
-
-        // Динамические callbacks Chart.js
-        chart.options.scales.y.ticks.callback = v => {
-            if (!showSigma || v < 1 || v > approxSigmas.length-1) return v;
-            const s = approxSigmas[Math.round(v)-1];
-            return s == null ? v : s < 0.01 ? '0' : s < 1 ? s.toFixed(3) : s.toFixed(1);
-        };
-        chart.options.plugins.tooltip.callbacks.title = ctxs => ctxs.map(c => {
-            const pos = c.parsed.y;
-            if (!showSigma) return `${c.parsed.x} → ${pos}`;
-            const s = approxSigmas[Math.round(pos)-1];
-            return `step ${c.parsed.x} → ${pos}${s != null ? ` (σ≈${s.toFixed(3)})` : ''}`;
-        });
-
-        // Interp tension
-        function getInterpMode() {
-            return $$(`#${id('interpolation')} select`)?.value || 'Linear';
-        }
-        function updateChartStyle(c = chart) {
-            const mode = getInterpMode();
-            const ds   = c.data.datasets[0];
-            if (mode === 'Step') {
-                ds.stepped = 'before'; ds.cubicInterpolationMode = 'default'; ds.tension = 0;
-            } else if (mode === 'Monotone') {
-                ds.stepped = false; ds.cubicInterpolationMode = 'monotone'; ds.tension = 0;
-            } else if (mode === 'Smooth (spline)') {
-                ds.stepped = false; ds.cubicInterpolationMode = 'default'; ds.tension = 0.4;
-            } else {
-                ds.stepped = false; ds.cubicInterpolationMode = 'default'; ds.tension = 0;
-            }
-            c.update();
-        }
-        const interpEl = $$(`#${id('interpolation')} select`);
-        if (interpEl) interpEl.addEventListener('change', () => updateChartStyle());
-        const schedEl = $$(`#${id('scheduler')} select`);
-        if (schedEl) schedEl.addEventListener('change', () => {
-            updateSigmaApprox(+step_ele.value, getScheduler());
-        });
-        const samplerEl = $$(`#${mode}_sampler select`);
-        if (samplerEl) samplerEl.addEventListener('change', () => {
-            updateSigmaApprox(+step_ele.value, getScheduler());
-        });
-
-        // ── История (Undo/Redo) ──────────────────────────────
-        const MAX_HIST = 20;
-        let hist = [], histIdx = -1;
-
-        function saveState(c) {
-            const snap = JSON.stringify(c.data.datasets[0].data);
-            if (hist[histIdx] === snap) return;
-            hist = hist.slice(0, histIdx+1);
-            hist.push(snap);
-            if (hist.length > MAX_HIST) hist.shift(); else histIdx++;
-        }
-        function undo(c) {
-            if (histIdx > 0) {
-                histIdx--;
-                c.data.datasets[0].data = JSON.parse(hist[histIdx]);
-                c.update(); triggerSync(c);
-            }
-        }
-        function redo(c) {
-            if (histIdx < hist.length-1) {
-                histIdx++;
-                c.data.datasets[0].data = JSON.parse(hist[histIdx]);
-                c.update(); triggerSync(c);
-            }
-        }
-
-        document.addEventListener('keydown', e => {
-            const tag = document.activeElement?.tagName;
-            if (tag==='INPUT'||tag==='TEXTAREA'||document.activeElement?.contentEditable==='true') return;
-            if (!enabled?.checked) return;
-            if (e.ctrlKey && e.key==='z' && !e.shiftKey) { e.preventDefault(); undo(chart); }
-            if (e.ctrlKey && ((e.key==='z' && e.shiftKey)||e.key==='y')) { e.preventDefault(); redo(chart); }
-        });
-
-        // ── Sync + Persist ──────────────────────────────────
-        let syncedData = null, pendingSync = null;
-
-        function _saveToDisk() {
-            try {
-                localStorage.setItem(`tm_curve:${mode}`, JSON.stringify(chart.data.datasets[0].data));
-                if (hr_chart) {
-                    localStorage.setItem(`tm_curve:${mode}:hr`, JSON.stringify(hr_chart.data.datasets[0].data));
-                }
-            } catch(e) { /* quota exceeded, silently ignore */ }
-        }
-
-        function _loadFromDisk() {
-            const saved = localStorage.getItem(`tm_curve:${mode}`);
-            if (saved) {
-                try {
-                    const pts = JSON.parse(saved);
-                    if (Array.isArray(pts) && pts.length >= 2) {
-                        chart.data.datasets[0].data = pts;
-                        updateSteps(chart, +step_ele.value);
-                        syncedData = JSON.stringify(chart.data.datasets[0].data);
-                        return;
-                    }
-                } catch(e) { /* ignore corrupt data */ }
-            }
-        }
-
-        function triggerSync(c, key='tm') {
-            const data = JSON.stringify(c.data.datasets[0].data);
-            if (key==='tm' && data===syncedData) return;
-            if (key==='tm_hr' && data===hr_syncedData) return;
-            const prom = lib.js2py(mode, key, data).then(() => {
-                if (key==='tm')    { syncedData    = data; pendingSync    = null; }
-                if (key==='tm_hr') { hr_syncedData = data; hr_pendingSync = null; }
-            }).catch(() => {
-                if (key==='tm')    pendingSync    = null;
-                if (key==='tm_hr') hr_pendingSync = null;
-            });
-            if (key==='tm')    pendingSync    = prom;
-            if (key==='tm_hr') hr_pendingSync = prom;
-            _saveToDisk();
-        }
-
-        // Hook плагина
-        const plugin = plugins[0];
-        const _oEnd = plugin.endDrag.bind(plugin);
-        plugin.endDrag = (c,a)=>{ _oEnd(c,a); saveState(c); triggerSync(c); };
-        const _oAdd = plugin.addPoint.bind(plugin);
-        plugin.addPoint = (c,a)=>{ _oAdd(c,a); saveState(c); triggerSync(c); };
-        const _oDel = plugin.removePoint.bind(plugin);
-        plugin.removePoint = (c,a)=>{ _oDel(c,a); saveState(c); triggerSync(c); };
-
-        // Инициализация
-        updateSteps(chart, +step_ele.value);
-        updateSigmaApprox(+step_ele.value, getScheduler());
-        _loadFromDisk();
-        saveState(chart);
-
-        let debounceTimer;
-        step_ele.addEventListener('input', () => {
-            updateSteps(chart, +step_ele.value);
-        updateSigmaApprox(+step_ele.value, getScheduler());
-            saveState(chart);
-            if (cutoffEl) cutoffEl.setAttribute('max', +step_ele.value);
-            clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(() => triggerSync(chart), 150);
-        });
-
-        // Обновление линии cutoff при изменении значения
-        if (cutoffEl) {
-            cutoffEl.addEventListener('input', () => {
-                chart.update();
-                if (hr_chart) hr_chart.update();
-            });
-        }
-
-        // ── HR Fix график ────────────────────────────────────
-        let hr_chart = null, hr_syncedData = null, hr_pendingSync = null;
-        const hr_container = $$('#' + id('hr_container'));
-
-        if (hr_container) {
-            const hr_step_raw = $$(`#${mode}_hires_steps input[type=number]`);
-            const hr_step     = hr_step_raw || step_ele;
-
-            const hr_canvas = document.createElement('canvas');
-            hr_canvas.width = 512; hr_canvas.height = 512;
-            const hr_plugins = createPlugins(hr_canvas, hr_step, cutoffEl);
-
-            hr_chart = new Chart(hr_canvas.getContext('2d'), {
-                type: 'scatter', data: createInitialData(),
-                options: createChartOption(), plugins: hr_plugins,
-            });
-
-            hr_chart.options.scales.y.ticks.callback = v => {
-                if (!showSigma || v < 1 || v > approxSigmas.length-1) return v;
-                const s = approxSigmas[Math.round(v)-1];
-                return s == null ? v : s < 1 ? s.toFixed(3) : s.toFixed(1);
-            };
-            hr_chart.options.plugins.tooltip.callbacks.title = ctxs => ctxs.map(c => {
-                const pos = c.parsed.y;
-                if (!showSigma) return `HR step ${c.parsed.x} → ${pos}`;
-                const s = approxSigmas[Math.round(pos)-1];
-                return `HR step ${c.parsed.x} → ${pos}${s != null ? ` (σ≈${s.toFixed(3)})` : ''}`;
-            });
-
-            hr_container.appendChild(hr_canvas);
-            updateSteps(hr_chart, +hr_step.value || +step_ele.value);
-
-            // Load persisted HR curve
-            const savedHr = localStorage.getItem(`tm_curve:${mode}:hr`);
-            if (savedHr) {
-                try {
-                    const pts = JSON.parse(savedHr);
-                    if (Array.isArray(pts) && pts.length >= 2) {
-                        hr_chart.data.datasets[0].data = pts;
-                        updateSteps(hr_chart, +hr_step.value || +step_ele.value);
-                        hr_syncedData = JSON.stringify(hr_chart.data.datasets[0].data);
-                    }
-                } catch(e) { /* ignore */ }
-            }
-
-            const hr_plugin = hr_plugins[0];
-            const _hoEnd = hr_plugin.endDrag.bind(hr_plugin);
-            hr_plugin.endDrag = (c,a)=>{ _hoEnd(c,a); triggerSync(c,'tm_hr'); };
-            const _hoAdd = hr_plugin.addPoint.bind(hr_plugin);
-            hr_plugin.addPoint = (c,a)=>{ _hoAdd(c,a); triggerSync(c,'tm_hr'); };
-            const _hoDel = hr_plugin.removePoint.bind(hr_plugin);
-            hr_plugin.removePoint = (c,a)=>{ _hoDel(c,a); triggerSync(c,'tm_hr'); };
-
-            hr_step.addEventListener('input', () => {
-                updateSteps(hr_chart, +hr_step.value || +step_ele.value);
-                triggerSync(hr_chart, 'tm_hr');
-            });
-
-            // Синхронизируем tension HR графика с основным
-            if (interpEl) interpEl.addEventListener('change', () => updateChartStyle(hr_chart));
-        }
-
-        // ── Generate button ─────────────────────────────────
-        let generating = false;
-        gradioApp().addEventListener('click', async e => {
-            if (e.target !== generate_button) return;
-            if (!enabled?.checked) return;
-            if (generating) { generating = false; return; }
-
-            const mainData = JSON.stringify(chart.data.datasets[0].data);
-            const hrData   = hr_chart ? JSON.stringify(hr_chart.data.datasets[0].data) : null;
-            const needMain = mainData !== syncedData;
-            const needHR   = hrData !== null && hrData !== hr_syncedData;
-
-            if (needMain || needHR) {
-                e.preventDefault(); e.stopPropagation();
-                await Promise.all([
-                    needMain ? (pendingSync    || lib.js2py(mode,'tm',   mainData).then(()=>syncedData   =mainData)) : Promise.resolve(),
-                    needHR   ? (hr_pendingSync || lib.js2py(mode,'tm_hr',hrData  ).then(()=>hr_syncedData=hrData  )) : Promise.resolve(),
-                ]);
-                generating = true; generate_button.click();
-            }
-        }, true);
-
-        // ── Нижняя панель ───────────────────────────────────
-        const PRESETS = {
-            'Linear (Default)': n => [{x:1,y:1},{x:n,y:n}],
-            'Detail Enhancer':  n => [{x:1,y:1},{x:Math.max(2,Math.round(n*.25)),y:Math.round(n*.7)},{x:n,y:n}],
-            'Composition Lock': n => [{x:1,y:1},{x:Math.round(n*.75),y:Math.max(2,Math.round(n*.25))},{x:n,y:n}],
-            'Time Travel':      n => [{x:1,y:1},{x:Math.round(n*.35),y:Math.round(n*.35)},{x:Math.round(n*.5),y:Math.max(1,Math.round(n*.15))},{x:Math.round(n*.65),y:Math.round(n*.35)},{x:n,y:n}],
-            'Early Burst':      n => [{x:1,y:1},{x:Math.round(n*.5),y:Math.round(n*.9)},{x:n,y:n}],
-        };
-
-        function makeBtn(label, title, onClick) {
-            const b = document.createElement('button');
-            b.textContent = label; b.type = 'button'; b.title = title || label;
-            b.style.cssText = 'padding:3px 10px;border-radius:4px;cursor:pointer;font-size:12px';
-            b.addEventListener('click', onClick); return b;
-        }
-
-        const bar = document.createElement('div');
-        bar.style.cssText = 'display:flex;gap:6px;align-items:center;margin:6px 0 0;flex-wrap:wrap;font-size:13px';
-
-        // ── Пресеты (built-in + custom из localStorage) ─────
-        function _storageKeys(prefix) {
-            const keys = [];
-            for (let i = 0; i < localStorage.length; i++) {
-                const k = localStorage.key(i);
-                if (k && k.startsWith(prefix)) keys.push(k);
-            }
-            return keys;
-        }
-
-        function _loadCustomPresets() {
-            const out = {};
-            for (const k of _storageKeys('tm_presets:')) {
-                const name = k.slice('tm_presets:'.length);
-                try {
-                    const raw = JSON.parse(localStorage.getItem(k));
-                    let pts, savedN;
-                    if (Array.isArray(raw)) {
-                        pts = raw;
-                        savedN = Math.max(...pts.map(p => p.x));
-                    } else if (raw && Array.isArray(raw.points) && raw.points.length >= 2) {
-                        pts = raw.points;
-                        savedN = raw.savedN || Math.max(...pts.map(p => p.x));
-                    } else {
-                        continue;
-                    }
-                    if (pts.length >= 2) {
-                        out[name] = (n) => {
-                            if (n === savedN || savedN <= 1) return pts;
-                            const scale = (n - 1) / (savedN - 1);
-                            return pts.map(p => ({
-                                ...p,
-                                x: Math.max(1, Math.min(n, Math.round(1 + (p.x - 1) * scale))),
-                            }));
-                        };
-                    }
-                } catch(e) { /* ignore */ }
-            }
-            return out;
-        }
-
-        function _rebuildPresetDropdown() {
-            while (presetSel.firstChild) presetSel.removeChild(presetSel.firstChild);
-            // Built-in
-            Object.keys(PRESETS).forEach(n => {
-                const o = document.createElement('option'); o.value = n; o.textContent = n;
-                presetSel.appendChild(o);
-            });
-            // Custom
-            const custom = _loadCustomPresets();
-            const cKeys = Object.keys(custom);
-            if (cKeys.length) {
-                const grp = document.createElement('optgroup'); grp.label = '-- Saved --';
-                cKeys.forEach(n => {
-                    const o = document.createElement('option'); o.value = n; o.textContent = n;
-                    grp.appendChild(o);
-                });
-                presetSel.appendChild(grp);
-            }
-            // Store custom map on the select for the apply handler
-            presetSel._custom = custom;
-        }
-
-        const presetSel = document.createElement('select');
-        presetSel.style.cssText = 'padding:3px 6px;border-radius:4px;cursor:pointer;flex:1;min-width:120px';
-        _rebuildPresetDropdown();
-
-        const applyBtn = makeBtn('Apply', 'Применить пресет', () => {
-            const name = presetSel.value;
-            const fn = PRESETS[name] || presetSel._custom[name];
-            if (!fn) return;
-            const n = Math.max(2, +step_ele.value);
-            chart.data.datasets[0].data = fn(n);
-            updateSteps(chart, n);
-            saveState(chart); updateChartStyle(); triggerSync(chart);
-        });
-
-        const savePresetBtn = makeBtn('Save', 'Сохранить как пресет', () => {
-            const name = prompt('Название пресета:', '');
-            if (!name) return;
-            try {
-                const pts = chart.data.datasets[0].data.map(p => ({...p}));
-                localStorage.setItem(`tm_presets:${name}`, JSON.stringify({
-                    savedN: Math.max(2, +step_ele.value),
-                    points: pts,
-                }));
-            } catch(e) { alert('Не удалось сохранить пресет (превышен лимит localStorage).'); return; }
-            _rebuildPresetDropdown();
-            presetSel.value = name;
-        });
-
-        const delPresetBtn = makeBtn('Del', 'Удалить выбранный пресет', () => {
-            const name = presetSel.value;
-            if (!presetSel._custom[name]) return;
-            if (!confirm(`Удалить пресет "${name}"?`)) return;
-            localStorage.removeItem(`tm_presets:${name}`);
-            _rebuildPresetDropdown();
-        });
-
-        const resetBtn = makeBtn('Reset', 'Сбросить кривую к прямой', () => {
-            const n = Math.max(2, +step_ele.value);
-            chart.data.datasets[0].data = [{x:1,y:1},{x:n,y:n}];
-            saveState(chart); updateChartStyle(); triggerSync(chart);
-        });
-
-        // Undo / Redo
-        const undoBtn = makeBtn('Undo', 'Отменить (Ctrl+Z)', () => undo(chart));
-        const redoBtn = makeBtn('Redo', 'Повторить (Ctrl+Shift+Z)', () => redo(chart));
-
-        // Separator
-        const sep = () => { const s = document.createElement('span'); s.textContent='|'; s.style.opacity='.3'; return s; };
-
-        // Export
-        const exportBtn = makeBtn('Export', 'Сохранить кривую в JSON', () => {
-            const n = prompt('Название пресета:', 'my_curve') || 'my_curve';
-            const data = {
-                name: n, version: 1,
-                points: chart.data.datasets[0].data,
-                interpolation: getInterpMode(),
-            };
-            const blob = new Blob([JSON.stringify(data, null, 2)], {type:'application/json'});
-            const url  = URL.createObjectURL(blob);
-            const a    = document.createElement('a');
-            a.href = url; a.download = `${n.replace(/\s+/g,'_')}.json`; a.click();
-            URL.revokeObjectURL(url);
-        });
-
-        // Import
-        const importBtn = makeBtn('Import', 'Загрузить кривую из JSON', () => {
-            const inp = document.createElement('input');
-            inp.type = 'file'; inp.accept = '.json';
-            inp.addEventListener('change', () => {
-                const file = inp.files[0]; if (!file) return;
-                const reader = new FileReader();
-                reader.onload = ev => {
-                    try {
-                        const d = JSON.parse(ev.target.result);
-                        if (!Array.isArray(d.points)) return;
-                        const n = Math.max(2, +step_ele.value);
-                        const pts = d.points.filter(p => p.x>=1&&p.x<=n&&p.y>=1&&p.y<=n);
-                        chart.data.datasets[0].data = pts;
-                        updateSteps(chart, n);
-                        saveState(chart); triggerSync(chart);
-                    } catch(err) { console.error('[TimeMachine] Import error:', err); }
-                };
-                reader.readAsText(file);
-            });
-            inp.click();
-        });
-
-        // Show sigma
-        const sigmaBtn = makeBtn('Sigma', 'Показать σ-значения на оси Y (реальные через HTTP, fallback Karras)', () => {
-            showSigma = !showSigma;
-            sigmaBtn.textContent = showSigma ? 'Step' : 'Sigma';
-            chart.update(); if (hr_chart) hr_chart.update();
-        });
-
-        // ── Panel system ────────────────────────────────────────────────
-        let _panelDiv = null;
-        function _closePanel() { if (_panelDiv) { _panelDiv.remove(); _panelDiv = null; } }
-
-        function _openPanel(title, buildFn) {
-            _closePanel();
-            const d = document.createElement('div');
-            d.id = id('panel');
-            d.style.cssText = 'padding:8px;margin:4px 0;border:1px solid rgba(255,140,0,0.3);border-radius:6px;background:rgba(255,140,0,0.05);font-size:13px';
-            const h = document.createElement('div');
-            h.style.cssText = 'font-weight:bold;margin-bottom:6px';
-            h.textContent = title;
-            d.appendChild(h);
-            buildFn(d);
-            $('#' + id('container')).appendChild(d);
-            _panelDiv = d;
-        }
-
-        // ── Gen… (procedural curves) ────────────────────────────────────
-        const genBtn = makeBtn('Gen…', 'Сгенерировать кривую (синус / случайная)', () => {
-            let prevData = chart.data.datasets[0].data.slice();
-            function getN() { return Math.max(2, +step_ele.value); }
-
-            function _sine(freq, amp) {
-                const n = getN();
-                const pts = [{x:1,y:1}];
-                for (let x = 2; x < n; x++) {
-                    const t = (x-1)/(n-1);
-                    const mid = 1 + (n-1)*t;
-                    const y = Math.round(mid + amp*(n-1)*Math.sin(2*Math.PI*freq*t));
-                    pts.push({x, y: Math.max(1, Math.min(n, y))});
-                }
-                pts.push({x:n, y:n});
-                return pts;
-            }
-
-            function _walk(stepSz, seed) {
-                const n = getN();
-                let rng = seed || Date.now();
-                function rand() { rng ^= rng<<13; rng ^= rng>>17; rng ^= rng<<5; return (rng>>>0)/4294967296; }
-                const pts = [{x:1,y:1}];
-                let y = 1;
-                for (let x = 2; x < n; x++) {
-                    y += (rand()-0.5)*2*stepSz;
-                    y = Math.max(1, Math.min(n, Math.round(y)));
-                    pts.push({x, y});
-                }
-                pts.push({x:n, y:n});
-                return pts;
-            }
-
-            _openPanel('Generate Curve', panel => {
-                const row1 = document.createElement('div');
-                row1.style.cssText = 'display:flex;gap:6px;align-items:center;margin-bottom:4px';
-                const sel = document.createElement('select');
-                sel.innerHTML = '<option>Sine</option><option>Random walk</option>';
-
-                const p1Label = document.createElement('span');
-                p1Label.style.cssText = 'width:55px;text-align:right';
-                const p1 = document.createElement('input');
-                p1.type = 'range'; p1.min = 0.5; p1.max = 10; p1.step = 0.5; p1.value = 2;
-
-                const p2Label = document.createElement('span');
-                p2Label.style.cssText = 'width:55px;text-align:right';
-                const p2 = document.createElement('input');
-                p2.type = 'range'; p2.min = 0; p2.max = 1; p2.step = 0.05; p2.value = 0.3;
-
-                function updateLabels() {
-                    if (sel.value === 'Sine') {
-                        p1Label.textContent = `Freq: ${p1.value}`;
-                        p1.min = 0.5; p1.max = 10; p1.step = 0.5;
-                        p2Label.textContent = `Amp: ${p2.value}`;
-                        p2.min = 0; p2.max = 1; p2.step = 0.05;
-                    } else {
-                        p1Label.textContent = `Step: ${p1.value}`;
-                        p1.min = 0.1; p1.max = 5; p1.step = 0.1;
-                        p2Label.textContent = `Seed: ${p2.value}`;
-                        p2.min = 0; p2.max = 9999; p2.step = 1;
-                    }
-                }
-
-                function preview() {
-                    const n = getN();
-                    const pts = sel.value === 'Sine' ? _sine(+p1.value, +p2.value) : _walk(+p1.value, +p2.value);
-                    chart.data.datasets[0].data = pts;
-                    updateSteps(chart, n);
-                    chart.update();
-                }
-
-                sel.addEventListener('change', () => { updateLabels(); preview(); });
-                p1.addEventListener('input', () => { updateLabels(); preview(); });
-                p2.addEventListener('input', () => { updateLabels(); preview(); });
-                updateLabels(); preview();
-
-                const apply = makeBtn('Apply', '', () => {
-                    saveState(chart); updateChartStyle(); triggerSync(chart);
-                    _closePanel();
-                });
-                const cancel = makeBtn('Cancel', '', () => {
-                    const n = getN();
-                    chart.data.datasets[0].data = prevData;
-                    updateSteps(chart, n); chart.update();
-                    _closePanel();
-                });
-                row1.append(sel, p1Label, p1, p2Label, p2, apply, cancel);
-                panel.appendChild(row1);
-            });
-        });
-
-        // ── Rasterize control points → dense array of length n ───────
-        const _WEIGHT = {
-            'Ease In':     t => t * t,
-            'Ease Out':    t => 1 - (1-t)*(1-t),
-            'Ease In-Out': t => t*t*(3-2*t),
-            'Cubic':       t => t*t*t,
-            'Exponential': t => Math.pow(2,t)-1,
-            'Step':        t => 0,
-        };
-
-        function _rasterize(pts, n) {
-            const sorted = [...pts].sort((a,b)=>a.x-b.x);
-            const out = [];
-            let si = 0;
-            for (let x = 1; x <= n; x++) {
-                while (si < sorted.length-2 && sorted[si+1].x <= x) si++;
-                const p0 = sorted[si], p1 = sorted[Math.min(si+1, sorted.length-1)];
-                let y;
-                if (p0.x === p1.x) { y = p0.y; }
-                else {
-                    const mode = p0.mode || '';
-                    const t = (x-p0.x)/(p1.x-p0.x);
-                    if (mode === 'Step') { y = p0.y; }
-                    else {
-                        const w = _WEIGHT[mode] || (t => t);
-                        y = p0.y + w(t) * (p1.y - p0.y);
-                    }
-                }
-                out.push({x, y: Math.max(1, Math.min(n, Math.round(y)))});
-            }
-            return out;
-        }
-
-        // ── Blend… ──────────────────────────────────────────────────────
-        const blendBtn = makeBtn('Blend…', 'Смешать два пресета', () => {
-            const n = Math.max(2, +step_ele.value);
-            let prevData = chart.data.datasets[0].data.slice();
-            const allPresets = {...PRESETS, ...presetSel._custom};
-            const names = Object.keys(allPresets);
-
-            _openPanel('Blend Presets', panel => {
-                const row = document.createElement('div');
-                row.style.cssText = 'display:flex;gap:6px;align-items:center;flex-wrap:wrap';
-
-                const sA = document.createElement('select');
-                const sB = document.createElement('select');
-                names.forEach(name => { sA.innerHTML += `<option>${name}</option>`; sB.innerHTML += `<option>${name}</option>`; });
-                if (names.length > 1) sB.selectedIndex = 1;
-
-                const sl = document.createElement('input');
-                sl.type = 'range'; sl.min = 0; sl.max = 100; sl.value = 50;
-                const slLabel = document.createElement('span');
-                slLabel.style.cssText = 'width:40px';
-
-                function _getPresetFn(name) { return PRESETS[name] || presetSel._custom[name]; }
-
-                function _blend() {
-                    const fnA = _getPresetFn(sA.value);
-                    const fnB = _getPresetFn(sB.value);
-                    if (!fnA || !fnB) return null;
-                    const cA = fnA(n), cB = fnB(n);
-                    const denseA = _rasterize(cA, n);
-                    const denseB = _rasterize(cB, n);
-                    const t = +sl.value / 100;
-                    slLabel.textContent = `${sl.value}%`;
-                    return denseA.map((pt, i) => ({
-                        x: pt.x,
-                        y: Math.round(pt.y*(1-t) + denseB[i].y*t),
-                    }));
-                }
-
-                function preview() { const pts = _blend(); if (pts) { chart.data.datasets[0].data = pts; updateSteps(chart, n); chart.update(); } }
-
-                sA.addEventListener('change', preview);
-                sB.addEventListener('change', preview);
-                sl.addEventListener('input', preview);
-                preview();
-
-                const apply = makeBtn('Apply', '', () => { saveState(chart); updateChartStyle(); triggerSync(chart); _closePanel(); });
-                const cancel = makeBtn('Cancel', '', () => { chart.data.datasets[0].data = prevData; updateSteps(chart, n); chart.update(); _closePanel(); });
-
-                row.append(sA, sB, sl, slLabel, apply, cancel);
-                panel.appendChild(row);
-            });
-        });
-
-        bar.append(presetSel, applyBtn, savePresetBtn, delPresetBtn, resetBtn, sep(), undoBtn, redoBtn, sep(), exportBtn, importBtn, sep(), sigmaBtn, genBtn, blendBtn);
-        $('#' + id('container')).appendChild(bar);
-
-        // ── One-shot: автосброс Enabled после генерации ────────────────
-        // Паттерн из script.js A1111: следим за interruptBtn.style.display
-        if (oneShotEl) {
-            const interruptBtn = gradioApp().querySelector(`#${mode}_interrupt`);
-            if (interruptBtn) {
-                let wasGen = false;
-                new MutationObserver(() => {
-                    const isGen = interruptBtn.style.display === 'block';
-                    if (isGen && !wasGen) {
-                        wasGen = true;
-                    } else if (!isGen && wasGen) {
-                        wasGen = false;
-                        if (oneShotEl.checked && enabled?.checked) {
-                            enabled.checked = false;
-                            enabled.dispatchEvent(new Event('change', { bubbles: true }));
-                        }
-                    }
-                }).observe(interruptBtn, { attributes: true, attributeFilter: ['style'] });
-            }
-        }
-    }
-
-    // ── Общие функции ────────────────────────────────────────────────
-
-    function createInitialData() {
-        return { datasets: [{
-            type:'line', showLine:true, tension:0,
-            backgroundColor:'rgba(255,140,0,.6)', borderColor:'rgba(255,140,0,.6)',
-            borderWidth:2, borderCapStyle:'round', borderJoinStyle:'round',
-            borderDash:[], borderDashOffset:0,
-            pointBorderColor:'rgba(255,140,0,.6)', pointBackgroundColor:'rgba(255,140,0,.6)',
-            pointBorderWidth:1, pointHoverBorderWidth:10, pointRadius:5, pointHitRadius:10,
-            fill:false, data:[],
-        }]};
-    }
-
-    function createChartOption() {
-        return {
-            responsive:false,
-            events:['mouseup','mousedown','mousemove','mouseout','click','touchstart','touchmove'],
-            scales:{
-                x:{type:'linear',display:true,title:{display:true,text:'timesteps'},ticks:{major:{enabled:true}},min:0,max:100,stepSize:10},
-                y:{type:'linear',display:true,title:{display:true,text:'actual timesteps'},ticks:{major:{enabled:true}},min:0,max:100,stepSize:10},
-            },
-            chartArea:{backgroundColor:'rgba(255,255,255,1)'},
-            animation:{duration:100},
-            plugins:{legend:{display:false},tooltip:{callbacks:{
-                title:ctxs=>ctxs.map(c=>`${c.parsed.x} → ${c.parsed.y}`), label:()=>'',
-            }}},
-        };
-    }
-
-    function createPlugins(canvas, step_ele, cutoffEl) {
-        const plugins = [{
-            id:'dragpoint',
-            beforeEvent(chart, args) {
-                const t = args.event.type;
-                if (t === 'mousedown') {
-                    const btn = args.event.native.button;
-                    if      (btn===0) this.startDrag(chart, args);
-                    else if (btn===2) this.removePoint(chart, args);
-                } else if (t==='mouseup'||t==='mouseout') {
-                    if (this.dragctx.item) this.endDrag(chart, args);
-                } else if (t==='mousemove') {
-                    if (this.dragctx.item) this.onDrag(chart, args);
-                }
-            },
-            afterDraw(chart) {
-                const ctx = chart.ctx; ctx.save();
-                // Cutoff line
-                const cs = cutoffEl ? +cutoffEl.value : 0;
-                if (cs > 0) {
-                    const xa = chart.scales.x, ya = chart.scales.y, x = xa.getPixelForValue(cs);
-                    ctx.beginPath(); ctx.setLineDash([6, 4]); ctx.strokeStyle = 'rgba(220,50,50,0.6)';
-                    ctx.lineWidth = 2; ctx.moveTo(x, ya.top); ctx.lineTo(x, ya.bottom); ctx.stroke();
-                }
-                // Per-segment mode indicators
-                const data = chart.data.datasets[0].data;
-                for (let i = 0; i < data.length - 1; i++) {
-                    const mode = data[i].mode;
-                    if (!mode) continue;
-                    const x0 = chart.scales.x.getPixelForValue(data[i].x);
-                    const y0 = chart.scales.y.getPixelForValue(data[i].y);
-                    const x1 = chart.scales.x.getPixelForValue(data[i+1].x);
-                    const y1 = chart.scales.y.getPixelForValue(data[i+1].y);
-                    const mx = (x0+x1)/2, my = (y0+y1)/2;
-                    ctx.beginPath(); ctx.arc(mx, my, 5, 0, 2*Math.PI);
-                    ctx.fillStyle = '#ff8c00'; ctx.fill();
-                    ctx.strokeStyle = '#fff'; ctx.lineWidth = 1; ctx.stroke();
-                    ctx.fillStyle = '#fff';
-                    ctx.font = 'bold 8px sans-serif';
-                    ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
-                    ctx.fillText(mode[0], mx, my);
-                }
-                ctx.restore();
-            },
-            dragctx:{item:null, max_steps:()=>Math.max(1,+step_ele.value)},
-            lastRemoved:false,
-            startDrag(chart,args){const item=this.getItem(chart,args);if(item)this.dragctx.item=item;else this.addPoint(chart,args);},
-            onDrag(chart,args){const y=this.getY(chart,args);const{datasetIndex,index}=this.dragctx.item;const item=chart.data.datasets[datasetIndex].data[index];if(item.y!==y){item.y=y;chart.update();}},
-            endDrag(chart){this.dragctx.item=null;},
-            addPoint(chart,args){const x=this.getX(chart,args),y=this.getY(chart,args);const found=chart.data.datasets[0].data.find(v=>v.x===x);if(found){if(found.y!==y){found.y=y;chart.update();}}else this.addItem(chart,{x,y});},
-            removePoint(chart,args){const item_=this.getItem(chart,args);if(item_){const{datasetIndex,index}=item_;const item=chart.data.datasets[datasetIndex].data[index];if(1<item.x&&item.x<this.dragctx.max_steps()){this.lastRemoved=true;chart.data.datasets[datasetIndex].data.splice(index,1);chart.update();}}},
-            getX(chart,args){const xx=chart.scales.x.getValueForPixel(args.event.native.clientX-chart.canvas.getBoundingClientRect().left);return Math.max(1,Math.min(Math.round(xx),this.dragctx.max_steps()));},
-            getY(chart,args){const yy=chart.scales.y.getValueForPixel(args.event.native.clientY-chart.canvas.getBoundingClientRect().top);return Math.max(1,Math.min(Math.round(yy),this.dragctx.max_steps()));},
-            getItem(chart,args){const items=chart.getElementsAtEventForMode(args.event,'nearest',{intersect:true},false);return items.length===0?null:items[0];},
-            addItem(chart,xy,donotupdate){chart.data.datasets[0].data.push(xy);chart.data.datasets[0].data.sort((a,b)=>a.x-b.x);if(!donotupdate)chart.update();},
-        }];
-
-        return plugins;
-    }
-
-    function updateSteps(chart, max_steps) {
-        max_steps = Math.max(2, max_steps);
-        chart.options.scales.x.max = max_steps+1;
-        chart.options.scales.y.max = max_steps+1;
-        const data = chart.data.datasets[0].data;
-        const new_data = [];
-        for (const pt of data) if(1<=pt.x&&pt.x<=max_steps) new_data.push({...pt, y:Math.min(pt.y,max_steps)});
-        if (!new_data.find(c=>c.x===1))         new_data.unshift({x:1,        y:1});
-        if (!new_data.find(c=>c.x===max_steps)) new_data.push   ({x:max_steps,y:max_steps});
-        chart.data.datasets[0].data = new_data;
-        chart.update();
-    }
-
-})('TimeMachine');

sd-webui-timemachine-fixed/scripts/timemachine.py

@@ -1,372 +0,0 @@
-from __future__ import annotations
-
-import os
-import json
-import bisect
-from typing import Any, List, Callable
-
-import gradio as gr
-
-from modules.processing import StableDiffusionProcessing
-from modules import scripts, extensions, script_callbacks
-from fastapi.responses import JSONResponse
-
-from scripts.timemachinelib import sampler as sampler_utils
-from scripts.timemachinelib.xyz import init_xyz
-
-NAME         = 'TimeMachine'
-_UNSUPPORTED = sampler_utils.UNSUPPORTED_SAMPLERS
-
-
-class Script(scripts.Script):
-
-    def title(self):
-        return NAME
-
-    def show(self, is_img2img):
-        return scripts.AlwaysVisible
-
-    def ui(self, is_img2img):
-        ext = _get_self_extension()
-        if ext is not None and not is_img2img:
-            js_ = [f'{x.path}?{os.path.getmtime(x.path)}'
-                   for x in ext.list_files('javascript/modules', '.js')]
-            js_.insert(0, ext.path)
-            gr.HTML(value='\n'.join(js_), elem_id=f'{NAME.lower()}-js_modules')
-
-        mode = 'img2img' if is_img2img else 'txt2img'
-        id_  = lambda x: f'{NAME.lower()}-{mode}-{x}'
-        js_  = lambda s: f'globalThis["{id_(s)}"]'
-
-        with gr.Accordion(NAME, open=False, elem_id=id_('accordion')):
-            with gr.Row():
-                enabled = gr.Checkbox(label='Enabled', value=False, elem_id=id_('enabled'))
-                scheduler = gr.Dropdown(
-                    label='Scheduler', choices=sampler_utils.get_scheduler_choices(),
-                    value='Use sampler default', elem_id=id_('scheduler'))
-                interp_mode = gr.Dropdown(
-                    label='Interpolation', choices=['Linear', 'Smooth (spline)', 'Step', 'Monotone', 'Ease In', 'Ease Out', 'Ease In-Out', 'Cubic', 'Exponential'],
-                    value='Linear', elem_id=id_('interpolation'))
-
-            with gr.Row():
-                cutoff_steps = gr.Number(
-                    label='Cutoff step (0=off)', value=0, minimum=0, maximum=150,
-                    step=1, elem_id=id_('cutoff'))
-                hr_cutoff_cb = gr.Checkbox(
-                    label='HR Cutoff', value=True, elem_id=id_('hr_cutoff'))
-                one_shot = gr.Checkbox(
-                    label='One-shot', value=False, elem_id=id_('one_shot'))
-
-            gr.HTML(elem_id=id_('container'))
-
-            with gr.Accordion('HR Fix Curve (txt2img only)', open=False,
-                              elem_id=id_('hr_accordion')):
-                hr_enabled = gr.Checkbox(
-                    label='Use separate curve for HR pass', value=False,
-                    elem_id=id_('hr_enabled'))
-                gr.HTML(elem_id=id_('hr_container'))
-
-            with gr.Group(visible=False):
-                sink    = gr.HTML(value='')
-                tm      = _js2py('tm',    id_, js_, sink)
-                hr_sink = gr.HTML(value='')
-                tm_hr   = _js2py('tm_hr', id_, js_, hr_sink)
-
-        return [enabled, scheduler, interp_mode, tm, hr_enabled, tm_hr, cutoff_steps, hr_cutoff_cb, one_shot]
-
-    def process_batch(
-        self,
-        p: StableDiffusionProcessing,
-        enabled: bool,
-        scheduler: str,
-        interp_mode: str,
-        tm: str,
-        hr_enabled: bool,
-        tm_hr: str,
-        cutoff_steps: int = 0,
-        hr_cutoff_enabled: bool = True,
-        one_shot: bool = False,
-        **kwargs,
-    ):
-        if not enabled:
-            return
-        if not tm or not tm.strip():
-            return
-        if p.sampler_name in _UNSUPPORTED:
-            msg = (f'⚠ {p.sampler_name!r} несовместим: '
-                   f'принимает sigma_min/max/n, не массив sigmas. '
-                   f'Используйте: Euler, DPM++ 2M, DPM++ SDE, Heun, LMS и др.')
-            print(f'\n[TimeMachine] {msg}\n')
-            gr.Warning(f'[TimeMachine] {msg}')
-            return
-
-        vs = _parse_points(tm)
-        if vs is None:
-            return
-
-        if len(vs) < 2 or 1 not in vs or p.steps not in vs:
-            points = [{'x': k, 'y': v['y'], 'mode': v.get('mode')} for k, v in sorted(vs.items())]
-            msg = (f'Кривая должна содержать точки x=1 и x={p.steps} '
-                   f'(текущие x: {[p["x"] for p in points]})')
-            print(f'[TimeMachine] {msg}')
-            gr.Warning(f'[TimeMachine] {msg}')
-            return
-
-        steps_float = _interpolate(vs, p.steps, interp_mode)
-        if len(steps_float) != p.steps:
-            return
-
-        cs = int(cutoff_steps)
-        steps_float = _apply_cutoff(steps_float, cs, p.steps)
-
-        if scheduler == 'Use sampler default':
-            sched_name = sampler_utils.get_default_scheduler_for(p.sampler_name)
-        else:
-            from modules import sd_schedulers
-            sched_name = next(
-                (s.name for s in sd_schedulers.schedulers if s.label == scheduler),
-                'karras')
-
-        override_main = sampler_utils.build_sigma_override(steps_float, sched_name)
-        override_hr   = _build_hr_override(p, hr_enabled, tm_hr, interp_mode, sched_name, cs, hr_cutoff_enabled)
-
-        if override_hr is not None:
-            def combined(n: int):
-                return override_hr(n) if getattr(p, 'is_hr_pass', False) else override_main(n)
-            p.sampler_noise_scheduler_override = combined
-        else:
-            p.sampler_noise_scheduler_override = override_main
-
-        p._timemachine_override_set = True
-        p.extra_generation_params.update({
-            f'{NAME} Enabled':       True,
-            f'{NAME} Interpolation': interp_mode,
-            f'{NAME} Steps':         [round(t, 3) for t in steps_float],
-            f'{NAME} Scheduler':     sched_name,
-            f'{NAME} Cutoff':        cs,
-            f'{NAME} One-shot':      one_shot,
-        })
-
-    def postprocess_batch(self, p, *args, **kwargs):
-        if getattr(p, '_timemachine_override_set', False):
-            p.sampler_noise_scheduler_override = None
-            p._timemachine_override_set = False
-
-
-# ── Интерполяция ──────────────────────────────────────────
-
-def _sliding_pairs(xs):
-    for i in range(len(xs) - 1):
-        yield xs[i], xs[i + 1]
-
-
-def _find_segment(xs: list, step: int) -> int:
-    i = bisect.bisect_right(xs, step) - 1
-    return max(0, min(i, len(xs) - 2))
-
-
-_WEIGHT_FUNCS: dict[str, Callable[[float], float]] = {
-    'Ease In':       lambda t: t * t,
-    'Ease Out':      lambda t: 1.0 - (1.0 - t) * (1.0 - t),
-    'Ease In-Out':   lambda t: t * t * (3.0 - 2.0 * t),
-    'Cubic':         lambda t: t ** 3,
-    'Exponential':   lambda t: 2.0 ** t - 1.0,
-}
-_GLOBAL_MODES = frozenset({'Smooth (spline)', 'Step', 'Monotone'})
-
-
-def _interpolate_segments(vs: dict, n: int, default_mode: str = 'Linear', ignore_per_segment: bool = False) -> List[float]:
-    default_weight_fn = _WEIGHT_FUNCS.get(default_mode, lambda t: t)
-    steps: List[float] = []
-    for min_x, max_x in _sliding_pairs(sorted(vs.keys())):
-        min_y, max_y = float(vs[min_x]['y']), float(vs[max_x]['y'])
-        seg_mode = default_mode if ignore_per_segment else (vs[min_x].get('mode') or default_mode)
-        if seg_mode == 'Step':
-            for step in range(min_x, max_x):
-                steps.append(min_y)
-        else:
-            wfn = _WEIGHT_FUNCS.get(seg_mode, default_weight_fn)
-            for step in range(min_x, max_x):
-                t = (step - min_x) / (max_x - min_x)
-                steps.append(min_y + wfn(t) * (max_y - min_y))
-    steps.append(float(vs[n]['y']))
-    return steps
-
-
-def _interpolate(vs: dict, n: int, mode: str) -> List[float]:
-    if mode == 'Smooth (spline)': return _compute_remapped_steps_spline(vs, n)
-    if mode == 'Step':            return _compute_remapped_steps_step(vs, n)
-    if mode == 'Monotone':        return _compute_remapped_steps_monotone(vs, n)
-    return _interpolate_segments(vs, n, mode)
-
-
-def _compute_remapped_steps_step(vs: dict, n: int) -> List[float]:
-    return _interpolate_segments(vs, n, default_mode='Step', ignore_per_segment=True)
-
-
-def _compute_remapped_steps_monotone(vs: dict, n: int) -> List[float]:
-    xs = sorted(vs.keys())
-    ys = [float(vs[x]['y']) for x in xs]
-    k  = len(xs)
-
-    if k == 2:
-        return _interpolate_segments(vs, n, ignore_per_segment=True)
-
-    h     = [xs[i+1] - xs[i]          for i in range(k-1)]
-    delta = [(ys[i+1]-ys[i]) / h[i]   for i in range(k-1)]
-
-    m = [0.0] * k
-    m[0]   = delta[0]
-    m[k-1] = delta[k-2]
-    for i in range(1, k-1):
-        p = (delta[i-1]*h[i] + delta[i]*h[i-1]) / (h[i-1]+h[i])
-        if delta[i-1]*delta[i] <= 0:
-            m[i] = 0.0
-        else:
-            sign = 1.0 if p >= 0 else -1.0
-            m[i] = sign * min(abs(p), 2*abs(delta[i-1]), 2*abs(delta[i]))
-
-    steps: List[float] = []
-    for step in range(1, n+1):
-        seg = _find_segment(xs, step)
-        x0, x1 = xs[seg], xs[seg+1]
-        h_s = x1 - x0
-        t   = max(0.0, min(1.0, (step-x0)/h_s if h_s>0 else 1.0))
-        t2, t3 = t*t, t*t*t
-        y = ((2*t3-3*t2+1)*ys[seg] + (t3-2*t2+t)*h_s*m[seg]
-           + (-2*t3+3*t2)*ys[seg+1] + (t3-t2)*h_s*m[seg+1])
-        steps.append(max(1.0, min(float(n), y)))
-    return steps
-
-
-def _catmull_rom(t: float, p0: float, p1: float, p2: float, p3: float) -> float:
-    t2 = t * t; t3 = t2 * t
-    return 0.5 * (2*p1 + (-p0+p2)*t + (2*p0-5*p1+4*p2-p3)*t2 + (-p0+3*p1-3*p2+p3)*t3)
-
-
-def _compute_remapped_steps_spline(vs: dict, n: int) -> List[float]:
-    xs = sorted(vs.keys()); ys = [float(vs[x]['y']) for x in xs]; k = len(xs)
-    y_ext = [2*ys[0]-ys[1]] + ys + [2*ys[-1]-ys[-2]]
-    steps: List[float] = []
-    for step in range(1, n+1):
-        seg = _find_segment(xs, step)
-        x0, x1 = xs[seg], xs[seg+1]
-        t = max(0., min(1., (step-x0)/(x1-x0) if x1>x0 else 1.))
-        i = seg+1
-        y = _catmull_rom(t, y_ext[i-1], y_ext[i], y_ext[i+1], y_ext[i+2])
-        steps.append(max(1., min(float(n), y)))
-    return steps
-
-
-def _apply_cutoff(sf: list[float], cs: int, total: int, blend: int = 4) -> list[float]:
-    """Плавный cutoff: W=blend шагов смешиваем кривую → identity, дальше чистая identity."""
-    if cs <= 0 or cs >= total:
-        return sf
-    out = sf[:]
-    blend_end = min(cs + blend, total)
-    blend_steps = blend_end - cs
-    for i in range(cs, blend_end):
-        alpha = (i - cs + 1) / blend_steps if blend_steps > 0 else 1.0
-        out[i] = out[i] * (1.0 - alpha) + float(i + 1) * alpha
-    for i in range(blend_end, total):
-        out[i] = float(i + 1)
-    return out
-
-
-def _build_hr_override(p, hr_enabled: bool, tm_hr: str, interp_mode: str, sched_name: str,
-                       cutoff_steps: int = 0, hr_cutoff_enabled: bool = True):
-    """Строит override для HR-прохода если все условия выполнены."""
-    if not hr_enabled:
-        return None
-    if not getattr(p, 'enable_hr', False):
-        return None
-    if not tm_hr or not tm_hr.strip():
-        return None
-
-    hr_steps = getattr(p, 'hr_second_pass_steps', 0)
-    if hr_steps <= 0:
-        hr_steps = p.steps
-
-    vs_hr = _parse_points(tm_hr)
-    if vs_hr is None:
-        return None
-
-    if len(vs_hr) < 2 or 1 not in vs_hr or hr_steps not in vs_hr:
-        msg = (f'HR кривая должна содержать x=1 и x={hr_steps} '
-               f'(x: {sorted(vs_hr.keys())})')
-        print(f'[TimeMachine] {msg}')
-        gr.Warning(f'[TimeMachine] {msg}')
-        return None
-
-    sf = _interpolate(vs_hr, hr_steps, interp_mode)
-    if len(sf) != hr_steps:
-        return None
-
-    if hr_cutoff_enabled and cutoff_steps > 0:
-        if hr_steps <= cutoff_steps:
-            hr_cs = max(1, round(cutoff_steps * hr_steps / p.steps))
-        else:
-            hr_cs = cutoff_steps
-        sf = _apply_cutoff(sf, hr_cs, hr_steps)
-
-    return sampler_utils.build_sigma_override(sf, sched_name)
-
-
-# ── Вспомогательные ──────────────────────────────────────
-
-def _parse_points(json_str: str) -> dict[int, dict] | None:
-    try:
-        pts = json.loads(json_str)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(pts, list):
-        return None
-    try:
-        result: dict[int, dict] = {}
-        for v in pts:
-            if isinstance(v, dict) and 'x' in v and 'y' in v:
-                x = int(v['x'])
-                result[x] = {
-                    'y': int(v['y']),
-                    'mode': v.get('mode') or None,
-                }
-        return result
-    except (KeyError, TypeError, ValueError):
-        return None
-
-
-def _get_self_extension():
-    self_path = os.path.abspath(__file__)
-    for ext in extensions.active():
-        if self_path.startswith(os.path.abspath(ext.path) + os.sep):
-            return ext
-
-
-def _js2py(name: str, id_: Callable, js_: Callable, sink: Any):
-    v_set  = gr.Button(elem_id=id_(f'{name}_set'))
-    v      = gr.Textbox(elem_id=id_(name))
-    v_sink = gr.Textbox()
-    v_set.click(fn=None, _js=js_(name), outputs=[v, v_sink])
-    v_sink.change(fn=None, _js=js_(f'{name}_after'), outputs=[sink])
-    return v
-
-
-init_xyz(Script, NAME)
-sampler_utils.register_ni_samplers()
-
-
-# ── FastAPI: real sigmas for JS ──────────────────────────────
-
-def _on_app_started(demo, app):
-    @app.get("/timemachine/sigmas")
-    def get_sigmas(scheduler: str = 'karras', steps: int = 20, sampler: str | None = None):
-        try:
-            if scheduler == 'Use sampler default' and sampler:
-                scheduler = sampler_utils.get_default_scheduler_for(sampler)
-            sigmas = sampler_utils.compute_sigmas(steps, scheduler)
-            return {"sigmas": sigmas.tolist()}
-        except Exception as e:
-            print(f'[TimeMachine] sigmas API error: {e}')
-            return JSONResponse(content={"sigmas": []}, status_code=500)
-
-script_callbacks.on_app_started(_on_app_started)

sd-webui-timemachine-fixed/scripts/timemachinelib/__init__.py

@@ -1,16 +0,0 @@
-from .sampler import (
-    build_sigma_override,
-    compute_sigmas,
-    get_default_scheduler_for,
-    get_scheduler_choices,
-    register_ni_samplers,
-    UNSUPPORTED_SAMPLERS,
-)
-from .xyz import init_xyz
-
-__all__ = [
-    'build_sigma_override', 'compute_sigmas',
-    'get_default_scheduler_for', 'get_scheduler_choices',
-    'register_ni_samplers', 'UNSUPPORTED_SAMPLERS',
-    'init_xyz',
-]

sd-webui-timemachine-fixed/scripts/timemachinelib/sampler.py

@@ -1,293 +0,0 @@
-# timemachinelib/sampler.py — v3.1 (bugfix)
-#
-# Исправления:
-#   - scheduler.need_inner_model → getattr (AttributeError на нестандартных планировщиках)
-#   - scheduler.default_rho     → getattr
-#   - opts.rho/sigma_min/sigma_max/use_old_karras → getattr (отсутствуют в ряде версий)
-#   - Удалён неиспользуемый Optional
-
-from __future__ import annotations
-
-import math
-
-import torch
-from modules import sd_schedulers, devices
-from modules.shared import opts
-
-
-def _build_model_wrap():
-    """k-diffusion denoiser wrapper. Поддерживает SD1/SD2/SDXL/SD3."""
-    from modules import shared
-    import k_diffusion.external
-
-    sd_model = shared.sd_model
-    if hasattr(sd_model, 'create_denoiser'):
-        return sd_model.create_denoiser()
-
-    param    = getattr(sd_model, 'parameterization', 'eps')
-    cls      = (k_diffusion.external.CompVisVDenoiser
-                if param == 'v' else k_diffusion.external.CompVisDenoiser)
-    quantize = getattr(opts, 'enable_quantization', False)
-    return cls(sd_model, quantize=quantize)
-
-
-def compute_sigmas(n: int, scheduler_name: str, model_wrap=None) -> torch.Tensor:
-    """Генерирует n+1 сигм (убывающие, последний = 0)."""
-    if model_wrap is None:
-        model_wrap = _build_model_wrap()
-
-    m_sigma_min = model_wrap.sigmas[0].item()
-    m_sigma_max = model_wrap.sigmas[-1].item()
-
-    # BUG-FIX: getattr вместо прямого обращения — атрибуты могут отсутствовать
-    if getattr(opts, 'use_old_karras_scheduler_sigmas', False):
-        sigma_min, sigma_max = 0.1, 10.0
-    else:
-        raw_min = getattr(opts, 'sigma_min', 0)
-        raw_max = getattr(opts, 'sigma_max', 0)
-        sigma_min = raw_min if raw_min != 0 else m_sigma_min
-        sigma_max = raw_max if raw_max != 0 else m_sigma_max
-
-    scheduler = sd_schedulers.schedulers_map.get(scheduler_name)
-    if scheduler is None or scheduler.function is None:
-        return model_wrap.get_sigmas(n).cpu()
-
-    kwargs: dict = {'sigma_min': sigma_min, 'sigma_max': sigma_max, 'device': devices.cpu}
-
-    # BUG-FIX: getattr с fallback — у нестандартных планировщиков атрибут может отсутствовать
-    if getattr(scheduler, 'need_inner_model', False):
-        kwargs['inner_model'] = model_wrap
-
-    default_rho = getattr(scheduler, 'default_rho', -1)
-    rho         = getattr(opts, 'rho', 0)
-    if default_rho != -1 and rho != 0 and rho != default_rho:
-        kwargs['rho'] = rho
-
-    return scheduler.function(n=n, **kwargs).cpu()
-
-
-def _lerp_sigma(full_sigmas: torch.Tensor, t: float) -> torch.Tensor:
-    """
-    Линейная интерполяция сигмы для дробной позиции t ∈ [1.0, max_idx].
-    t=1.0 → full_sigmas[0] (макс. шум)
-    t=max_idx → full_sigmas[max_idx-1] (мин. ненулевой шум)
-    """
-    n    = len(full_sigmas) - 1           # кол-во ненулевых позиций
-    lo   = max(0, int(math.floor(t)) - 1) # 0-based нижняя граница
-    hi   = min(lo + 1, n - 1)             # 0-based верхняя (не выходим за 0-элемент)
-    frac = t - math.floor(t)
-    return full_sigmas[lo] * (1.0 - frac) + full_sigmas[hi] * frac
-
-
-def build_sigma_override(steps_float: list[float], scheduler_name: str):
-    """
-    Возвращает функцию для p.sampler_noise_scheduler_override.
-
-    steps_float  — float позиции (1-based) в sigma-расписании, одна на каждый UI-шаг.
-    scheduler_name — имя планировщика ('karras', 'exponential', ...)
-    """
-    max_idx = math.ceil(max(steps_float))
-
-    def override(n: int) -> torch.Tensor:
-        """n = p.steps (или +1 при discard_next_to_last_sigma)."""
-        model_wrap  = _build_model_wrap()
-        full_sigmas = compute_sigmas(max_idx, scheduler_name, model_wrap)
-
-        selected = [_lerp_sigma(full_sigmas, t) for t in steps_float]
-
-        delta = n - len(selected)
-        if delta > 0:
-            last    = selected[-1]
-            min_sig = full_sigmas[-2]          # минимальная ненулевая
-            for i in range(1, delta + 1):
-                alpha = i / (delta + 1)
-                selected.append(last * (1.0 - alpha) + min_sig * alpha)
-        elif delta < 0:
-            selected = selected[:n]
-
-        return torch.cat([torch.stack(selected), full_sigmas[-1:]])
-
-    return override
-
-
-def get_default_scheduler_for(sampler_name: str) -> str:
-    """Возвращает scheduler по умолчанию для данного семплера."""
-    from modules import sd_samplers
-    config = sd_samplers.find_sampler_config(sampler_name)
-    if config:
-        return config.options.get('scheduler', 'karras')
-    return 'karras'
-
-
-def get_scheduler_choices() -> list[str]:
-    """Список планировщиков для UI-дропдауна."""
-    skip = {'automatic', 'Automatic'}
-    return ['Use sampler default'] + [
-        s.label
-        for s in sd_schedulers.schedulers
-        if s.name not in skip and s.label not in skip and s.function is not None
-    ]
-
-
-UNSUPPORTED_SAMPLERS = {'DPM fast', 'DPM adaptive'}
-
-
-# ═══════════════════════════════════════════════════════════════
-# Noise Injection (NI) семплеры
-#
-# Физическая идея: когда σ растёт между шагами (Time Travel),
-# латент находится «слишком чистым» для текущего уровня шума.
-# Правильное решение — добавить шум: x += √(σ²_{k+1} − σ²_k) · ε
-#
-# Кастомные циклы обязательны: стандартные сэмплеры k-diffusion
-# не знают о noise injection, и обёртка модели не может обновить
-# x во внешней функции (см. NIModelWrapper — удалена как ошибочная).
-# ═══════════════════════════════════════════════════════════════
-
-import tqdm as _tqdm
-from modules import sd_samplers, sd_samplers_common
-import modules.sd_samplers_kdiffusion as K
-
-
-class TimeMachineEulerNI:
-    """
-    Euler + Noise Injection. Кастомный цикл — NI модифицирует x
-    напрямую, затем вычисляется стандартный Euler-шаг.
-    """
-    @torch.no_grad()
-    def __call__(self, model, x, sigmas, extra_args=None, callback=None, disable=None,
-                 s_churn=0., s_tmin=0., s_tmax=float('inf'), s_noise=1., **kwargs):
-        extra_args  = extra_args or {}
-        s_in        = x.new_ones([x.shape[0]])
-        last_sigma: float | None = None
-        n_steps     = len(sigmas) - 1
-
-        for i in _tqdm.tqdm(range(n_steps), disable=disable):
-            sigma_curr = sigmas[i]
-            sigma_next = sigmas[i + 1]
-
-            # ── Noise Injection (σ выросла → добавить шум) ──────────
-            sv = sigma_curr.item()
-            if last_sigma is not None and sv > last_sigma:
-                delta_var = sv ** 2 - last_sigma ** 2
-                if delta_var > 0:
-                    x = x + torch.randn_like(x) * math.sqrt(delta_var)
-            last_sigma = sv
-
-            # ── s_churn (ε-буст для exploration) ─────────────────────
-            gamma = min(s_churn / n_steps, math.sqrt(2) - 1) if s_tmin <= sv <= s_tmax else 0.
-            sigma_hat = sigma_curr * (gamma + 1)
-            if gamma > 0:
-                eps = torch.randn_like(x) * s_noise
-                x = x + eps * math.sqrt(sigma_hat ** 2 - sv ** 2)
-
-            # ── Euler шаг ────────────────────────────────────────────
-            denoised = model(x, sigma_hat * s_in, **extra_args)
-            if callback is not None:
-                callback({'x': x, 'i': i, 'sigma': sigma_hat,
-                          'sigma_hat': sigma_hat, 'denoised': denoised})
-
-            d = (x - denoised) / sigma_hat
-            dt = sigma_next - sigma_hat
-            x = x + d * dt
-
-        return x
-
-
-class TimeMachineDPM2MNI:
-    """
-    DPM++ 2M + Noise Injection.
-
-    Кастомный цикл: при NI кеш old_denoised сбрасывается,
-    иначе второй порядок использует значение с неверного состояния.
-    """
-    @torch.no_grad()
-    def __call__(self, model, x, sigmas, extra_args=None, callback=None, disable=None, **kwargs):
-        extra_args  = extra_args or {}
-        s_in        = x.new_ones([x.shape[0]])
-        sigma_fn    = lambda t: t.neg().exp()
-        t_fn        = lambda s: s.log().neg()
-        old_denoised = None
-        last_sigma: float | None = None
-
-        for i in _tqdm.tqdm(range(len(sigmas) - 1), disable=disable):
-            sigma_curr = sigmas[i]
-            sigma_next = sigmas[i + 1]
-
-            # ── Noise Injection ──────────────────────────────────────
-            sv = sigma_curr.item()
-            if last_sigma is not None and sv > last_sigma:
-                delta_var = sv ** 2 - last_sigma ** 2
-                if delta_var > 0:
-                    x = x + torch.randn_like(x) * math.sqrt(delta_var)
-                old_denoised = None          # кеш невалиден после re-noise
-            last_sigma = sv
-
-            # ── DPM++ 2M шаг ───────────���─────────────────────────────
-            denoised = model(x, sigma_curr * s_in, **extra_args)
-            if callback is not None:
-                callback({'x': x, 'i': i, 'sigma': sigma_curr,
-                          'sigma_hat': sigma_curr, 'denoised': denoised})
-
-            t, t_next = t_fn(sigma_curr), t_fn(sigma_next)
-            h = t_next - t
-
-            if old_denoised is None or sigma_next == 0 or h == 0:
-                # Euler: первый шаг, после NI-сброса, последний шаг,
-                # или flat sigma (h=0 — деление на ноль в 2M формулах)
-                x = (sigma_fn(t_next) / sigma_fn(t)) * x - (-h).expm1() * denoised
-            else:
-                # DPM++ 2M второй порядок
-                h_last = t - t_fn(sigmas[i - 1])
-                r = h_last / h
-                denoised_d = (1 + 1 / (2 * r)) * denoised - (1 / (2 * r)) * old_denoised
-                x = (sigma_fn(t_next) / sigma_fn(t)) * x - (-h).expm1() * denoised_d
-
-            old_denoised = denoised
-
-        return x
-
-
-# ─────────────────────────────────────────────────────────────────
-# Регистрация NI семплеров в A1111 с поддержкой s_churn
-# ─────────────────────────────────────────────────────────────────
-
-class _TMSampler(K.KDiffusionSampler):
-    """
-    Обёртка над KDiffusionSampler, которая форсирует extra_params
-    для s_churn/s_tmin/s_tmax/s_noise (родной A1111 маппинг
-    sampler_extra_params не работает для TM-сэмплеров, т.к.
-    ключуется по строковому имени функции, а у нас — объект).
-    """
-    def __init__(self, func, sd_model, options=None):
-        super().__init__(func, sd_model, options)
-        self.extra_params = ['s_churn', 's_tmin', 's_tmax', 's_noise']
-
-
-def register_ni_samplers() -> None:
-    """
-    Добавляет 'TM Euler (NI)' и 'TM DPM++ 2M (NI)' в список семплеров A1111.
-    Используются совместно с TimeMachine: sigma override задаёт расписание,
-    NI добавляет физически правильный шум при backward-шагах.
-    Без TimeMachine ведут себя идентично Euler / DPM++ 2M (NI не срабатывает).
-    """
-    ni_entries = [
-        ('TM Euler (NI)',     TimeMachineEulerNI(),  ['k_tm_euler_ni'],    {}),
-        ('TM DPM++ 2M (NI)', TimeMachineDPM2MNI(),  ['k_tm_dpmpp2m_ni'], {'scheduler': 'karras'}),
-    ]
-    added = False
-    for label, func, aliases, options in ni_entries:
-        if label not in [x.name for x in sd_samplers.all_samplers]:
-            # default-аргументы f= и o= фиксируют текущие значения в closure
-            data = sd_samplers_common.SamplerData(
-                label,
-                lambda model, f=func, o=options: _TMSampler(f, model, options=o),
-                aliases,
-                options,
-            )
-            sd_samplers.all_samplers.append(data)
-            added = True
-
-    if added:
-        sd_samplers.set_samplers()
-        sd_samplers.all_samplers_map = {x.name: x for x in sd_samplers.all_samplers}

sd-webui-timemachine-fixed/scripts/timemachinelib/xyz.py

@@ -1,74 +0,0 @@
-# xyz.py — v7: индексы под UI с 9 компонентами
-# [enabled, scheduler, interp_mode, tm, hr_enabled, tm_hr, cutoff_steps, hr_cutoff, one_shot]
-#   0=enabled  1=scheduler  2=interp  4=hr_enabled  6=cutoff_steps  7=hr_cutoff  8=one_shot
-
-import os
-
-from modules import scripts
-from modules.processing import StableDiffusionProcessingTxt2Img
-
-
-def __set_value(p, script, index, value):
-    args = list(p.script_args)
-    all_s = (scripts.scripts_txt2img.scripts if isinstance(p, StableDiffusionProcessingTxt2Img)
-             else scripts.scripts_img2img.scripts)
-    for idx in [x.args_from for x in all_s if isinstance(x, script)]:
-        if idx is not None:
-            args[idx + index] = value
-    p.script_args = type(p.script_args)(args)
-
-
-def to_bool(v: str):
-    if not v: return False
-    v = v.strip().lower()
-    if v == 'true':  return True
-    if v == 'false': return False
-    try: return bool(int(v))
-    except (ValueError, TypeError):
-        raise ValueError('value must be True/False/1/0')
-
-
-class AxisOptions:
-    def __init__(self, AxisOption, axis_options):
-        self.AxisOption = AxisOption; self.target = axis_options; self.options = []
-    def __enter__(self): self.options.clear(); return self
-    def __exit__(self, *_):
-        for opt in self.options: self.target.append(opt)
-        self.options.clear()
-    def create(self, name, type_fn, action, choices=None):
-        return (self.AxisOption(name, type_fn, action, choices=lambda: choices)
-                if choices else self.AxisOption(name, type_fn, action))
-    def add(self, opt): self.options.append(opt)
-
-
-_xyz_registered = False
-
-def init_xyz(script, ext_name):
-    global _xyz_registered
-    if _xyz_registered: return
-    for data in scripts.scripts_data:
-        if os.path.basename(data.path) not in ('xy_grid.py','xyz_grid.py'): continue
-        if not hasattr(data.module,'AxisOption') or not hasattr(data.module,'axis_options'): continue
-        AO = data.module.AxisOption; ao = data.module.axis_options
-        if not isinstance(AO, type) or not isinstance(ao, list): continue
-        try: _create_options(script, ext_name, AO, ao)
-        except Exception as e:
-            print(f'[TimeMachine] Не удалось зарегистрировать XYZ-опции: {e}')
-    _xyz_registered = True
-
-
-def _create_options(script, ext_name, AO, ao):
-    from scripts.timemachinelib.sampler import get_scheduler_choices
-    with AxisOptions(AO, ao) as opts:
-        def define(param, index, type_fn, choices=None):
-            def fn(p, x, xs): __set_value(p, script, index, x)
-            return opts.create(f'{ext_name} {param}', type_fn, fn, choices)
-        for opt in [
-            define('Enabled',       0, to_bool, ['false','true']),
-            define('Scheduler',     1, str,     get_scheduler_choices()),
-            define('Interpolation', 2, str,     ['Linear','Smooth (spline)','Step','Monotone','Ease In','Ease Out','Ease In-Out','Cubic','Exponential']),
-            define('HR Enabled',    4, to_bool, ['false','true']),
-            define('Cutoff Steps',  6, int),
-            define('HR Cutoff',     7, to_bool, ['false','true']),
-            define('One-shot',      8, to_bool, ['false','true']),
-        ]: opts.add(opt)